年月に分割するとなった場合、無理くりこんな感じが思い浮かぶ。
┌──────────────────────────────────────┐
│SELECT CONVERT([int],                                                       │
│     LEFT( MAX(FORMAT([年], '0000') + '/' + FORMAT([月], '00')), 4)) AS [年],│
│       CONVERT([int],                                                       │
│    RIGHT(MAX(FORMAT([年], '0000') + '/' + FORMAT([月], '00')), 2)) AS [月] │
│    FROM (                                                                  │
│        VALUES (2024, 12),                                                  │
│               (2025,  1),                                                  │
│               (2025,  2)                                                   │
│    ) AS [表]([年], [月]);                                                  │
│--→年「2025」、月「2」                                                     │
└──────────────────────────────────────┘

しかし、ここまでくるとハナから日付型にしてしまった方がシンプルでわかりやすい。
┌──────────────────────────────────────┐
│SELECT YEAR( MAX(DATEFROMPARTS([年], [月], 1))) AS [年],                    │
│       MONTH(MAX(DATEFROMPARTS([年], [月], 1))) AS [月]                     │
│FROM (                                                                      │
│    VALUES (2024, 12),                                                      │
│           (2025,  1),                                                      │
│           (2025,  2)                                                       │
│) AS T([年], [月]);                                                         │
│--→年「2025」、月「2」                                                     │
└──────────────────────────────────────┘

それぞれで最大値をとるとおかしなことになる。
┌──────────────────────────────────────┐
│SELECT FORMAT(MAX([年]), '0000') + '/' + FORMAT(MAX([月]), '00')            │
│    FROM (                                                                  │
│        VALUES (2024, 12),                                                  │
│               (2025,  1),                                                  │
│               (2025,  2)                                                   │
│    ) AS [表]([年], [月]);                                                  │
│--→「2025/12」                                                             │
└──────────────────────────────────────┘

でも、結合してから最大値をとれば、案外簡単にうまくいく。
┌──────────────────────────────────────┐
│SELECT MAX(FORMAT([年], '0000') + '/' + FORMAT([月], '00'))                 │
│    FROM (                                                                  │
│        VALUES (2024, 12),                                                  │
│               (2025,  1),                                                  │
│               (2025,  2)                                                   │
│    ) AS [表]([年], [月]);                                                  │
│--→「2025/02」                                                             │
└──────────────────────────────────────┘

もちろん最小値でも同様。

Ｑ．インデックスをテーブルのあるDBとは別のDBにはることができるか？
    (インデックス領域を別DBに移し、領域の効率化をはかる)
Ａ．できない
┌──────────────────────────────────────┐
│CREATE NONCLUSTERED INDEX [索引] ON [DB1].[dbo].[表] …                     │
└──────────────────────────────────────┘
    上記を[DB2]で実行して、[DB1]上でインデックスがはられる
    ([DB1]で実行したのと同じ結果になる)
    また、下記のような指定もできない
┌──────────────────────────────────────┐
│CREATE NONCLUSTERED INDEX [DB2].[dbo].[索引] ON [DB1].[dbo].[表] …         │
└──────────────────────────────────────┘

┌────────────┬─────────────────────────┐
│クラスタ化インデックス  │(基本的に)主キー(*1)、テーブルに一つのみ設定可能  │
│                        │実データがその並びになるので検索は爆速            │
│                        │*1：敢えて主キーを非クラスタ化し                  │
│   PRIMARY KEY CLUSTERED│    他インデックスにクラスタ化を譲ることも可能    │
├────────────┼─────────────────────────┤
│非クラスタ化インデックス│一般的なインデックス(クラスタ化以外のインデックス)│
│                        │実データとは別に検索列と行ポインタの並びを保存する│
│      NONCLUSTERED INDEX│更新時に時間がかかり、インデックスサイズを消費する│
├────────────┼─────────────────────────┤
│カバリングインデックス  │インデックスに検索列以外に参照列も含めて          │
│複合インデックス(の活用)│行を参照することなくインデックス内で参照を完結させ│
│                        │検索を高速化する手法(参照列は検索列と相違なし)    │
│                  ON (,)│但し、その分インデックスサイズが肥大化する        │
├────────────┼─────────────────────────┤
│付加列インデックス      │カバリングインデックスのサイズを削減したもの      │
│             INCLUDE (,)│参照列を検索列と分ける(参照専門にする)ことで実現  │
└────────────┴─────────────────────────┘

┌──────────────────────────────────────┐
│EXECUTE sp_spaceused;                                                       │
└──────────────────────────────────────┘
上記をDBにて実行すると、以下の結果が取得できる。
┌─────────┬─────────┬─────────┐
│database_name     │database_size     │unallocated space │
├─────────┼─────────┼─────────┤
│(DB名)            │①       xxxx.xxMB│②       xxxx.xxMB│
└─────────┴─────────┴─────────┘
┌───────┬───────┬───────┬───────┐
│reserved      │data          │index_size    │unused        │
├───────┼───────┼───────┼───────┤
│③      xxxxKB│④      xxxxKB│⑤      xxxxKB│⑥      xxxxKB│
└───────┴───────┴───────┴───────┘

実体ファイル(のサイズ)との関係は以下の通り
・データ「(DB名).mdf」  ＝②＋③  (なお、③＝④＋⑤＋⑥)
・ログ「(DB名)_log.ldf」＝①－(②＋③)

つまり
・①＝データ「(DB名).mdf」＋ログ「(DB名)_log.ldf」
  →プロパティに表示される「サイズ」も①である

ストアドプロシージャでSQL文を出力する方法。

例えば、以下のような感じでSQL文を編集して、実行できたりする。
┌──────────────────────────────────────┐
│CREATE PROCEDURE [dbo].[PROCEDURE_テスト]                                   │
│AS                                                                          │
│BEGIN                                                                       │
│    DECLARE @sql    [nvarchar](max);                                        │
│    SET @sql = 'SELECT ' + CHAR(39) + '結果' + CHAR(39) + ';';              │
│    EXECUTE (@sql);                                                         │
│END;                                                                        │
│--→出力されるのは「結果」一行                                              │
└──────────────────────────────────────┘
EXECUTE()のところを、直接SQL文に置き換えてもOK

以下のような感じで実行する。
┌──────────────────────────────────────┐
│EXEC [dbo].[PROCEDURE_テスト];                                              │
└──────────────────────────────────────┘

スドアドファンクションのように、他SQL文との連携に融通は利かないが
Power BIでもSQL文指定でテーブルに値をひっぱってきたりできるし
PHPでもPDOで連想配列にひっぱってきたりできる。

JavaScriptのparseInt()のように、文字列込みの数値の文字列を
数値にいい感じで変換するには、TRANSLATE()を使えば実現できる。
けど、ちとめんどくさい。(もっといい方法がありそうだが)
例）「1個」→「1」
┌──────────────────────────────────────┐
│SELECT [文字列],                                                            │
│       CONVERT([int],                                                       │
│               REPLACE(TRANSLATE([文字列],                                  │
│                                 [除外文字],                                │
│                                 REPLICATE(' ', LEN([除外文字]))            │
│                       ),                                                   │
│                       ' ',                                                 │
│                       '')                                                  │
│       ) AS [数値]                                                          │
│    FROM (                                                                  │
│        SELECT [文字列],                                                    │
│               TRANSLATE([文字列],                                          │
│                         '0123456789',                                      │
│                         REPLICATE(' ', 10)) AS [除外文字]                  │
│            FROM (                                                          │
│                VALUES                                                      │
│('1個'),                                                                    │
│('全23セット')                                                              │
│            ) AS [表]([文字列])                                             │
│    ) AS [表]                                                               │
└──────────────────────────────────────┘

複数行を横一列にする方法として、MSSQLでは「FOR XML PATH」を用いる。
その意味をもう一度復習

「FOR XML PATH」をつけると、XML形式として横一列に表示ができる。
┌──────────────────────────────────────┐
│WITH [表] AS (                                                              │
│         SELECT * FROM (VALUES ('A'),                                       │
│                               ('B'),                                       │
│                               ('C')) AS [表]([列])                         │
│     )                                                                      │
│SELECT [列]                                                                 │
│    FROM [表]                                                               │
│    FOR XML PATH ('');                                                      │
│--→「<列>A</列><列>B</列><列>C</列>」                                      │
└──────────────────────────────────────┘
通常は列名でタグが付いてくる。

これを、列名[data()]にすると、スペース区切りにすることができる
┌──────────────────────────────────────┐
│WITH [表] AS (                                                              │
│         SELECT * FROM (VALUES ('A'),                                       │
│                               ('B'),                                       │
│                               ('C')) AS [表]([列])                         │
│     )                                                                      │
│SELECT [列] AS [data()]                                                     │
│    FROM [表]                                                               │
│    FOR XML PATH ('');                                                      │
│--→「A B C」                                                               │
└──────────────────────────────────────┘
内側だけにスペースが付くので便利。
このスペースを区切り文字に置換すればよいわけだ。

では列名をなくしてしまえばどうだろう。
どのようなやり方でもよいがAS句で列名を指定しなければないけない形にもっていく。
(以下の場合は人畜無害な空文字を付加する形をとってみた)
┌──────────────────────────────────────┐
│WITH [表] AS (                                                              │
│         SELECT * FROM (VALUES ('A'),                                       │
│                               ('B'),                                       │
│                               ('C')) AS [表]([列])                         │
│     )                                                                      │
│SELECT [列] + ''                                                            │
│    FROM [表]                                                               │
│    FOR XML PATH ('');                                                      │
│--→「ABC」                                                                 │
└──────────────────────────────────────┘
これで列名によるタグがなくなるが、今度は区切りがまったくなくなってしまう。

ということで、自前で区切り文字をあらかじめつけたのが以下。
┌──────────────────────────────────────┐
│WITH [表] AS (                                                              │
│         SELECT * FROM (VALUES ('A'),                                       │
│                               ('B'),                                       │
│                               ('C')) AS [表]([列])                         │
│     )                                                                      │
│SELECT [列] + ','                                                           │
│    FROM [表]                                                               │
│    FOR XML PATH ('');                                                      │
│--→「A,B,C,」                                                              │
└──────────────────────────────────────┘
好きな区切り文字を指定できるが、外側にもついてしまうのが難点。


ちなみに「',' + [列]」と逆にすると、「,A,B,C」になる。
┌──────────────────────────────────────┐
│WITH [表] AS (                                                              │
│         SELECT * FROM (VALUES ('A'),                                       │
│                               ('B'),                                       │
│                               ('C')) AS [表]([列])                         │
│     )                                                                      │
│SELECT STUFF((SELECT ',' + [列]                                             │
│                  FROM [表]                                                 │
│                  FOR XML PATH ('')), 1, 1, '');                            │
│--→「A,B,C」                                                               │
└──────────────────────────────────────┘
そこでSTUFF関数と組み合わせればなんとなくいけるかも。

列名[data()]のやり方だとデータ中に半角スペースが混じっていると
破綻してしまうのだが、以下のような感じで
使われないであろう文字を区切り文字にして回避することができてしまう。
┌──────────────────────────────────────┐
│WITH [表] AS (                                                              │
│         SELECT * FROM (VALUES ('A X'),                                     │
│                               ('B Y'),                                     │
│                               ('C Z')) AS [表]([列])                       │
│     )                                                                      │
│SELECT REPLACE(STUFF((SELECT '\n' + [列]                                    │
│                          FROM [表]                                         │
│                          FOR XML PATH ('')), 1, 2, ''), '\n', CHAR(10));   │
│--→「A X                                                                   │
│      B Y                                                                   │
│      C Z」                                                                 │
└──────────────────────────────────────┘

他テーブルをJOINしてUPDATEする場合、複数行になったらどうなるのか？
┌──────────────────────────────────────┐
│GO                                                                          │
│    DECLARE @テストＤ table (                                               │
│        [列]    [nvarchar](16)  NULL                                        │
│    );                                                                      │
│    INSERT INTO @テストＤ VALUES (NULL);                                    │
│    UPDATE [出力Ｄ]                                                         │
│        SET [列] = [入力Ｄ].[列]                                            │
│        FROM @テストＤ AS [出力Ｄ]                                          │
│            CROSS JOIN (                                                    │
│                SELECT *                                                    │
│                    FROM (                                                  │
│                        VALUES ('A'),                                       │
│                               ('B'),                                       │
│                               ('C')                                        │
│                    ) AS [入力Ｄ]([列])                                     │
│            ) AS [入力Ｄ];                                                  │
│    SELECT * FROM @テストＤ;                                                │
│GO                                                                          │
│--→「A」に更新された                                                       │
└──────────────────────────────────────┘
最初のレコードが優先される。

でも、最初ってなんだよ？問題が発生する恐れがあるので、
あまり使わない方がよいだろう。
ひとまず二重キーエラーとかにならないので、対策は軽くてよいということで。

┌──────────────────────────────────────┐
│SELECT DATEADD([week],                                                      │
│               週番号 - 1,                                                  │
│               DATEADD([dd],                                                │
│                       1 - DATEPART([dw], DATEFROMPARTS(年, 1, 1)),         │
│                       DATEFROMPARTS(年, 1, 1))) AS [週頭日]                │
└──────────────────────────────────────┘
もっといい方法はないものか？