mirrors/perspective-dev--perspective
1
0
Fork 0
Code Issues Pull Requests Actions Deployments Models Agent Notes Packages Projects Releases Wiki Activity

chore: import upstream snapshot with attribution

Browse Source
This commit is contained in:
wehub-resource-sync
2026-07-13 12:25:07 +08:00
commit a26e856398
1681 changed files with 296950 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tools/bench/cross_platform_suite.mjs
+344
View File
@@ -0,0 +1,344 @@
// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
// ┃ ██████ ██████ ██████ █ █ █ █ █ █▄ ▀███ █ ┃
// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█ ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄ ▀█ █ ▀▀▀▀▀ ┃
// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄ █ ▄▄▄▄▄ ┃
// ┃ █ ██████ █ ▀█▄ █ ██████ █ ███▌▐███ ███████▄ █ ┃
// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
// ┃ Copyright (c) 2017, the Perspective Authors. ┃
// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
// ┃ This file is part of the Perspective library, distributed under the terms ┃
// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
import { benchmark } from "./src/js/benchmark.mjs";
import {
check_version_gte,
new_superstore_table,
} from "./src/js/superstore.mjs";
export async function join_suite(perspective, metadata) {
if (check_version_gte(metadata.version, "4.4.0")) {
async function before_all() {
const left = await perspective.table(
new_superstore_table(metadata),
);
const columns = await left.columns();
const expressions = Object.fromEntries(
columns
.filter((x) => x !== "Row ID")
.map((x) => [`${x}_2`, `"${x}"`]),
);
const view = await left.view({
columns: ["Row ID", ...Object.keys(expressions)],
expressions,
});
const right = await perspective.table(await view.to_arrow());
await view.delete();
return { left, right };
}
async function after_all({ left, right }) {
await left.delete();
await right.delete();
}
await benchmark({
name: `.join()`,
before_all,
after_all,
metadata,
async after(_, joined) {
await joined.delete();
},
async test({ left, right }) {
return await perspective.join(left, right, "Row ID");
},
});
}
}
export async function to_data_suite(perspective, metadata) {
async function before_all() {
const table = await perspective.table(new_superstore_table(metadata));
const view = await table.view();
return { table, view };
}
async function after_all({ table, view }) {
if (check_version_gte(metadata.version, "2.10.9")) {
await view.delete();
}
if (check_version_gte(metadata.version, "3.0.0")) {
await table.delete();
}
}
await benchmark({
name: `.to_arrow()`,
before_all,
after_all,
metadata,
async test({ view }) {
const _arrow = await view.to_arrow();
},
});
await benchmark({
name: `.to_csv()`,
before_all,
after_all,
metadata,
async test({ view }) {
const _csv = await view.to_csv();
},
});
await benchmark({
name: `.to_columns()`,
before_all,
after_all,
metadata,
async test({ view }) {
const _columns = await view.to_columns();
},
});
await benchmark({
name: `.to_json()`,
before_all,
after_all,
metadata,
async test({ view }) {
const _json = await view.to_json();
},
});
}
export async function view_suite(perspective, metadata) {
async function before_all() {
const table = await perspective.table(new_superstore_table(metadata));
const schema = await table.schema();
return { table, schema };
}
async function after_all({ table }) {
if (check_version_gte(metadata.version, "3.0.0")) {
await table.delete();
}
}
async function after({ table }, view) {
if (check_version_gte(metadata.version, "2.10.9")) {
await view.delete();
}
}
await benchmark({
name: `.view()`,
before_all,
after_all,
after,
metadata,
async test({ table }) {
return await table.view();
},
});
await benchmark({
name: `.view({group_by})`,
before_all,
after_all,
after,
metadata,
async test({ table }) {
if (check_version_gte(metadata.version, "1.2.0")) {
return await table.view({ group_by: ["Product Name"] });
} else {
return await table.view({ row_pivots: ["Product Name"] });
}
},
});
await benchmark({
name: `.view({expressions})`,
before_all,
after_all,
after,
metadata,
async test({ table }) {
if (check_version_gte(metadata.version, "2.7.0")) {
return await table.view({
columns: ["AAA"],
expressions: {
AAA: `("Sales" + "Profit") / 2`,
},
});
} else {
return await table.view({
columns: ["AAA"],
expressions: [`//AAA\n("Sales" + "Profit") / 2`],
});
}
},
});
await benchmark({
name: `.view({group_by, aggregates: "median"})`,
before_all,
after_all,
after,
metadata,
async test({ table, schema }) {
const columns = ["Sales", "Quantity", "City"];
const aggregates = Object.fromEntries(
Object.keys(schema).map((x) => [x, "median"]),
);
if (check_version_gte(metadata.version, "1.2.0")) {
return await table.view({
group_by: ["State"],
aggregates,
columns,
});
} else {
return await table.view({
row_pivots: ["State"],
aggregates,
columns,
});
}
},
});
}
export async function table_suite(perspective, metadata) {
async function before_all() {
try {
const table = await perspective.table(
new_superstore_table(metadata),
);
const view = await table.view();
const csv = await view.to_csv();
const arrow = await view.to_arrow();
const json = await view.to_json();
const columns = await view.to_columns();
if (check_version_gte(metadata.version, "2.10.9")) {
await view.delete();
}
if (check_version_gte(metadata.version, "3.0.0")) {
await table.delete();
}
return { csv, arrow, table, json, columns };
} catch (e) {
console.error(e);
}
}
if (check_version_gte(metadata.version, "2.3.0")) {
await benchmark({
name: `.table(arrow, {limit: 1000})`,
before_all,
metadata,
async after(_, table) {
if (check_version_gte(metadata.version, "3.0.0")) {
await table.delete();
}
},
async test({ arrow }) {
return await perspective.table(arrow.slice(), { limit: 1000 });
},
});
}
await benchmark({
name: `.table(arrow)`,
before_all,
metadata,
async after(_, table) {
if (check_version_gte(metadata.version, "3.0.0")) {
await table.delete();
}
},
async test({ table, arrow }) {
return await perspective.table(arrow.slice());
},
});
if (check_version_gte(metadata.version, "3.0.0")) {
await benchmark({
name: `table.update(arrow)`,
before_all,
metadata,
async before({ arrow }) {
let table2 = await perspective.table(arrow.slice(), {
limit: 1000,
});
return table2;
},
async after(_, table) {
if (!check_version_gte(metadata.version, "3.4.3")) {
// Bug with old versions of perspective segfault when you delete
// a table with pending updates.
await table.size();
}
await table.delete();
},
async test({ arrow }, table2) {
for (let i = 0; i < 3; i++) {
await table2.update(arrow.slice());
}
},
});
}
await benchmark({
name: `.table(csv)`,
before_all,
metadata,
async after(_, table) {
if (check_version_gte(metadata.version, "3.0.0")) {
await table.delete();
}
},
async test({ csv }) {
return await perspective.table(csv);
},
});
await benchmark({
name: `.table(json)`,
before_all,
metadata,
async after(_, table) {
if (check_version_gte(metadata.version, "3.0.0")) {
await table.delete();
}
},
async test({ table, json }) {
return await perspective.table(json);
},
});
await benchmark({
name: `.table(columns)`,
before_all,
metadata,
async after(_, table) {
if (check_version_gte(metadata.version, "3.0.0")) {
await table.delete();
}
},
async test({ table, columns }) {
return await perspective.table(columns);
},
});
}