分類するとこんな感じか？
┌─────┬────────────────────────────────┐
│機能要件  │明示された要求事項                                              │
│          │・いわゆる本開発の目玉機能                                      │
├─────┼────────────────────────────────┤
│暗黙の要件│明示しなくとも満たされるべき要求事項                            │
│          │・誤った情報がないこと(誤解しやすい表現や誤字脱字などがないこと)│
│          │・UI/UXが使いやすいこと(並び順・メッセージ・画面遷移など)       │
├─────┼────────────────────────────────┤
│非機能要件│主にインフラ(ハードウェア)関係の暗黙の要件                      │
│          │・性能(速度と容量)  …運用に耐えうる速度や容量を満たしていること│
│          │・信頼性と可用性    …壊れにくく壊れても対策がなされていること  │
│          │・拡張性と移植性    …次のステップへ進むこともできること        │
│          │・安全性            …いわゆるセキュリティ対策(侵入・改竄・漏洩)│
│          │・運用保守性        …実運用全般として扱いやすいこと            │
└─────┴────────────────────────────────┘
非機能要件には暗黙の要件も含まれるっぽいが
一般的に非機能要件っていったらインフラが主だったりもするのかなぁ。
よくわからん。

SQL文のDEFAULT定義は、あくまで列が指定されなかった場合の既定値であり
NULLを代入した場合の代替値ではないことに注意。
○INSERT文にて列が指定されなかった場合には基本的にNULLが代入される
○この場合、DEFAULT定義があった場合にはその値が代入される
○UPDATE文にてNULLを代入しても、DEFAULT定義の値は無視される
×INSERT文にてNULLを代入したら、DEFAULT定義の値が代入される
  →NULLが代入される

よって、NOT NULL制約とDEFAULT定義が両方定義してある列について
DEFAULT定義があるから(NOT NULL制約にはひっかからなくて)安心というのは間違いだ。

SQL文のDEFAULT定義は、あくまで列が指定されなかった場合の既定値であり
NULLを代入した場合の代替値ではないことに注意。
○INSERT文にて列が指定されなかった場合には基本的にNULLが代入される
○この場合、DEFAULT定義があった場合にはその値が代入される
○UPDATE文にてNULLを代入しても、DEFAULT定義の値は無視される
×INSERT文にてNULLを代入したら、DEFAULT定義の値が代入される
  →NULLが代入される

よって、NOT NULL制約とDEFAULT定義が両方定義してある列について
DEFAULT定義があるから(NOT NULL制約にはひっかからなくて)安心というのは間違いだ。

そして、それが如実に現れるのがExcelVBAのADODB。

「テーブル.AddNew」した瞬間に、全ての列にNULLがセットされるので
「テーブル.Fields(列).Value = 値」で値を代入しないと
NULLが代入されることになる。(列が指定されないのではない)

例えば、「列2」に対する代入処理がない場合は、以下のような扱いになる訳だ。
┌─┬────────────────────────────────────┐
│×│INSERT 表 (列1)      VALUES (値2);                                      │
├─┼────────────────────────────────────┤
│○│INSERT 表 (列1, 列2) VALUES (値1, NULL);                                │
└─┴────────────────────────────────────┘

例えば以下のようにtdタグ直下にテキスト文とタグが混在していて
テキストだけ除去する方法。
┌──────────────────────────────────────┐
│<td>あいうえお<input type="text" value="かきくけこ"/></td>                  │
└──────────────────────────────────────┘

ちなみにタグ側だけ削除するには、以下みたいな感じで簡単なのだが。
┌──────────────────────────────────────┐
│$('td').children().remove();                                                │
└──────────────────────────────────────┘

一番確実な対処法としてはtd直下にテキストを置くのではなく、spanタグを介する方法。
┌──────────────────────────────────────┐
│<td><span>あいうえお</span><input type="text" value="かきくけこ"/></td>     │
└──────────────────────────────────────┘
そうすると以下のように素直に処理ができる。
┌──────────────────────────────────────┐
│$('td').children('span').remove();                                          │
├──────────────────────────────────────┤
│$('td').children().remove('span');                                          │
└──────────────────────────────────────┘

とはいえ、spanタグを今さら追加できないという事情の場合の対処方法。
すばり、テキストで取得したものを置換で除去してしまう！
┌──────────────────────────────────────┐
│$('td').html(                                                               │
│    $('td').html().replace($('td').text(), '')                              │
│);                                                                          │
└──────────────────────────────────────┘
なお、.text()は改行を認識するが、.html()は改行を除去してしまうという特性があり
たいていは上記ではうまくいかないようだ。
(<td>から</td>まで一行で書かれている場合のみうまくいく)

ということで、改行コードを除去した上で置換すればいけそうだ。
┌──────────────────────────────────────┐
│$('td').html(                                                               │
│    $('td').html().replace(                                                 │
│        $('td').text().replace(/\n/g, ''),                                  │
│        ''                                                                  │
│    )                                                                       │
│);                                                                          │
└──────────────────────────────────────┘

MSSQLにおけるbool型相当はbit型であるが、
SQL文中では「TRUE/FALSE」ではなく「1/0」で扱う。
よって、int型と同じなのかなと思うと当然ながら違うこともある。

その一つがExcelにおける文字列型のセルに出力した際に
「TRUE/FALSE」と表示される点だ。
なお、「TRUE」や「FALSE」といった文字列ではない点に注意。

Key-Value形式のテーブルで、Valueに他のKeyがある場合
それを繋げて最終的なValueを取得するSQL文。
なお、循環(無限ループ)の場合は、最初の階層の結果を返却する。
┌──────────────────────────────────────┐
│WITH [起点] (                                                               │
│        [キー],                                                             │
│        [バリュー]                                                          │
│    ) AS (                                                                  │
│        SELECT [キー],                                                      │
│               [バリュー]                                                   │
│            FROM 表 [表]                                                    │
│            WHERE [キー] = 値                                               │
│    ),                                                                      │
│    [再帰] (                                                                │
│        [キー],                                                             │
│        [階層],                                                             │
│        [直前キー],                                                         │
│        [バリュー],                                                         │
│        [循環]                                                              │
│    ) AS (                                                                  │
│        SELECT [キー],                                                      │
│               1                 AS [階層],                                 │
│               [キー]            AS [直前キー],                             │
│               [バリュー],                                                  │
│               0                 AS [循環]                                  │
│            FROM [起点]                                                     │
│        UNION ALL                                                           │
│        SELECT [再帰].[キー],                                               │
│               [再帰].[階層] + 1 AS [階層],                                 │
│               [表].[キー]       AS [直前キー],                             │
│               [表].[バリュー],                                             │
│               CASE                                                         │
│                 WHEN [再帰].[キー] = [表].[バリュー]                       │
│                   OR [再帰].[階層] > 99              THEN 1                │
│                 ELSE                                      0                │
│               END AS [循環]                                                │
│            FROM [再帰]                                                     │
│                INNER JOIN 表 AS [表]                                       │
│                  ON [表].[キー] = [再帰].[バリュー]                        │
│            WHERE [再帰].[循環] = 0                                         │
│    )                                                                       │
│SELECT [キー],                                                              │
│       [階層],                                                              │
│       [直前キー],                                                          │
│       [バリュー]                                                           │
│    FROM [再帰]                                                             │
│    WHERE [循環] = 0                                                        │
│      AND NOT EXISTS (                                                      │
│              SELECT *                                                      │
│                  FROM [再帰] AS [他]                                       │
│                  WHERE [他].[階層] > [再帰].[階層]                         │
│          )                                                                 │
│UNION ALL                                                                   │
│SELECT [キー],                                                              │
│       NULL       AS [階層],                                                │
│       NULL       AS [直前キー],                                            │
│       [バリュー]                                                           │
│    FROM [起点]                                                             │
│    WHERE EXISTS (                                                          │
│              SELECT *                                                      │
│                  FROM [再帰]                                               │
│                  WHERE [循環] = 1                                          │
│          )                                                                 │
└──────────────────────────────────────┘

【方法1】枠線を消す
  リボンメニュー「表示」の(「表示」の部にある)「■枠線」のチェックをはずす

【方法2】枠線を白色にする
  「セルの書式設定」の「罫線」タブにて、「色」を白として枠線を引く
  なお、これは背景色が白(もしくは色なし)の場合のみ有効で
  他の色に着色した場合には、(白ではなく)それと同色にする必要あり

【方法3】背景色を白色にする
  意外に盲点なのが背景色が着色されている場合に、枠線が消える点だ
  すべてのセルの(背景色が)白色だったりした場合などには、
  何か違うモードとなっているのかと勘違いしてしまいがぢである
  背景色をなくす(塗りつぶしなしにする)と枠線が復活する

【JSON→PHP配列】
┌──────────────────────────────────────┐
│$PHP配列 = json_decode($JSON, TRUE);                                        │
└──────────────────────────────────────┘

【PHP配列→JSON】
┌──────────────────────────────────────┐
│$JSON = json_encode($PHP配列);                                              │
└──────────────────────────────────────┘

【PHP配列→JSON】(わかりやすいように表示)
┌──────────────────────────────────────┐
│$JSON = json_encode($PHP配列, JSON_UNESCAPED_UNICODE|JSON_PRETTY_PRINT);    │
└──────────────────────────────────────┘
  (JSON_UNESCAPED_UNICODE＝日本語そのまま、JSON_PRETTY_PRINT＝整列)

従って、以下のようにすると、JSONをきれいに整形できる。
┌──────────────────────────────────────┐
│$PHP配列 = json_decode($JSON, TRUE);                                        │
│echo json_encode($PHP配列, JSON_UNESCAPED_UNICODE|JSON_PRETTY_PRINT);       │
└──────────────────────────────────────┘

キー列の値が同じ行が続くものを塊ともなし、
その塊ごとに番号を振る方法はないようなので、マクロを組んだ。

以下のような番号(二列目)を振りたいわけだ。
┌─┬─┐
│A │ 1│
├─┼─┤
│A │ 1│
├─┼─┤
│B │ 1│
├─┼─┤
│A │ 2│
├─┼─┤
│C │ 1│
├─┼─┤
│A │ 3│
└─┴─┘

┌──────────────────────────────────────┐
│Const X_キー As Long = 1                                                    │
│Const X_番号 As Long = 2                                                    │
│Dim yMax As Long, y1 As Long, y2 As Long                                    │
│Dim 番号 As Long, is違 As Boolean                                           │
│With シート                                                                 │
│    yMax = .UsedRange.Rows(.UsedRange.Rows.Count).Row                       │
│    .Columns(X_番号).ClearContents                                          │
│    For y1 = 1 To yMax                                                      │
│        If .Cells(y1, X_番号).Value = "" Then                               │
│            is違 = False                                                    │
│            番号 = 1                                                        │
│            For y2 = y1 To yMax                                             │
│                If .Cells(y2, X_キー).Value = .Cells(y1, X_キー).Value Then │
│                    If is違 Then                                            │
│                        is違 = False                                        │
│                        番号 = 番号 + 1                                     │
│                    End If                                                  │
│                    .Cells(y2, X_番号).Value = 番号                         │
│                Else                                                        │
│                    is違 = True                                             │
│                End If                                                      │
│            Next y2                                                         │
│        End If                                                              │
│    Next y1                                                                 │
│End With                                                                    │
└──────────────────────────────────────┘

UPSERT的な以下MERGE文、WHEN句は削ることができる。
(でも一つは残さないとエラーだけど)
┌──────────────────────────────────────┐
│MERGE INTO [出力Ｄ]                                                         │
│    USING [入力Ｄ]                                                          │
│      ON [入力Ｄ].[キー] = [出力Ｄ].[キー]                                  │
│    WHEN MATCHED THEN                                                       │
│        UPDATE SET [列] = [入力Ｄ].[列]                                     │
│    WHEN NOT MATCHED BY TARGET THEN                                         │
│        INSERT ([列]) VALUES ([入力Ｄ].[列])                                │
│;                                                                           │
└──────────────────────────────────────┘

以下だとINSERT同等。(重複していたらINSERTと違ってエラーにはならない)
┌──────────────────────────────────────┐
│MERGE INTO [出力Ｄ]                                                         │
│    USING [入力Ｄ]                                                          │
│      ON [入力Ｄ].[キー] = [出力Ｄ].[キー]                                  │
│----WHEN MATCHED THEN                                                       │
│----    UPDATE SET [列] = [入力Ｄ].[列]                                     │
│    WHEN NOT MATCHED BY TARGET THEN                                         │
│        INSERT ([列]) VALUES ([入力Ｄ].[列])                                │
│;                                                                           │
└──────────────────────────────────────┘

以下だとUPDATE同等。(該当がなかったらUPDATE同様無視)
┌──────────────────────────────────────┐
│MERGE INTO [出力Ｄ]                                                         │
│    USING [入力Ｄ]                                                          │
│      ON [入力Ｄ].[キー] = [出力Ｄ].[キー]                                  │
│    WHEN MATCHED THEN                                                       │
│        UPDATE SET [列] = [入力Ｄ].[列]                                     │
│----WHEN NOT MATCHED BY TARGET THEN                                         │
│----    INSERT ([列]) VALUES ([入力Ｄ].[列])                                │
│;                                                                           │
└──────────────────────────────────────┘

ちなみに「WHEN MATCHED THEN」は、「WHEN MATCHED THEN DELETE」(DELETE文)もできる。

なお、いずれも「THEN NEXT SENTENSE」的な空処理はできないようだ。
つまりWHEN句は上記のようにコメントアウトするか文を削除する他ない。

一つ以上WHEN句が必要だけどそれを空処理にすることはできない、
ということになるが、そうなるとまったく意味不明なので
そんなことできなくてよいのかもしれない。