[親]と[子]の二列(二階層)になっていて、それぞれ文字列型なのだが
場合によっては[子]が数値要素だけの場合、
数値としてソートをかけたいする(そうしないと「10」が「2」の前に来て格好悪い)

というこで、出し分けるSQL文は以下の通り
┌──────────────────────────────────────┐
│SELECT [主表].[親],                                                         │
│       [主表].[子],                                                         │
│    FROM [表] AS [主表]                                                     │
│    ORDER BY [主表].[親] ASC,                                               │
│             CASE                                                           │
│               WHEN EXISTS (                                                │
│                        SELECT *                                            │
│                            FROM [表] AS [調査表]                           │
│                            WHERE [調査表].[親] = [A].[親]                  │
│                              AND (ISNUMERIC([調査表].[子]) = 0             │
│                                OR ([調査表].[子] LIKE '0%'                 │
│                                AND [調査表].[子] <> '0'))                  │
│                    ) THEN                                                  │
│                 [主表].[子]                                                │
│               ELSE                                                         │
│                 FORMAT(CAST([主表].[子] AS int), '00000000')               │
│             END ASC;                                                       │
└──────────────────────────────────────┘
「0001」とかについては文字列として並び替えるおまけつき(しかも「0」だけは除く)

┌───────────┬────┬────┬────────────────┐
│       パターン       │外部利用│直接実行│              備考              │
├───────────┼────┼────┼────────────────┤
│Public Sub            │        │        │                                │
├───────────┤   ○   │   ○   ├────────────────┤
│Sub                   │        │        │アクセス修飾子の省略はPublic扱い│
├───────────┼────┼────┼────────────────┤
│Option Private Module │        │        │Option Private Moduleを付けると │
│Public Sub            │        │        │            直接実行できなくなる│
├───────────┤   ○   │   ×   ├────────────────┤
│Public Function       │        │        │引数があると、直接実行はできない│
├───────────┤        │        │                                │
│Function              │        │        │アクセス修飾子の省略はPublic扱い│
├───────────┼────┼────┼────────────────┤
│Private Sub           │        │        │                                │
├───────────┤   ×   │   ×   ├────────────────┤
│Private Function      │        │        │                                │
└───────────┴────┴────┴────────────────┘

その要素が配列にあるかを返す関数。「inArray(要素,配列) → TrueかFalse」
┌──────────────────────────────────────┐
│Function inArray(ByVal needle As Variant, _                                 │
│                 ByVal haystack As Variant) As Boolean                      │
│    inArray = (UBound(Filter(haystack, needle)) >= 0)                       │
│End Function                                                                │
└──────────────────────────────────────┘

でも、これだと部分一致検索になってしまうのであった。。。

完全一致検索を実現するには以下のように地道にやるしかないようだ。
┌──────────────────────────────────────┐
│Public Function inArray(ByVal needle As Variant, _                          │
│                        ByVal haystack As Variant) As Boolean               │
│    Dim theValue As Variant                                                 │
│    If IsEmpty(haystack) Then                                               │
│        inArray = False                                                     │
│        Exit Function                                                       │
│    End If                                                                  │
│    For Each theValue In haystack                                           │
│        If needle = theValue Then                                           │
│            inArray = True                                                  │
│            Exit Function                                                   │
│        End If                                                              │
│    Next theValue                                                           │
│    inArray = False                                                         │
│End Function                                                                │
└──────────────────────────────────────┘

「配置／文字の制御／縮小して全体を表示する」の設定
┌──────────────────────────────────────┐
│セル.ShrinkToFit = True                                                     │
└──────────────────────────────────────┘

クラスにすると大変利点を感じるケース
・開始処理と終了処理が定型的なもの
  ＃ファイルアクセス(Open＆Close)的なもの
  →コンストラクタとデストラクタに処理を設置することにより
    処理の漏れを防ぐ(こともできる)
・一度だけ読む込む定数ファイル的なもの
  →アクセスは一度でメンバ変数に保持し、ゲッタで返却取得
・決まった場所に入出力する場合
  →ゲッタやセッタで

・TRUCATE TABLE文ではなく、DELETE文で全件削除
  →ロールバックに備えながら処理をするのでものすごく遅い
・相関副問い合わせではなく、内部結合で行抽出
  →抽出が先に行われない場合があり、ものすごく遅くなる
・インデックスを張らない
  →ものすごく遅い

ExcelVBA／オートフィルタ連動マクロ
オートフィルタの設定に伴ってマクロを起動する方法。

オートフィルタ変更イベント的なものはないので
代わりに「SUBTOTAL()」と再計算イベントを複合して対応する。

つまり、「SUBTOTAL()」で行件数を算出するようにして(第一引数=3)、
オートフィルタで行数が変動するのを再計算イベントで捕捉するという感じ。

以下のような形となる。
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
【全表示の場合】
┌────┬──┬───┬───┬───┬───┐┌────┐
│抽出条件│キー│項目A │項目B │項目C │項目Z ││=SUBTOTAL(3,A:A)
├────┼──┼───┼───┼───┼───┤└────┘
│A       │A1  │あ    │      │      │ん    │
│A       │A2  │あ    │      │      │ん    │
├────┼──┼───┼───┼───┼───┤
│B       │B1  │      │い    │      │ん    │
│B       │B2  │      │い    │      │ん    │
├────┼──┼───┼───┼───┼───┤
│C       │C1  │      │      │う    │ん    │
│C       │C2  │      │      │う    │ん    │
├────┼──┼───┼───┼───┼───┤
│D       │D1  │      │      │      │ん    │
│D       │D2  │      │      │      │ん    │
└────┴──┴───┴───┴───┴───┘
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
【抽出条件を「A」のみにした場合】
┌────┬──┬───┬───┐┌────┐
│抽出条件│キー│項目A │項目Z ││=SUBTOTAL(3,A:A)
├────┼──┼───┼───┤└────┘
│A       │A1  │あ    │ん    │
│A       │A2  │あ    │ん    │
└────┴──┴───┴───┘
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
【抽出条件を「A」と「B」にした場合】
┌────┬──┬───┬───┬───┐┌────┐
│抽出条件│キー│項目A │項目B │項目Z ││=SUBTOTAL(3,A:A)
├────┼──┼───┼───┼───┤└────┘
│A       │A1  │あ    │      │ん    │
│A       │A2  │あ    │      │ん    │
├────┼──┼───┼───┼───┤
│B       │B1  │      │い    │ん    │
│B       │B2  │      │い    │ん    │
└────┴──┴───┴───┴───┘
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
【シートに記述するマクロ】
┌──────────────────────────────────────┐
│Option Explicit                                                             │
│Const X_抽出条件 As Long = 1                                                │
│'===========================================================================│
│'  再計算時のイベント(SUBTOTAL(3,A:A)の設定が必須)                          │
│'    オートフィルタの変更を検出できないため                                 │
│'===========================================================================│
│Private Sub Worksheet_Calculate()                                           │
│    Dim 配列 As Variant                                                     │
│    Dim 判定結果 As Variant                                                 │
│    With ActiveSheet                                                        │
│        If Not .AutoFilterMode Then                     ' フィルタ未設定    │
│            .Columns("A:G").Hidden = False                                  │
│            Exit Sub                                                        │
│        End If                                                              │
│        If .AutoFilter.Filters.Count < X_抽出条件 Then  ' キー列に未設定    │
│            Exit Sub                                                        │
│        End If                                                              │
│        If Not .AutoFilter.Filters(X_抽出条件).On Then  ' 絞り込み未設定    │
│            .Columns("A:G").Hidden = False                                  │
│            Exit Sub                                                        │
│        End If                                                              │
│        ' 抽出条件の配列化                                                  │
│        Select Case .AutoFilter.Filters(X_抽出条件).Count                   │
│            Case 1:                                                         │
│                配列 = Array(.AutoFilter.Filters(X_抽出条件).Criteria1)     │
│            Case 2:                                                         │
│                配列 = Array(.AutoFilter.Filters(X_抽出条件).Criteria1, _   │
│                             .AutoFilter.Filters(X_抽出条件).Criteria2)     │
│            Case Else:                                                      │
│                配列 = .AutoFilter.Filters(X_抽出条件).Criteria1            │
│        End Select                                                          │
│        ' 表示変更                                                          │
│        .Columns("A:G").Hidden = False                                      │
│        判定結果 = Filter(配列, "=A")                                       │
│        If UBound(判定結果) = -1 Then                                       │
│            .Columns("C:C").Hidden = True                                   │
│        End If                                                              │
│        判定結果 = Filter(配列, "=B")                                       │
│        If UBound(判定結果) = -1 Then                                       │
│            .Columns("D:D").Hidden = True                                   │
│        End If                                                              │
│        判定結果 = Filter(配列, "=C")                                       │
│        If UBound(判定結果) = -1 Then                                       │
│            .Columns("E:E").Hidden = True                                   │
│        End If                                                              │
│    End With                                                                │
│End Sub                                                                     │
│'===========================================================================│
└──────────────────────────────────────┘

┌──────────────────────────────────────┐
│SELECT 列 FROM 表 WHERE 検索列 = '■';                                      │
└──────────────────────────────────────┘
上記のようなSQL文を用意しておいて、画面から■の部分を入力してもらい、
任意の検索を行う場合を例にする。

以下のような値(文字列)を入力された場合…。
┌──────────────────────────────────────┐
│' OR 1 = 1;--                                                               │
└──────────────────────────────────────┘
そのままはめ込むと以下のようになってしまい(「--」以降はコメントとなる)
┌──────────────────────────────────────┐
│SELECT 列 FROM 表 WHERE 検索列 = '' OR 1 = 1;--';                           │
└──────────────────────────────────────┘
OR条件の「1 = 1」が如何なる時も成立してしまい全件ヒットする。

これが基本的なSQLインジェクション手法だ。

じゃ、「'」を「\'」に置換して、単なる文字にしてしまえばよいか？
┌──────────────────────────────────────┐
│SELECT 列 FROM 表 WHERE 検索列 = '\' OR 1 = 1;--';                          │
└──────────────────────────────────────┘
単なる「\' OR 1 = 1;--」という文字列で検索しにいくので成功！

それならこれでどうだ！
┌──────────────────────────────────────┐
│\' OR 1 = 1;--                                                              │
└──────────────────────────────────────┘
置換しなければ前出と同じなのだが、置換してしまうと以下のようになってしまう。
┌──────────────────────────────────────┐
│SELECT 列 FROM 表 WHERE 検索列 = '\\' OR 1 = 1;--';                         │
└──────────────────────────────────────┘
「'\\'」の部分が「\」という文字を意味することになり、
「1 = 1」が如何なる時も成立してしまう

ちなみに「'」を「''」に置換する場合も以下の通り。
┌──────────────────────────────────────┐
│SELECT 列 FROM 表 WHERE 検索列 = '\'' OR 1 = 1;--';                         │
└──────────────────────────────────────┘
こちらは「'\''」が「'」という文字を意味するが他は同じ。全て成立してしまう。

そんなに簡単な話ではないのだ。

┌──────────────────────────────────────┐
│SELECT *                                                                    │
│    FROM "pg_stat_all_indexes"                                              │
│    WHERE "schemaname" = 'public';                                          │
├──────────────────────────────────────┤
│SELECT *                                                                    │
│    FROM "pg_statio_all_indexes"                                            │
│    WHERE "schemaname" = 'public';                                          │
└──────────────────────────────────────┘
基本は上記の二つ。

これを編集すると以下のような感じ。
┌──────────────────────────────────────┐
│SELECT "pg_stat_all_indexes"."relid",                                       │
│       "pg_stat_all_indexes"."indexrelid",                                  │
│       "pg_stat_all_indexes"."schemaname",                                  │
│       "pg_stat_all_indexes"."relname",                                     │
│       "pg_stat_all_indexes"."indexrelname",                                │
│       "pg_stat_all_indexes"."idx_scan",                                    │
│       "pg_stat_all_indexes"."idx_tup_read",                                │
│       "pg_stat_all_indexes"."idx_tup_fetch",                               │
│       "pg_statio_all_indexes"."idx_blks_read",                             │
│       "pg_statio_all_indexes"."idx_blks_hit"                               │
│    FROM "pg_stat_all_indexes",                                             │
│         "pg_statio_all_indexes"                                            │
│    WHERE "pg_stat_all_indexes"."indexrelid"                                │
│                                      = "pg_statio_all_indexes"."indexrelid"│
│      AND "pg_stat_all_indexes"."schemaname" = 'public'                     │
│    ORDER BY "pg_stat_all_indexes"."relname"      ASC,                      │
│             "pg_stat_all_indexes"."indexrelname" ASC;                      │
└──────────────────────────────────────┘

  総使用量を確認する
┌──────────────────────────────────────┐
│SELECT SUM(`data_length` + `index_length`) / 1024 / 1024 AS `総使用量(MB)`  │
│    FROM `information_schema`.`tables`;                                     │
└──────────────────────────────────────┘
  DBごとの使用量を確認する
┌──────────────────────────────────────┐
│SELECT `table_schema`                                    AS `DB名`,         │
│       SUM(`data_length` + `index_length`) / 1024 / 1024 AS `使用量(MB)`    │
│    FROM `information_schema`.`tables`                                      │
│    GROUP BY `table_schema`                                                 │
│    ORDER BY SUM(`data_length` + `index_length`) DESC;                      │
└──────────────────────────────────────┘