あるクラスのコンストラクタで他クラスを呼び出したら、どの順で実行されるか？
┌──────────────────────────────────────┐
│Public Sub 実験コンストラクタで他クラスを実行()                             │
│    Dim objクラス1 As New クラス1                                           │
│    Call objクラス1.実行                                                    │
│End Sub                                                                     │
├──────────────────────────────────────┤
│'クラス1.cls                                                                │
│Private Sub Class_Initialize()                                              │
│    Dim objクラス2 As New クラス2                                           │
│    Call objクラス2.実行                                                    │
│End Sub                                                                     │
│Public Sub 実行()                                                           │
│    MsgBox "②クラス1実行"                                                  │
│End Sub                                                                     │
├──────────────────────────────────────┤
│'クラス2.cls                                                                │
│Public Sub 実行()                                                           │
│    MsgBox "①クラス2実行"                                                  │
│End Sub                                                                     │
└──────────────────────────────────────┘
当たり前だが「コンストラクタ(→他クラスを実行)→自クラスを実行」の順で実行される

次はLetとGetの起動タイミングをみてみよう
┌──────────────────────────────────────┐
│Private メンバ変数 As Long                                                  │
├──────────────────────────────────────┤
│Property Let 実験プロパティ(ByVal 入力値 As Long)                           │
│    メンバ変数 = 入力値                                                     │
│    MsgBox "①Letが実行された"                                              │
│End Property                                                                │
├──────────────────────────────────────┤
│Property Get 実験プロパティ() As Long                                       │
│    実験プロパティ = メンバ変数                                             │
│    MsgBox "②Getが実行された"                                              │
│End Property                                                                │
├──────────────────────────────────────┤
│Sub 実験LetGet()                                                            │
│    実験プロパティ = 777                                                    │
│    MsgBox "③" & 実験プロパティ                                            │
│End Sub                                                                     │
└──────────────────────────────────────┘

今日から始まった実験シリーズ～！

まずは値渡しと参照渡しの違いを体感してみよう
┌──────────────────────────────────────┐
│Public Sub 実験値渡し()                                                     │
│    Dim 変数 As String                                                      │
│    変数 = "値渡し"                                                         │
│    Call サブ関数(変数)                                                     │
│    MsgBox 変数     ' →「値渡し」                                          │
│End Sub                                                                     │
├──────────────────────────────────────┤
│Private Sub サブ関数(ByVal 変数 As String)                                  │
│    変数 = "参照渡し"                                                       │
│End Sub                                                                     │
└──────────────────────────────────────┘
┌──────────────────────────────────────┐
│Public Sub 実験参照渡し()                                                   │
│    Dim 変数 As String                                                      │
│    変数 = "値渡し"                                                         │
│    Call サブ関数(変数)                                                     │
│    MsgBox 変数     ' →「参照渡し」                                        │
│End Sub                                                                     │
├──────────────────────────────────────┤
│Private Sub サブ関数(変数 As String)                                        │
│    変数 = "参照渡し"                                                       │
│End Sub                                                                     │
└──────────────────────────────────────┘

「Application.Goto」命令で、特定のセルに飛んでも、
フォーカスがあたるだけで、アクティブ(セレクト)になる訳ではない場合ある。

つまり、ボタン押下のイベントで「Application.Goto」命令で
自シートのいずれかのセルに飛ぶと、飛ぶことはできるが
その後、キー操作を受け付けない(セルをダブルクリックするか何かしなければならない)

これは、アクティブなのがボタン(オブジェクト)側だからである。

これを解消する(アクティブにする)には、「Application.Goto」命令直後に
「ActiveCell.Select」など(*1)を実行すればよい。

*1：以下のいずれでもOK
  ・「ActiveCell.Activate」
  ・「ActiveCell.Select」
  ・「Selection.Activate」
  ・「Selection.Select」

なお、他シートへ飛ぶ場合には、
ボタンにフォーカスが当たっているのは自シート側なので
このような現象は発生しづらいが、直前のそのシートでボタンを押下しているなど
オブジェクト側にフォーカスが当たっていれば、同じ論理でキー操作を受け付けなくなる

例えば、二つのシートにボタンを配置し、
それぞれ他方の特定のシートに飛ぶようにした場合、
飛んだ先のシートではいずれもキー操作を受け付けないことになる

なお、オブジェクト側がアクティブになっている場合
画面左上の「名前ボックス」は空欄となっているのが目安となる。

「.Offset()」だね。
┌──────────────────────────────────────┐
│With セル                                                                   │
│    If .Value = "" Then                                                     │
│        MsgBox "入力してね"                                                 │
│        Application.GoTo .Offset()                                          │
│    End If                                                                  │
│End With                                                                    │
└──────────────────────────────────────┘

┌──────────────────────────────────────┐
│GO                                                                          │
│    DECLARE @sql    nvarchar(max);                                          │
│    DECLARE @sql0   nvarchar(max);                                          │
│    DECLARE @sql1   nvarchar(max);                                          │
│    DECLARE @sql1a  nvarchar(max);                                          │
│    DECLARE @sql1b  nvarchar(max);                                          │
│    -- ---------------------------------------------------------------------│
│    --   見出                                                               │
│    -- ---------------------------------------------------------------------│
│    SELECT @sql0 = ISNULL(@sql0 + ',','')                                   │
│                 + '(SELECT [列名]'                                         │
│                 + '     FROM [列Ｍ]'                                       │
│                 + '     WHERE [列ID] = ' + CONVERT(varchar,[列ID])         │
│                 + ') AS [' + CONVERT(varchar,[列ID]) + ']'                 │
│        FROM [列Ｍ]                                                         │
│        ORDER BY [列順];                                                    │
│    SET @sql0 = 'SELECT 0    AS [行順],'                                    │
│              + '       NULL AS [行ID],'                                    │
│              + @sql0;                                                      │
│    -- ---------------------------------------------------------------------│
│    --   明細                                                               │
│    -- ---------------------------------------------------------------------│
│    SELECT @sql1a = ISNULL(@sql1a + ',','')                                 │
│                  + '[' + CONVERT(varchar,[列ID]) + ']',                    │
│           @sql1b = ISNULL(@sql1b + ',','')                                 │
│                  + '[ピボット].[' + CONVERT(varchar,[列ID]) + ']'          │
│        FROM [列Ｍ]                                                         │
│        ORDER BY [列順];                                                    │
│    SET @sql1 = 'SELECT [行Ｍ].[行順],'                                     │
│              + '       [ピボット].[行ID],'                                 │
│              + @sql1b                                                      │
│              + '    FROM ('                                                │
│              + '        SELECT [列Ｍ].[列ID],'                             │
│              + '               [行Ｍ].[行ID],'                             │
│              + '               [行列Ｄ].[データ]'                          │
│              + '            FROM [列Ｍ]'                                   │
│              + '                CROSS JOIN [行Ｍ]'                         │
│              + '                LEFT JOIN [行列Ｄ]'                        │
│              + '                  ON  [行列Ｄ].[列ID] = [列Ｍ].[列ID]'     │
│              + '                  AND [行列Ｄ].[行ID] = [行Ｍ].[行ID]'     │
│              + '    ) AS [行列Ｍ]'                                         │
│              + '    PIVOT ('                                               │
│              + '        MAX([データ]) FOR [列ID] IN (' + @sql1a + ')'      │
│              + '    ) AS [ピボット]'                                       │
│              + '        INNER JOIN [行Ｍ]'                                 │
│              + '          AND [行Ｍ].[行ID] = [ピボット].[行ID]';          │
│    -- ---------------------------------------------------------------------│
│    --   統合                                                               │
│    -- ---------------------------------------------------------------------│
│    SET @sql = 'SELECT *'                                                   │
│             + '    FROM (' + @sql0 + ' UNION ALL ' + @sql1 + ') AS [行列]' │
│             + '    ORDER BY [行順] ASC;';                                  │
│    EXECUTE (@sql);                                                         │
│GO                                                                          │
└──────────────────────────────────────┘

┌──────────────────────────────────────┐
│GO                                                                          │
│    DECLARE @sql    [nvarchar](max);                                        │
│    DECLARE @sql0   [nvarchar](max);                                        │
│    DECLARE @sql1   [nvarchar](max);                                        │
│    -- ---------------------------------------------------------------------│
│    --   見出                                                               │
│    -- ---------------------------------------------------------------------│
│    SELECT @sql0 = ISNULL(@sql0 + ',','')                                   │
│                 + '(SELECT [列名]'                                         │
│                 + '     FROM [列Ｍ]'                                       │
│                 + '     WHERE [列ID] = ' + CONVERT([varchar], [列ID])      │
│                 + ') AS [' + CONVERT([varchar], [列ID]) + ']'              │
│        FROM [列Ｍ]                                                         │
│        ORDER BY [列順];                                                    │
│    SET @sql0 = 'SELECT 0    AS [行順],'                                    │
│              + '       NULL AS [行ID],'                                    │
│              + @sql0;                                                      │
│    -- ---------------------------------------------------------------------│
│    --   明細                                                               │
│    -- ---------------------------------------------------------------------│
│    SELECT @sql1 = ISNULL(@sql1 + ',','')                                   │
│                 + '(SELECT [行列Ｄ].[データ]'                              │
│                 + '     FROM [行列Ｄ]'                                     │
│                 + '     WHERE [行列Ｄ].[列ID] = '                          │
│                                                + CONVERT([varchar], [列ID])│
│                 + '       AND [行列Ｄ].[行ID] = [行Ｍ].[行ID]'             │
│                 + ') AS [' + CONVERT([varchar], [列ID]) + ']'              │
│        FROM [列Ｍ]                                                         │
│        ORDER BY [列順];                                                    │
│    SET @sql1 = 'SELECT [行Ｍ].[行順],'                                     │
│              + '       [行Ｍ].[行ID],'                                     │
│              + @sql1                                                       │
│              + '    FROM [行Ｍ]';                                          │
│    -- ---------------------------------------------------------------------│
│    --   統合                                                               │
│    -- ---------------------------------------------------------------------│
│    SET @sql = 'SELECT *'                                                   │
│             + '    FROM (' + @sql0 + ' UNION ALL ' + @sql1 + ') AS [行列]' │
│             + '    ORDER BY [行順] ASC;';                                  │
│    EXECUTE (@sql);                                                         │
│GO;                                                                         │
└──────────────────────────────────────┘

なお、[列ID]が文字列の場合は以下に変更。
┌──────────────────────────────────────┐
│                 + '     WHERE [行列Ｄ].[列ID] = '                          │
│                                                + CONVERT([varchar], [列ID])│
└──────────────────────────────────────┘
  ↓
┌──────────────────────────────────────┐
│                 + '     WHERE [行列Ｄ].[列ID]                              │
│                                          = ' + CHAR(39) + [列ID] + CHAR(39)│
└──────────────────────────────────────┘

年度版(4月～翌3月)。
┌──────────────────────────────────────┐
│WITH "年月Ｄ" AS (                                                          │
│    SELECT "年",                                                            │
│           "月",                                                            │
│           COUNT(*) AS "値"                                                 │
│        FROM (                                                              │
│            SELECT "年"                                                     │
│                   "月"                                                     │
│                FROM "表"                                                   │
│        )                                                                   │
│        GROUP BY "年",                                                      │
│                 "月"                                                       │
│)                                                                           │
│SELECT *                                                                    │
│    FROM (                                                                  │
│        SELECT CASE                                                         │
│                 WHEN "カレンダＭ"."月" < 4 THEN "カレンダＭ"."年" - 1      │
│                 ELSE                            "カレンダＭ"."年"          │
│               END AS "年度",                                               │
│               CASE                                                         │
│                 WHEN "カレンダＭ"."月" < 4 THEN "カレンダＭ"."月" + 12     │
│                 ELSE                            "カレンダＭ"."月"          │
│               END AS "月",                                                 │
│               NVL("年月Ｄ"."値", 0) AS "値"                                │
│            FROM (                                                          │
│                SELECT "年"."年",                                           │
│                       "月"."月"                                            │
│                    FROM (                                                  │
│                        SELECT 開始年度 + ROWNUM - 1  AS "年"               │
│                            FROM DUAL                                       │
│                                CONNECT BY ROWNUM <= 終了年度 - 開始年度 + 2│
│                    ) "年"                                                  │
│                        CROSS JOIN (                                        │
│                            SELECT ROWNUM AS "月"                           │
│                                FROM DUAL CONNECT BY ROWNUM <= 12           │
│                        ) "月"                                              │
│            ) "カレンダＭ"                                                  │
│                LEFT JOIN "年月Ｄ"                                          │
│                  ON  "年月Ｄ"."年" = "カレンダＭ"."年"                     │
│                  AND "年月Ｄ"."月" = "カレンダＭ"."月"                     
│    ) "集計Ｄ"                                                              │
│     PIVOT (                                                                │
│        SUM("値") FOR "月" IN ( 4 AS  "4月",                                │
│                                5 AS  "5月",                                │
│                                6 AS  "6月",                                │
│                                7 AS  "7月",                                │
│                                8 AS  "8月",                                │
│                                9 AS  "9月",                                │
│                               10 AS "10月",                                │
│                               11 AS "11月",                                │
│                               12 AS "12月",                                │
│                               13 AS  "1月",                                │
│                               14 AS  "2月",                                │
│                               15 AS  "3月")                                │
│    ) "ピボット"                                                            │
│    WHERE "年度" BETWEEN 開始年度 AND 終了年度                              │
│    ORDER BY "年度" ASC;                                                    │
└──────────────────────────────────────┘
  ・「開始年度」と「終了年度」の部分はそれぞれの数値に置き換える
  ・「年月Ｄ」の中身を変えれば、元データをいろいろなものにできる

ピボット集計にて、縦軸に年、横軸に1～12月のマトリクス表を出力するSQL文。
┌──────────────────────────────────────┐
│WITH "年月Ｄ" AS (                                                          │
│    SELECT "年",                                                            │
│           "月",                                                            │
│           COUNT(*) AS "値"                                                 │
│        FROM (                                                              │
│            SELECT "年"                                                     │
│                   "月"                                                     │
│                FROM "表"                                                   │
│        )                                                                   │
│        GROUP BY "年",                                                      │
│                 "月"                                                       │
│)                                                                           │
│SELECT *                                                                    │
│    FROM (                                                                  │
│        SELECT "カレンダＭ"."年",                                           │
│               "カレンダＭ"."月",                                           │
│               NVL("年月Ｄ"."値", 0) AS "値"                                │
│            FROM (                                                          │
│                SELECT "年"."年",                                           │
│                       "月"."月"                                            │
│                    FROM (                                                  │
│                        SELECT 開始年 + ROWNUM - 1  AS "年"                 │
│                            FROM DUAL                                       │
│                                 CONNECT BY ROWNUM <= 終了年 - 開始年 + 1   │
│                    ) "年"                                                  │
│                        CROSS JOIN (                                        │
│                            SELECT ROWNUM AS "月"                           │
│                                FROM DUAL CONNECT BY ROWNUM <= 12           │
│                        ) "月"                                              │
│            ) "カレンダＭ"                                                  │
│                LEFT JOIN "年月Ｄ"                                          │
│                  ON  "年月Ｄ"."年" = "カレンダＭ"."年"                     │
│                  AND "年月Ｄ"."月" = "カレンダＭ"."月"                     │
│    ) "集計Ｄ"                                                              │
│    PIVOT (                                                                 │
│        SUM("値") FOR "月" IN ( 1 AS  "1月",                                │
│                                2 AS  "2月",                                │
│                                3 AS  "3月",                                │
│                                4 AS  "4月",                                │
│                                5 AS  "5月",                                │
│                                6 AS  "6月",                                │
│                                7 AS  "7月",                                │
│                                8 AS  "8月",                                │
│                                9 AS  "9月",                                │
│                               10 AS "10月",                                │
│                               11 AS "11月",                                │
│                               12 AS "12月")                                │
│    ) "ピボット"                                                            │
│    ORDER BY "年" ASC;                                                      │
└──────────────────────────────────────┘
  ・「開始年」と「終了年」の部分はそれぞれの数値に置き換える
  ・「年月Ｄ」の中身を変えれば、元データをいろいろなものにできる

一つ前のレコードを参照するには、LAG()関数を使う。こんな感じ。
┌──────────────────────────────────────┐
│SELECT LAG("列") OVER(PARTITION BY "グループ列"                             │
│                      ORDER BY     "ソート列"   ASC) AS "列"                │
│    FROM "表";                                                              │
└──────────────────────────────────────┘
その列だけ局地的に一つ前のレコードを取得するような感じになる。
なお、一つまえのレコードがない場合には、「NULL」になる。

では、結合した場合はどうか？
┌──────────────────────────────────────┐
│SELECT LAG("副表"."列") OVER(PARTITION BY "副表"."グループ列"               │
│                             ORDER BY     "副表"."ソート列"   ASC) AS "列"  │
│    FROM "主表"                                                             │
│        LEFT JOIN "副表"                                                    │
│          ON "副表"."主キー" = "主表"."外部キー";                           │
└──────────────────────────────────────┘
うっかりこういうのはNG。予期せぬ「NULL」が多発する。
なぜなら、LAG()関数はあくまで直前の母集団の一つ前のレコードを探し出してくるので
この場合、"副表"側全部の中の一つ前のレコードとはならないのだ。

とはいえ、以下のようなのはNG。
┌──────────────────────────────────────┐
│SELECT "副表"."列"                                                          │
│    FROM "主表"                                                             │
│        LEFT JOIN "副表" "中継副表"                                         │
│            LEFT JOIN "副表"                                                │
│              ON "副表"."主キー"                                            │
│       = LAG("中継副表"."主キー") OVER(PARTITION BY "副表"."グループ列"     │
│                                       ORDER BY     "副表"."ソート列"   ASC)│
│          ON "中継副表"."主キー" = "主表"."外部キー";                       │
└──────────────────────────────────────┘
「ORA-30483: ここでウィンドウ・ファンクションは使用できません。」エラーとなる。

なので、副問合せの時点で解決してしまうのがよいようだ。
┌──────────────────────────────────────┐
│SELECT "副表"."列"                                                          │
│    FROM "主表"                                                             │
│        LEFT JOIN (                                                         │
│            SELECT "主キー",                                                │
│                   LAG("列") OVER(PARTITION BY "グループ列"                 │
│                                  ORDER BY     "ソート列"   ASC) AS "列"    │
│                FROM "副表"                                                 │
│        ) "副表"                                                            │
│          ON "副表"."主キー" = "主表"."外部キー";                           │
└──────────────────────────────────────┘
本当にこれがベストなのかは不安だが。