Power Queryで複数データを
一つにまとめる
設計パターン

フォルダー結合からmap・flatMap・fold・unfold・スキーマ設計までを一つの判断軸で理解する

Copyright © 2026 LWP 山中 一弘

本資料は、出典を明記いただければ、商用・非商用を問わず、ご自由に複製・改変・再配布していただけます。なお、著作権表示は改変せず、そのまま記載してご利用くださいますようお願いいたします。

売上_東京.csv

売上_大阪.csv

売上_名古屋.csv

        ↓

すべての売上明細を1つのテーブルへまとめる

入力を列挙する

↓

入力ごとに解釈する

↓

共通の形へ正規化する

↓

入力元の情報を付ける

↓

目的に合う演算で一つにする

↓

エラーや処理履歴を返す

Result = Assemble(Contextualize(Normalize(Parse(Source))))

let

    fnReadCsv =

        (Binary as binary) as table =>

            let

                Parsed =

                    Csv.Document(

                        Binary,

                        [

                            Delimiter = ",",

                            Encoding = 65001,

                            QuoteStyle = QuoteStyle.Csv

                        ]

                    ),

                Promoted =

                    Table.PromoteHeaders(

                        Parsed,

                        [PromoteAllScalars = true]

                    )

            in

                Promoted

in

    fnReadCsv

CSV Aのヘッダー

CSV Aのデータ

CSV Bのヘッダー  ← データとして残る

CSV Bのデータ

let

    Files =

        Folder.Files(FolderPath),

    CsvFiles =

        Table.SelectRows(

            Files,

            each

                Text.Lower([Extension]) = ".csv"

                and [Attributes]?[Hidden]? <> true

        ),

    WithData =

        Table.AddColumn(

            CsvFiles,

            "Data",

            each fnReadCsv([Content]),

            type table

        ),

    ExpandColumns =

        {"Date", "CustomerCode", "Amount"},

    Result =

        Table.ExpandTableColumn(

            WithData,

            "Data",

            ExpandColumns,

            ExpandColumns

        )

in

    Result

ファイルAの文脈 + 明細1

ファイルAの文脈 + 明細2

ファイルBの文脈 + 明細1

let

    Files =

        Folder.Files(FolderPath),

    CsvFiles =

        Table.SelectRows(

            Files,

            each

                Text.Lower([Extension]) = ".csv"

                and [Attributes]?[Hidden]? <> true

        ),

    Sources =

        Table.ToRecords(CsvFiles),

    Tables =

        List.Transform(

            Sources,

            (Source) =>

                let

                    Parsed =

                        fnReadCsv(Source[Content]),

                    WithSource =

                        Table.AddColumn(

                            Parsed,

                            "Source.Name",

                            each Source[Name],

                            type text

                        )

                in

                    WithSource

        ),

    Result =

        Table.Combine(Tables)

in

    Result

Source A → Table A

Source B → Table B

Source C → Table C

              ↓

         Table.Combine

let

    Files =

        Folder.Files(FolderPath),

    CsvFiles =

        Table.SelectRows(

            Files,

            each Text.Lower([Extension]) = ".csv"

        ),

    WithData =

        Table.AddColumn(

            CsvFiles,

            "Data",

            each

                let

                    Parsed =

                        fnReadCsv([Content]),

                    FileName =

                        [Name],

                    WithSource =

                        Table.AddColumn(

                            Parsed,

                            "Source.Name",

                            each FileName,

                            type text

                        )

                in

                    WithSource,

            type table

        ),

    Result =

        Table.Combine(WithData[Data])

in

    Result

let

    Files =

        Folder.Files(FolderPath),

    CsvFiles =

        Table.SelectRows(

            Files,

            each Text.Lower([Extension]) = ".csv"

        ),

    Sources =

        Table.ToRecords(CsvFiles),

    RecordLists =

        List.Transform(

            Sources,

            (Source) =>

                let

                    Parsed =

                        fnReadCsv(Source[Content]),

                    Records =

                        Table.ToRecords(Parsed),

                    WithSource =

                        List.Transform(

                            Records,

                            (Row) =>

                                Record.Combine(

                                    {

                                        Row,

                                        [#"Source.Name" = Source[Name]]

                                    }

                                )

                        )

                in

                    WithSource

        ),

    AllRecords =

        List.Combine(RecordLists),

    Result =

        Table.FromRecords(AllRecords)

in

    Result

CSV → Table → List of Record

全ファイルのRecordリストを連結

最後にTable.FromRecords

let

    Files =

        Folder.Files(FolderPath),

    Sources =

        Table.ToRecords(Files),

    InitialState =

        [

            Tables = {},

            Errors = {},

            FileNumber = 0

        ],

    FinalState =

        List.Accumulate(

            Sources,

            InitialState,

            (State, Source) =>

                let

                    Attempt =

                        try fnReadCsv(Source[Content]),

                    NextFileNumber =

                        State[FileNumber] + 1

                in

                    if Attempt[HasError] then

                        [

                            Tables = State[Tables],

                            Errors =

                                State[Errors]

                                    & {

                                        [

                                            Name = Source[Name],

                                            Error = Attempt[Error]

                                        ]

                                    },

                            FileNumber = NextFileNumber

                        ]

                    else

                        [

                            Tables =

                                State[Tables] & {Attempt[Value]},

                            Errors = State[Errors],

                            FileNumber = NextFileNumber

                        ]

        ),

    Data =

        Table.Combine(FinalState[Tables]),

    ErrorTable =

        Table.FromRecords(FinalState[Errors])

in

    [

        Data = Data,

        Errors = ErrorTable

    ]

let

    Pages =

        List.Generate(

            () =>

                [

                    Page = fnGetPage(null),

                    Continue = true

                ],

            each [Continue],

            (State) =>

                let

                    NextToken =

                        State[Page][NextToken],

                    HasNext =

                        NextToken <> null,

                    NextPage =

                        if HasNext then

                            fnGetPage(NextToken)

                        else

                            null

                in

                    [

                        Page = NextPage,

                        Continue = HasNext

                    ],

            each [Page][Data]

        ),

    Result =

        Table.Combine(Pages)

in

    Result

List.Accumulate

= 与えられた入力を順番に状態へ畳み込む

List.Generate

= 状態から次の候補を作り、条件を満たす間だけ値を生み出す

let

    Files =

        Folder.Files(FolderPath),

    WithCompany =

        Table.AddColumn(

            Files,

            "Company",

            each fnGetCompany([Name]),

            type text

        ),

    Grouped =

        Table.Group(

            WithCompany,

            {"Company"},

            {

                {

                    "Files",

                    each _,

                    type table

                }

            }

        ),

    WithData =

        Table.AddColumn(

            Grouped,

            "Data",

            each

                let

                    Sources =

                        Table.ToRecords([Files]),

                    Tables =

                        List.Transform(

                            Sources,

                            each fnReadCsv(_[Content])

                        )

                in

                    Table.Combine(Tables),

            type table

        )

in

    WithData

Date            date

CustomerCode    text

Amount          number

SourceName      text

let

    ContractColumns =

        {"Date", "CustomerCode", "Amount", "SourceName"},

    Normalize =

        (Source as record) as table =>

            let

                Parsed =

                    fnReadCsv(Source[Content]),

                Renamed =

                    Table.RenameColumns(

                        Parsed,

                        {

                            {"売上日", "Date"},

                            {"得意先コード", "CustomerCode"},

                            {"売上金額", "Amount"}

                        },

                        MissingField.Ignore

                    ),

                WithSource =

                    Table.AddColumn(

                        Renamed,

                        "SourceName",

                        each Source[Name],

                        type text

                    ),

                Shaped =

                    Table.SelectColumns(

                        WithSource,

                        ContractColumns,

                        MissingField.UseNull

                    ),

                Typed =

                    Table.TransformColumnTypes(

                        Shaped,

                        {

                            {"Date", type date},

                            {"CustomerCode", type text},

                            {"Amount", type number},

                            {"SourceName", type text}

                        }

                    )

            in

                Typed,

    Files =

        Folder.Files(FolderPath),

    Sources =

        Table.ToRecords(Files),

    NormalizedTables =

        List.Transform(Sources, each Normalize(_)),

    Result =

        Table.Combine(NormalizedTables)

in

    Result

let

    Sales =

        fnReadSales(),

    Customers =

        fnReadCustomers(),

    Joined =

        Table.NestedJoin(

            Sales,

            {"CustomerCode"},

            Customers,

            {"CustomerCode"},

            "Customer",

            JoinKind.LeftOuter

        ),

    Result =

        Table.ExpandTableColumn(

            Joined,

            "Customer",

            {"CustomerName", "Area"},

            {"CustomerName", "Area"}

        )

in

    Result

let

    Parsers =

        [

            Csv =

                (Source as record) as table =>

                    fnReadCsv(Source[Content]),

            Tsv =

                (Source as record) as table =>

                    let

                        Parsed =

                            Csv.Document(

                                Source[Content],

                                [

                                    Delimiter = "#(tab)",

                                    Encoding = 65001,

                                    QuoteStyle = QuoteStyle.Csv

                                ]

                            )

                    in

                        Table.PromoteHeaders(Parsed),

            Json =

                (Source as record) as table =>

                    Table.FromRecords(

                        Json.Document(Source[Content])

                    )

        ],

    ReadSource =

        (Source as record) as table =>

            let

                Parser =

                    Record.Field(

                        Parsers,

                        Source[ParserName]

                    )

            in

                Parser(Source)

in

    ReadSource

map

= 各入力を1つの結果へ変換する

= List.Transform、Table.AddColumn

flatMap

= 各入力を複数行へ変換し、その結果を平らにする

= Table列を追加してTable.ExpandTableColumn

fold

= 入力を順番に処理し、1つの状態へ畳み込む

= List.Accumulate

unfold

= 現在の状態から次の候補と次の状態を作り続ける

= List.Generate

join

= 共通キーで別集合を対応づける

= Table.NestedJoin、Table.Join

group

= 共通区分で小さな集合へ分ける

= Table.Group

代表ファイルで変換手順を作る

↓

変換手順を関数化する

↓

各ファイルへ関数を適用する

↓

戻り値のTableを展開する

各ファイルで型を確定してから結合する

各ファイルでは文字列中心で読み、結合後に最終型を設定する

Fail Fast

= 1ファイルでも異常なら全体をエラーにする

Quarantine

= 正常ファイルは統合し、異常ファイルは別一覧へ隔離する

Folder.Files

↓

拡張子、隠し属性、ファイル名で対象を絞る

↓

Table.ToRecordsでファイルをRecordのリストにする

↓

ファイル単位の関数で解析、ヘッダー昇格、列名正規化を行う

↓

Source.Nameを結果へ追加する

↓

完成スキーマへそろえる

↓

Table.Combineを一度だけ実行する

外側の文脈を残す

→ AddColumnしてExpandする

個々の結果を同格の部品として扱う

→ List.TransformしてTable.Combineする

1件の事実へ分解して再構築する

→ Recordを集めてTable.FromRecordsする

前回の状態を引き継ぐ

→ List.Accumulateする

次の入力を状態から作る

→ List.Generateする

業務上のまとまりを残す

→ Table.Groupで分けてからCombineする

完成形を中心に設計する

→ 共通スキーマへ正規化してからCombineする

同じ実体の情報を合わせる

→ キーでJoinする