┌──────────────────────────────────────┐
│CREATE PROCEDURE [dbo].[PROCEDURE_小数]                                     │
│    @引数小数               [decimal](8, 2)                                 │
└──────────────────────────────────────┘
MSSQLのストアドプロシージャの引数をdecimal型の小数で定義した場合
ExcelVBAのプレースホルダ的には、以下のような形式で値を指定してあげる。
┌──────────────────────────────────────┐
│Dim SQLコマンド As New ADODB.Command                                        │
│With SQLコマンド                                                            │
│    .ActiveConnection = mデータベース                                       │
│    .CommandType = adCmdStoredProc                                          │
│    .CommandText = "PROCEDURE_小数"                                         │
│    .NamedParameters = True                                                 │
│    .Parameters.Append .CreateParameter("@引数小数", adDecimal, adParamInput)
│    With .Parameters("@引数小数")                                           │
│        .Precision = 8                                                      │
│        .NumericScale = 2                                                   │
│    End With                                                                │
│    .Execute                                                                │
└──────────────────────────────────────┘

ストアドプロシージャでレコードを返すことになっているものの
条件分岐であきらかにレコードを返すものがない(0件レコードを返す)という時に
ダミーで0件レコードを返却したいが、適切な方法というのは見当たらない。

ということで、いくつか候補を考えてみた。
┌──────────────────────────────────────┐
│SELECT 1 WHERE 1 <> 1;                                                      │
├──────────────────────────────────────┤
│SELECT 0 WHERE 0 <> 0;                                                      │
├──────────────────────────────────────┤
│SELECT NULL WHERE NULL IS NOT NULL;                                         │
└──────────────────────────────────────┘
上に行くほど直感的、下に行くほど論理的ていう並びにしてみた。

とりあえず一番下のを推奨としたい。

ExcelVBAでADODBを使ってMSSQLに問い合わせをしたが
SQLの処理が長すぎてタイムアウトエラーとなってしまう場合
以下のようにタイムアウト時間を延長することができる。
┌──────────────────────────────────────┐
│Dim テーブル As New ADODB.Recordset                                         │
│Dim SQLコマンド As New ADODB.Command                                        │
│With SQLコマンド                                                            │
│    .CommandTimeout = 180   ' ←★接続時間延長(30秒→180秒)                 │
│    .ActiveConnection = (データベース接続情報)                              │
│    .CommandText = (SQL文)                                                  │
│End With                                                                    │
│テーブル.Open SQLコマンド                                                   │
└──────────────────────────────────────┘
但し、基本的に処理が長すぎるSQL文を見直すべきで(インデックスの追加など)
上記手段を行うのは最後の最後もしくは特例的に限定すべきである。

LIKE演算子で使える。
┌──────────────────────────────────────┐
│SELECT COUNT(*)                                                             │
│    FROM 表                                                                 │
│    WHERE [列] LIKE '[A-Z][0-9]%';                                          │
└──────────────────────────────────────┘
上記の場合は「A0」や「B1ABC」などが検索できる。

SELECT結果をCSV出力する方法。

一番オーソドックスなのは以下の形。
┌──────────────────────────────────────┐
│sqlcmd -S . -Q "SET NOCOUNT ON SELECT * FROM [表];" -h -1 -s, -W            │
│                                                         -o 出力ファイル.csv│
└──────────────────────────────────────┘

上記だと、ヘッダ表が出力されないので自前で出力する場合は以下の通り。
┌──────────────────────────────────────┐
│echo ヘッダ1,ヘッダ2,ヘッダ3> 出力ファイル.csv                              │
│sqlcmd -S . -Q "SET NOCOUNT ON SELECT * FROM [表];" -h -1 -s, -W            │
│                                                         >> 出力ファイル.csv│
└──────────────────────────────────────┘

ヘッダ出力を自動化するのなら、以下のような感じか。
┌──────────────────────────────────────┐
│sqlcmd -S . -Q "SET NOCOUNT ON SELECT * FROM [表] WHERE 1 <> 1;"            │
│                                 -h1 -s, -W | find /V "--"> 出力ファイル.csv│
│sqlcmd -S . -Q "SET NOCOUNT ON SELECT * FROM [表];" -h -1 -s, -W            │
│                                                         >> 出力ファイル.csv│
└──────────────────────────────────────┘
出力結果の最初の一行目のみ抽出もしくは最後の一行目のみ削除ってのを
Windowsコマンド上でできればいいのだが、難しいので断念。

こんな感じ。
┌──────────────────────────────────────┐
│SELECT ISNULL(CONVERT(varchar, [群]), '計') AS [群],                        │
│       ISNULL([縦]                  , '計') AS [縦],                        │
│       SUM([横１])   AS [横１],                                             │
│       SUM([横２])   AS [横２],                                             │
│       SUM([横３])   AS [横３],                                             │
│       SUM([計])  AS [計]                                                   │
│    FROM (                                                                  │
│        SELECT [群],                                                        │
│               [縦],                                                        │
│               [横１],                                                      │
│               [横２],                                                      │
│               [横３],                                                      │
│               ([横１] + [横２] + [横３]) AS [計]                           │
│            FROM [表]                                                       │
│                PIVOT (COUNT([ID])                                          │
│                           FOR [区分]                                       │
│                           IN ([横１],[横２],[横３])) AS [ピボット]         │
│        UNION ALL                                                           │
│        SELECT [群Ｄ].[群],                                                 │
│               [縦Ｄ].[縦],                                                 │
│               NULL                  AS [横１],                             │
│               NULL                  AS [横２],                             │
│               NULL                  AS [横３],                             │
│               NULL                  AS [計]                                │
│            FROM (                                                          │
│                SELECT DISTINCT [群]                                        │
│                    FROM [表]                                               │
│            ) AS [群Ｄ]                                                     │
│                CROSS JOIN (                                                │
│                    SELECT DISTINCT [縦]                                    │
│                        FROM [表]                                           │
│                ) AS [縦Ｄ]                                                 │
│    ) AS [ピボットＤ]                                                       │
│    GROUP BY GROUPING SETS (                                                │
│                 (),                                                        │
│                 ([縦]),                                                    │
│                 ([群]),                                                    │
│                 ([群],[縦])                                                │
│             )                                                              │
│    ORDER BY [群] ASC,                                                      │
│             [縦] ASC;                                                      │
└──────────────────────────────────────┘
こんな結果になる(はず)。
┌──┬──┬──┬──┬──┬──┐
│ 群 │ 縦 │横１│横２│横３│ 計 │
├──┼──┼──┼──┼──┼──┤
│    │    │    │    │    │    │
│    ├──┼──┼──┼──┼──┤
│    │    │    │    │    │    │
│    ├──┼──┼──┼──┼──┤
│    │ 計 │    │    │    │    │
├──┼──┼──┼──┼──┼──┤
│ 計 │ 計 │    │    │    │    │
└──┴──┴──┴──┴──┴──┘

LIKE演算子による部分一致判定を、列間で実行する場合。

意外に単純、'%'を文字列として結合してあげればよい。

列大が列小を内包しているもののみ抽出(部分一致検索)
┌──────────────────────────────────────┐
│SELECT *                                                                    │
│    FROM 表                                                                 │
│    WHERE 列大 LIKE '%' + 列小 + '%';                                       │
└──────────────────────────────────────┘

列大が列小を内包しているもののみ抽出(前方部分一致検索)
┌──────────────────────────────────────┐
│SELECT *                                                                    │
│    FROM 表                                                                 │
│    WHERE 列大 LIKE 列小 + '%';                                             │
└──────────────────────────────────────┘

date型の[日付]という列を、文字型(varchar(16))に型変換する時に
NULLが混じっていたら空文字('')にするというSQL文
ISNULL()とCONVERT()を駆使する訳だが、順番を間違えると以下の違いが出てしまう
┌──────────────────────────────────────┐
│SELECT ISNULL(CONVERT(varchar(16), [日付]), '') FROM 表;              →NULL│
├──────────────────────────────────────┤
│SELECT CONVERT(varchar(16), ISNULL([日付], '')) FROM 表;        →1900-01-01│
└──────────────────────────────────────┘

これはdate型に空文字('')を入れると、初期値(1900-01-01)になるからだ
┌──────────────────────────────────────┐
│SELECT ISNULL([日付], '') FROM 表;                              →1900-01-01│
└──────────────────────────────────────┘

一番単純な例は以下(空文字('')をdate型に型変換するとやはり初期値になる)
┌──────────────────────────────────────┐
│SELECT CONVERT(date, '');                                       →1900-01-01│
└──────────────────────────────────────┘

なので、順番を間違えないように気をつけなければならない

FORMAT()の引数にNULL直書きはエラーとなる
┌──────────────────────────────────────┐
│SELECT FORMAT(NULL,'0');                                                    │
│                 →引数のデータ型 NULL は format 関数の引数 1 では無効です。│
└──────────────────────────────────────┘

これはFORMAT()がNULLを許容していないのではなく、
型が不定なNULLを許容していないのだ

つまり、以下だとOK
┌──────────────────────────────────────┐
│SELECT FORMAT(CAST(NULL AS int),'0');                                 →NULL│
└──────────────────────────────────────┘

なので、テーブル上のNULLデータの場合は、テーブル定義で型も決まっているので
エラーとはならない

デバッグでうっかり勘違いしてしまいがちなところだ

[＋表]と[－表]を統合して時系列で二列に並べて累積を逐一計算する場合は、
以下のような感じ
┌──────────────────────────────────────┐
│SELECT [±表].[日付],                                                       │
│       CASE [±表].[±区分]                                                 │
│         WHEN 1 THEN '＋'                                                   │
│         WHEN 2 THEN '－'                                                   │
│       END AS [区分],                                                       │
│       [±表].[＋値],                                                       │
│       [±表].[－値],                                                       │
│       ISNULL((                                                             │
│           SELECT SUM([＋表].[値])                                          │
│               FROM [＋表]                                                  │
│               WHERE [＋表].[日付] < [±表].[日付]                          │
│                  OR  ([＋表].[日付]   =  [±表].[日付]                     │
│                   AND [＋表].[±区分] <= [±表].[±区分])                  │
│       ), 0) - ISNULL((                                                     │
│           SELECT SUM([－表].[値])                                          │
│               FROM [－表]                                                  │
│               WHERE [－表].[日付] < [±表].[日付]                          │
│                  OR  ([－表].[日付]   =  [±表].[日付]                     │
│                   AND [－表].[±区分] <= [±表].[±区分])                  │
│       ), 0) AS [累積]                                                      │
│    FROM (                                                                  │
│        SELECT [日付],                                                      │
│               1         AS [±区分],                                       │
│               SUM([値]) AS [＋値],                                         │
│               NULL      AS [－値]                                          │
│            FROM [＋表]                                                     │
│            GROUP BY [日付]                                                 │
│        UNION ALL                                                           │
│        SELECT [日付],                                                      │
│               2         AS [±区分],                                       │
│               NULL      AS [＋値],                                         │
│               SUM([値]) AS [－値]                                          │
│            FROM [－表]                                                     │
│            GROUP BY [日付]                                                 │
│    ) AS [±表]                                                             │
│    ORDER BY [±表].[日付]   ASC,                                           │
│             [±表].[±区分] ASC;                                           │
└──────────────────────────────────────┘
[－表]がなければ、もっとシンプルになる。
┌──────────────────────────────────────┐
│SELECT [±表].[日付],                                                       │
│       [±表].[＋値],                                                       │
│       ISNULL((                                                             │
│           SELECT SUM([＋表].[値])                                          │
│               FROM [＋表]                                                  │
│               WHERE [＋表].[日付] <= [±表].[日付]                         │
│       ), 0) AS [累積]                                                      │
│    FROM (                                                                  │
│        SELECT [日付],                                                      │
│               SUM([値]) AS [＋値]                                          │
│            FROM [＋表]                                                     │
│            GROUP BY [日付]                                                 │
│    ) AS [±表]                                                             │
│    ORDER BY [±表].[日付] ASC;                                             │
└──────────────────────────────────────┘