パフォーマンスを最適化する

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// getAircraftName.ts - 効率が低い：単一のオブジェクトでは事前に読み込みが発生します
import { Osdk } from "@osdk/client";
import { ExampleDataAircraft } from "@ontology/sdk";

export default function getAircraftName(aircraft: Osdk.Instance<ExampleDataAircraft>): string {
    return aircraft.displayName!;
}

// getAircraftsNames.ts - 効率が中程度：オブジェクトの配列では事前に読み込みが発生します
import { Osdk } from "@osdk/client";
import { ExampleDataAircraft } from "@ontology/sdk";

export default function getAircraftsNames(aircraftArray: Osdk.Instance<ExampleDataAircraft>[]): string[] {
    return aircraftArray.map(e => e.displayName!);
}

// countAircrafts.ts - 最も効率的：オブジェクトセットでは必要になるまで読み込みを遅延します
// ここでは、集計値のみが関数のメモリーに読み込まれます
import { ObjectSet } from "@osdk/client";
import { Integer } from "@osdk/functions";
import { ExampleDataAircraft } from "@ontology/sdk";

export default async function countAircrafts(aircraftSet: ObjectSet<ExampleDataAircraft>): Promise<Integer> {
    const result = await aircraftSet.aggregate({
        $select: { $count: "unordered" }
    });
    return result.$count;
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import { Function, Integer } from "@foundry/functions-api";
import { ObjectSet, ExampleDataAircraft } from "@foundry/ontology-api";

export class MyFunctions {
    // 効率が低い：単一のオブジェクトでは事前に読み込みが発生します
    @Function()
    public getAircraftName(aircraft: ExampleDataAircraft): string {
        return aircraft.displayName!;
    }

    // 効率が中程度：オブジェクトの配列では事前に読み込みが発生します
    @Function()
    public getAircraftsNames(aircraftArray: ExampleDataAircraft[]): string[] {
        return aircraftArray.map(e => e.displayName!);
    }

    // 最も効率的：オブジェクトセットでは必要になるまで読み込みを遅延します
    // ここでは、集計値のみが関数のメモリーに読み込まれます
    @Function()
    public async countAircrafts(aircraftSet: ObjectSet<ExampleDataAircraft>): Promise<Integer> {
        const count = await aircraftSet.count();
        return count!;
    }
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// forLoopWorst.ts - アンチパターン：ループ内でオブジェクトを1個ずつ読み込みます
import { Client, Osdk } from "@osdk/client";
import { ExampleDataAircraft } from "@ontology/sdk";
import { Integer } from "@osdk/functions";

export default async function forLoopWorst(client: Client, pks_list: string[]): Promise<Integer> {
    let seatsCount = 0;

    for (const currentPk of pks_list) {
        const fetchedPage = await client(ExampleDataAircraft).where({
            tailNumber: { $eq: currentPk }
        }).fetchPage();
        const aircraft = fetchedPage.data[0];
        seatsCount += aircraft?.numberOfSeats ?? 0;
    }

    return seatsCount;
}

// forLoopBetter.ts - より良い方法：1回の呼び出しですべてのオブジェクトを読み込み、その後に反復処理を行います
import { Client, Osdk } from "@osdk/client";
import { ExampleDataAircraft } from "@ontology/sdk";
import { Integer } from "@osdk/functions";

export default async function forLoopBetter(client: Client, pks_list: string[]): Promise<Integer> {
    let seatsCount = 0;

    const allObjects = client(ExampleDataAircraft).where({
        tailNumber: { $in: pks_list }
    });

    for await (const currentObject of allObjects.asyncIter()) {
        seatsCount += currentObject?.numberOfSeats ?? 0;
    }

    return seatsCount;
}

// forLoopBest.ts - 最良の方法：バックエンドで集計を実行します
import { Client } from "@osdk/client";
import { ExampleDataAircraft } from "@ontology/sdk";
import { Integer } from "@osdk/functions";

export default async function forLoopBest(client: Client, pks_list: string[]): Promise<Integer> {
    const result = await client(ExampleDataAircraft).where({
        tailNumber: { $in: pks_list }
    }).aggregate({
        $select: { "numberOfSeats:sum": "unordered" }
    });

    return result.numberOfSeats.sum!;
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import { Function, Integer } from "@foundry/functions-api";
import { Objects, ExampleDataAircraft } from "@foundry/ontology-api";

export class MyFunctions {
    // アンチパターン：ループ内でオブジェクトを1個ずつ読み込みます
    @Function()
    public forLoopWorst(pks_list: string[]): Integer {
        let seatsCount = 0;

        for (const currentPk of pks_list) {
            const aircraft = Objects.search()
                .exampleDataAircraft()
                .filter(o => o.tailNumber.exactMatch(currentPk))
                .all()[0];
            seatsCount += aircraft.numberOfSeats ?? 0;
        }

        return seatsCount;
    }

    // より良い方法：オブジェクトを一括で読み込み、その後に反復処理を行います
    @Function()
    public forLoopBetter(pks_list: string[]): Integer {
        const allObjects = Objects.search()
            .exampleDataAircraft()
            .filter(o => o.tailNumber.exactMatch(...pks_list))
            .all();

        let seatsCount = 0;
        for (const currentObject of allObjects) {
            seatsCount += currentObject.numberOfSeats ?? 0;
        }

        return seatsCount;
    }

    // 最良の方法：バックエンドで集計を実行します
    @Function()
    public async forLoopBest(pks_list: string[]): Promise<Integer> {
        const seatsCount = await Objects.search()
            .exampleDataAircraft()
            .filter(o => o.tailNumber.exactMatch(...pks_list))
            .sum(o => o.numberOfSeats);

        return seatsCount!;
    }
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import { ObjectSpecifier, Osdk } from "@osdk/client";
import { Employee } from "@ontology/sdk";
import { Integer } from "@osdk/functions";

export default async function getEmployeeProjectCount(
    employees: Osdk.Instance<Employee>[]
): Promise<Record<ObjectSpecifier<Employee>, Integer>> {
    const allEmployeeProjectCounts = await Promise.all(
        employees.map(async employee => {
            let count = 0;
            for await (const project of employee.$link.workHistory.asyncIter()) {
                count++;
            }
            return count;
        })
    );

    const result: Record<ObjectSpecifier<Employee>, Integer> = {};
    employees.forEach((employee, i) => {
        result[employee.$objectSpecifier] = allEmployeeProjectCounts[i];
    });

    return result;
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import { ObjectSpecifier, Osdk } from "@osdk/client";
import { Employee } from "@ontology/sdk";
import { Integer } from "@osdk/functions";

export default async function getEmployeeProjectCount(
    employees: Osdk.Instance<Employee>[]
): Promise<Record<ObjectSpecifier<Employee>, Integer>> {
    const result: Record<ObjectSpecifier<Employee>, Integer> = {};

    // プロジェクトオブジェクト自体を読み込むのではなく、バックエンドの集計を使って各従業員にリンクされたプロジェクトの件数を数えます
    const counts = await Promise.all(
        employees.map(async employee => ({
            employee,
            count: await employee.$link.workHistory.aggregate({ $select: { $count: "unordered" } }),
        }))
    );

    counts.forEach(({ employee, count }) => {
        result[employee.$objectSpecifier] = count.$count;
    });

    return result;
}

Copied!
1
2
3
for (const employee of employees) {
    const pastProjects = await employee.$link.workHistory.fetchPage();
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import { Osdk } from "@osdk/client";
import { Employee, Project } from "@ontology/sdk";

async function getProjects(employee: Osdk.Instance<Employee>): Promise<Osdk.Instance<Project>[]> {
    const projects: Osdk.Instance<Project>[] = [];
    for await (const project of employee.$link.workHistory.asyncIter()) {
        projects.push(project);
    }
    return projects;
}

export default async function findEmployeeWithMostProjects(
    employees: Osdk.Instance<Employee>[]
): Promise<Osdk.Instance<Employee>> {
    // 各従業員のプロジェクトを読み込むリクエストを送信すると、すべてのリンクが並列で読み込まれます
    const allEmployeeProjects = await Promise.all(employees.map(employee => getProjects(employee)));

    // 結果を反復処理して、プロジェクト数が最も多い従業員を見つけます
    let result = employees[0];
    let maxProjectsLength = allEmployeeProjects[0].length;
    for (let i = 1; i < employees.length; i++) {
        if (allEmployeeProjects[i].length > maxProjectsLength) {
            result = employees[i];
            maxProjectsLength = allEmployeeProjects[i].length;
        }
    }

    return result;
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// forLoopAsync.ts - 実行はより高速ですが、オントロジーの呼び出しは依然として複数回発生します
import { Client, ObjectSet, Osdk } from "@osdk/client";
import { ExampleDataAircraft } from "@ontology/sdk";
import { Integer } from "@osdk/functions";

async function getMaintenanceEventCount(
    client: Client,
    aircraft: Osdk.Instance<ExampleDataAircraft>
): Promise<Integer> {
    const aircraftSet = client(ExampleDataAircraft).where({
        tailNumber: { $eq: aircraft.tailNumber }
    });
    const maintenanceEvents = aircraftSet.pivotTo("exampleDataAircraftMaintenanceEvent");
    const result = await maintenanceEvents.aggregate({
        $select: { $count: "unordered" }
    });
    return result.$count ?? 0;
}

export default async function forLoopAsync(
    client: Client,
    aircraftSet: ObjectSet<ExampleDataAircraft>
): Promise<Integer> {
    const allObjects: Osdk.Instance<ExampleDataAircraft>[] = [];
    for await (const obj of aircraftSet.asyncIter()) {
        allObjects.push(obj);
    }

    const futures = allObjects.map(obj => getMaintenanceEventCount(client, obj));
    const results = await Promise.all(futures);

    return results.reduce((sum, count) => sum + count, 0);
}

// bulkProcessing.ts - 最良の方法：1回のオントロジー操作
import { ObjectSet } from "@osdk/client";
import { ExampleDataAircraft } from "@ontology/sdk";
import { Integer } from "@osdk/functions";

export default async function bulkProcessing(
    aircraftSet: ObjectSet<ExampleDataAircraft>
): Promise<Integer> {
    const allMaintenanceEvents = aircraftSet.pivotTo("exampleDataAircraftMaintenanceEvent");
    const result = await allMaintenanceEvents.aggregate({
        $select: { $count: "unordered" }
    });
    return result.$count ?? 0;
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import { Function, Integer } from "@foundry/functions-api";
import { ObjectSet, ExampleDataAircraft } from "@foundry/ontology-api";
import { Objects } from "@foundry/ontology-api";

export class MyFunctions {
    private async getMaintenanceEventCount(aircraft: ExampleDataAircraft): Promise<Integer> {
        const aircraftSet = Objects.search().exampleDataAircraft([aircraft]);
        const maintenanceEvents = aircraftSet.searchAroundExampleDataAircraftMaintenanceEvent();
        return await maintenanceEvents.count() ?? 0;
    }

    // 実行はより高速ですが、オントロジーの呼び出しは依然として複数回発生します
    @Function()
    public async forLoopAsync(aircraftSet: ObjectSet<ExampleDataAircraft>): Promise<Integer> {
        const allObjects = aircraftSet.all();
        const futures = allObjects.map(obj => this.getMaintenanceEventCount(obj));
        const results = await Promise.all(futures);
        return results.reduce((sum, count) => sum + count, 0);
    }

    // 最良の方法：1回のオントロジー操作
    @Function()
    public async bulkProcessing(aircraftSet: ObjectSet<ExampleDataAircraft>): Promise<Integer> {
        const allMaintenanceEvents = aircraftSet.searchAroundExampleDataAircraftMaintenanceEvent();
        return await allMaintenanceEvents.count() ?? 0;
    }
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// editAircraftName.ts - 単一のオブジェクトの編集
import { Osdk, Client } from "@osdk/client";
import { ExampleDataAircraft } from "@ontology/sdk";
import { Edits, createEditBatch } from "@osdk/functions";

type OntologyEdit = Edits.Object<ExampleDataAircraft>;

export default async function editAircraftName(
    client: Client,
    aircraft: Osdk.Instance<ExampleDataAircraft>
): Promise<OntologyEdit[]> {
    const batch = createEditBatch<OntologyEdit>(client);
    batch.update(aircraft, { displayName: "new display name" });
    return batch.getEdits();
}

// editAllAircrafts.ts - オブジェクトセットを使った一括編集
import { Client, ObjectSet } from "@osdk/client";
import { ExampleDataAircraft } from "@ontology/sdk";
import { Edits, createEditBatch } from "@osdk/functions";

type OntologyEdit = Edits.Object<ExampleDataAircraft>;

export default async function editAllAircrafts(
    client: Client,
    aircraftSet: ObjectSet<ExampleDataAircraft>
): Promise<OntologyEdit[]> {
    const batch = createEditBatch<OntologyEdit>(client);

    for await (const aircraft of aircraftSet.asyncIter()) {
        batch.update(aircraft, { displayName: "new display name" });
    }

    return batch.getEdits();
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import { Function, OntologyEditFunction, Edits } from "@foundry/functions-api";
import { ObjectSet, ExampleDataAircraft } from "@foundry/ontology-api";

export class MyFunctions {
    // 単一のオブジェクトの編集
    @Edits(ExampleDataAircraft)
    @OntologyEditFunction()
    public editAircraftName(aircraft: ExampleDataAircraft): void {
        aircraft.displayName = "new display name";
    }

    // 配列の編集
    @Edits(ExampleDataAircraft)
    @OntologyEditFunction()
    public editAircraftsNames(aircraftArray: ExampleDataAircraft[]): void {
        aircraftArray.forEach(aircraft => {
            aircraft.displayName = "new display name";
        });
    }

    // オブジェクトセットの編集 - 多数のオブジェクトを編集する必要がある場合に最も効率的です
    @Edits(ExampleDataAircraft)
    @OntologyEditFunction()
    public editAllAircrafts(aircraftSet: ObjectSet<ExampleDataAircraft>): void {
        aircraftSet.all().forEach(aircraft => {
            aircraft.displayName = "new display name";
        });
    }
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import { ObjectSet, ObjectSpecifier, Osdk } from "@osdk/client";
import { ObjectTypeA } from "@ontology/sdk";
import { Double } from "@osdk/functions";

// 指定されたオブジェクトについて、必要な値を計算する関数の例です。
function computeForThisObject(obj: Osdk.Instance<ObjectTypeA, never, "exampleProperty">, scalar: Double): Double | undefined {
    if (scalar === 0) {
        // ゼロ除算エラー
        return undefined;
    }
    // exampleProperty が定義されているかを確認し、定義されている場合は除算します。定義されていない場合は undefined を返します。
    return obj.exampleProperty ? obj.exampleProperty / scalar : undefined;
}

/**
 * この関数は ObjectSet を入力として受け取り、派生列を出力として生成します。
 * この派生列は、各オブジェクトのインスタンスを、列に設定する数値に対応付けます。
 * この実装は、オブジェクトのプロパティに固定値を乗算する単純な for ループです。
 * これを基本ケースとして、以下で改善します。
 */
export default async function getDerivedColumnNoOptimization(
    objects: ObjectSet<ObjectTypeA>,
    scalar: Double
): Promise<Record<ObjectSpecifier<ObjectTypeA>, Double>> {
    // 返す結果マップを定義します
    const resultMap: Record<ObjectSpecifier<ObjectTypeA>, Double> = {};

    /* メモリーに読み込めるオブジェクト数には制限があります。
     * 現在のオブジェクトセットの読み込み制限については、適用される制限のドキュメントを参照してください。
     */
    for await (const obj of objects.asyncIter({ $select: ["exampleProperty"] })) {
        // 読み込んだ各オブジェクトについて計算を実行します。結果が定義されている場合は、結果マップに格納します。
        const result = computeForThisObject(obj, scalar);
        if (result !== undefined) {
            resultMap[obj.$objectSpecifier] = result;
        }
    }

    return resultMap;
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import { ObjectSet, ObjectSpecifier, Osdk } from "@osdk/client";
import { ObjectTypeA } from "@ontology/sdk";
import { Double } from "@osdk/functions";

// 指定されたオブジェクトについて、必要な値を計算する関数の例です。
async function computeForThisObject(obj: Osdk.Instance<ObjectTypeA, never, "exampleProperty">, scalar: Double): Promise<Double | undefined> {
    if (scalar === 0) {
        // ゼロ除算エラー
        return undefined;
    }
    // exampleProperty が定義されているかを確認し、定義されている場合は除算します。定義されていない場合は undefined を返します。
    return obj.exampleProperty ? obj.exampleProperty / scalar : undefined;
}

/**
 * この関数は ObjectSet を入力として受け取り、派生列を出力として生成します。
 */
export default async function getDerivedColumnParallel(
    objects: ObjectSet<ObjectTypeA>,
    scalar: Double
): Promise<Record<ObjectSpecifier<ObjectTypeA>, Double>> {
    // 結果マップを定義します
    const resultMap: Record<ObjectSpecifier<ObjectTypeA>, Double> = {};

    /* メモリーに読み込めるオブジェクト数には制限があります。
     * 現在のオブジェクトセットの読み込み制限については、適用される制限のドキュメントを参照してください。
     * Workshop はユーザーのスクロールに応じて遅延読み込みできるため、これは問題にならないはずです。
     */
    const allObjs: Osdk.Instance<ObjectTypeA, never, "exampleProperty">[] = [];
    for await (const obj of objects.asyncIter({ $select: ["exampleProperty"] })) {
        allObjs.push(obj);
    }

    // 配列内の各オブジェクトの計算を並列で開始します
    const promises = allObjs.map(currObject => computeForThisObject(currObject, scalar));

    // Promise.all を使ってヘルパー関数の非同期実行を並列化します
    const allResolvedPromises = await Promise.all(promises);

    // resultMap に結果を設定します
    allObjs.forEach((obj, i) => {
        const result = allResolvedPromises[i];
        if (result !== undefined) {
            resultMap[obj.$objectSpecifier] = result;
        }
    });

    return resultMap;
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import { Client, ObjectSet, ObjectSpecifier, Osdk } from "@osdk/client";
import { ObjectTypeA, ObjectTypeB } from "@ontology/sdk";
import { Double } from "@osdk/functions";

// オブジェクトの値を合計します
async function sumValue(objs: ObjectSet<ObjectTypeB>): Promise<Double> {
    const aggregation = await objs.aggregate({
        $select: { "propertyToAggregateB:sum": "unordered" },
    });
    return aggregation.propertyToAggregateB.sum ?? 0;
}

// null でないオブジェクトの値を合計します
async function sumValueIfPresent(objs: ObjectSet<ObjectTypeB>): Promise<Double> {
    const aggregation = await objs
        .where({ metric: { $isNull: false } })
        .aggregate({ $select: { "propertyToAggregateA:sum": "unordered" } });
    return aggregation.propertyToAggregateA.sum ?? 0;
}

async function computeMetricB(objs: ObjectSet<ObjectTypeB>): Promise<Double> {
    // 式の各部分の呼び出しを準備し、並列で実行します
    const [sum, sumIfPresent] = await Promise.all([sumValue(objs), sumValueIfPresent(objs)]);

    // 計算を実行します
    return sum / sumIfPresent;
}

/**
 * 指定されたオブジェクトについて、必要な値を計算する関数の例です。
 * 指定されたオブジェクトについて、オントロジーをクエリします（ほかのオブジェクトへの絞り込み、別のオブジェクトセットへのピボットなど）。
 */
async function computeForThisObjectFilterOntology(client: Client, obj: Osdk.Instance<ObjectTypeA, never, "exampleProperty">): Promise<Double> {
    // いくつかのプロパティで絞り込み、オブジェクトセットを作成します
    const currObjectSet = client(ObjectTypeB).where({ property: { $eq: obj.exampleProperty } });
    // 注：オブジェクトタイプ間に既存のリンクがある場合は、次の代替方法を使えます。
    // const currObjectSet = obj.$link.objectTypeB;

    // このオブジェクトセットの集計を計算します
    return await computeMetricB(currObjectSet);
}

/**
 * ObjectSet を入力として受け取り、派生列を生成します。
 * 各オブジェクトについて computeForThisObjectFilterOntology を並列で呼び出します。
 */
export default async function getDerivedColumnFilterOntology(
    client: Client,
    objects: ObjectSet<ObjectTypeA>
): Promise<Record<ObjectSpecifier<ObjectTypeA>, Double>> {
    const resultMap: Record<ObjectSpecifier<ObjectTypeA>, Double> = {};

    const allObjs: Osdk.Instance<ObjectTypeA, never, "exampleProperty">[] = [];
    for await (const obj of objects.asyncIter({ $select: ["exampleProperty"] })) {
        allObjs.push(obj);
    }

    const results = await Promise.all(
        allObjs.map(obj => computeForThisObjectFilterOntology(client, obj))
    );
    allObjs.forEach((obj, i) => {
        resultMap[obj.$objectSpecifier] = results[i];
    });

    return resultMap;
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import { ObjectSet, Osdk } from "@osdk/client";
import { ObjectTypeA } from "@ontology/sdk";
import { Double, TwoDimensionalAggregation } from "@osdk/functions";

export default async function getDerivedColumnParallelAsTwoDimensional(
    objects: ObjectSet<ObjectTypeA>,
    scalar: Double
): Promise<TwoDimensionalAggregation<string, Double>> {
    const allObjs: Osdk.Instance<ObjectTypeA, never, "exampleProperty">[] = [];
    for await (const obj of objects.asyncIter({ $select: ["exampleProperty"] })) {
        allObjs.push(obj);
    }

    // 上記の並列実行の例にある computeForThisObject を再利用します
    const allResolvedPromises = await Promise.all(allObjs.map(currObject => computeForThisObject(currObject, scalar)));

    // 計算した値から、主キープロパティをキーとする TwoDimensionalAggregation を作成します
    return allObjs
        .map((obj, i) => ({ key: String(obj.$primaryKey), value: allResolvedPromises[i] }))
        .filter((bucket): bucket is { key: string; value: Double } => bucket.value !== undefined);
}