wehub-resource-sync
3375 lines
125 KiB
JavaScript
3375 lines
125 KiB
JavaScript
// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
|
|
// ┃ ██████ ██████ ██████ █ █ █ █ █ █▄ ▀███ █ ┃
|
|
// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█ ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄ ▀█ █ ▀▀▀▀▀ ┃
|
|
// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄ █ ▄▄▄▄▄ ┃
|
|
// ┃ █ ██████ █ ▀█▄ █ ██████ █ ███▌▐███ ███████▄ █ ┃
|
|
// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// ┃ 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 * as expressions_common from "./common.js";
|
|
|
|
import { test, expect } from "@perspective-dev/test";
|
|
import perspective from "../perspective_client";
|
|
|
|
/**
|
|
* Tests the functionality of `View`-based expressions, specifically that
|
|
* existing column/view semantics (pivots, aggregates, columns, sorts, filters)
|
|
* continue to be functional on expressions.
|
|
*/
|
|
((perspective) => {
|
|
test.describe("Expression structures", function () {
|
|
test.describe("if statements", function () {
|
|
test("if without else should be invalid", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const validate = await table.validate_expressions([
|
|
'if ("w" > 1) 5;',
|
|
'if ("w" > 1) 5',
|
|
]);
|
|
|
|
expect(
|
|
validate.expression_schema['if ("w" > 1) 5;'],
|
|
).toBeUndefined();
|
|
expect(
|
|
validate.expression_schema['if ("w" > 1) 5'],
|
|
).toBeUndefined();
|
|
|
|
expect(validate.errors).toEqual({
|
|
'if ("w" > 1) 5': {
|
|
column: 0,
|
|
error_message:
|
|
"Type Error - inputs do not resolve to a valid expression.",
|
|
line: 0,
|
|
},
|
|
'if ("w" > 1) 5;': {
|
|
column: 0,
|
|
error_message:
|
|
"Type Error - inputs do not resolve to a valid expression.",
|
|
line: 0,
|
|
},
|
|
});
|
|
|
|
table.delete();
|
|
});
|
|
|
|
test.skip("if else with multiple return types should be invalid", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: {
|
|
"if (\"w\" == 1.5) 5; else 'abc'":
|
|
"if (\"w\" == 1.5) 5; else 'abc'",
|
|
},
|
|
});
|
|
const results = await view.to_columns();
|
|
|
|
// TODO: we should prevent this polymorphic return from being
|
|
// allowed, but the machinery around how if/else returns is
|
|
// opaque to me at the moment.
|
|
expect(results["if (\"w\" == 1.5) 5; else 'abc'"]).toEqual([
|
|
"",
|
|
"abc",
|
|
"abc",
|
|
"abc",
|
|
]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("functional if", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
'if ("w" > 2, 5, 10);',
|
|
'if ("w" == 1.5, 5, 10)',
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results['if ("w" > 2, 5, 10);']).toEqual([10, 5, 5, 5]);
|
|
expect(results['if ("w" == 1.5, 5, 10)']).toEqual([
|
|
5, 10, 10, 10,
|
|
]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("functional if string", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
"if (\"y\" == 'a', 5, 10);",
|
|
"if (\"y\" != 'a', 5, 10)",
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results["if (\"y\" == 'a', 5, 10);"]).toEqual([
|
|
5, 10, 10, 10,
|
|
]);
|
|
expect(results["if (\"y\" != 'a', 5, 10)"]).toEqual([
|
|
10, 5, 5, 5,
|
|
]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test.skip("functional if bool", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
'if ("z" == true, 5, 10);',
|
|
'if ("z" != true, 5, 10)',
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results['if ("z" == 1, 5, 10);']).toEqual([
|
|
5, 10, 5, 10,
|
|
]);
|
|
expect(results['if ("z" != true, 5, 10)']).toEqual([
|
|
10, 5, 10, 5,
|
|
]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("functional if date", async function () {
|
|
const table = await perspective.table({
|
|
a: "date",
|
|
b: "date",
|
|
});
|
|
|
|
const view = await table.view({
|
|
expressions: [
|
|
'if ("a" == "b", 5, 10);',
|
|
'if ("a" < "b", 5, 10)',
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
await table.update({
|
|
a: [
|
|
new Date(2020, 3, 1),
|
|
new Date(2012, 0, 30),
|
|
new Date(2018, 9, 31),
|
|
new Date(2020, 1, 29),
|
|
],
|
|
b: [
|
|
new Date(2020, 3, 1),
|
|
new Date(2012, 1, 30),
|
|
new Date(2018, 10, 31),
|
|
new Date(2020, 1, 29),
|
|
],
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results['if ("a" == "b", 5, 10);']).toEqual([
|
|
5, 10, 10, 5,
|
|
]);
|
|
expect(results['if ("a" < "b", 5, 10)']).toEqual([
|
|
10, 5, 5, 10,
|
|
]);
|
|
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("functional if datetime", async function () {
|
|
const table = await perspective.table({
|
|
a: "datetime",
|
|
b: "datetime",
|
|
});
|
|
|
|
const view = await table.view({
|
|
expressions: [
|
|
'if ("a" >= "b", 5, 10);',
|
|
'if ("a" < "b", 5, 10)',
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
await table.update({
|
|
a: [
|
|
new Date(2020, 3, 1, 12, 30, 45, 850),
|
|
new Date(2012, 0, 30, 19, 25),
|
|
new Date(2018, 9, 31, 3, 13),
|
|
new Date(2020, 1, 29, 23, 59, 59),
|
|
],
|
|
b: [
|
|
new Date(2020, 3, 1, 12, 30, 45, 850),
|
|
new Date(2012, 1, 30),
|
|
new Date(2018, 10, 31),
|
|
new Date(2020, 1, 29),
|
|
],
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results['if ("a" >= "b", 5, 10);']).toEqual([
|
|
5, 10, 10, 5,
|
|
]);
|
|
expect(results['if ("a" < "b", 5, 10)']).toEqual([
|
|
10, 5, 5, 10,
|
|
]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("ternary if", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: {
|
|
'"w" > 2 ? 5 : 10;': '"w" > 2 ? 5 : 10;',
|
|
'"w" == 1.5 ? 5 : 10': '"w" == 1.5 ? 5 : 10',
|
|
},
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results['"w" > 2 ? 5 : 10;']).toEqual([10, 5, 5, 5]);
|
|
expect(results['"w" == 1.5 ? 5 : 10']).toEqual([5, 10, 10, 10]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("ternary if string", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
"\"y\" == 'a' ? 5 : 10;",
|
|
"\"y\" != 'a' ? 5 : 10",
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results["\"y\" == 'a' ? 5 : 10;"]).toEqual([
|
|
5, 10, 10, 10,
|
|
]);
|
|
expect(results["\"y\" != 'a' ? 5 : 10"]).toEqual([10, 5, 5, 5]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test.skip("ternary if bool", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
'"z" == true ? 5 : 10;',
|
|
'"z" != true ? 5 : 10',
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results['"z" == 1 ? 5 : 10;']).toEqual([5, 10, 5, 10]);
|
|
expect(results['"z" != true ? 5 : 10']).toEqual([10, 5, 10, 5]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("ternary if date", async function () {
|
|
const table = await perspective.table({
|
|
a: "date",
|
|
b: "date",
|
|
});
|
|
|
|
const view = await table.view({
|
|
expressions: {
|
|
'"a" == "b" ? 5 : 10;': '"a" == "b" ? 5 : 10;',
|
|
'"a" < "b" ? 5 : 10': '"a" < "b" ? 5 : 10',
|
|
},
|
|
});
|
|
|
|
await table.update({
|
|
a: [
|
|
new Date(2020, 3, 1),
|
|
new Date(2012, 0, 30),
|
|
new Date(2018, 9, 31),
|
|
new Date(2020, 1, 29),
|
|
],
|
|
b: [
|
|
new Date(2020, 3, 1),
|
|
new Date(2012, 1, 30),
|
|
new Date(2018, 10, 31),
|
|
new Date(2020, 1, 29),
|
|
],
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results['"a" == "b" ? 5 : 10;']).toEqual([5, 10, 10, 5]);
|
|
expect(results['"a" < "b" ? 5 : 10']).toEqual([10, 5, 5, 10]);
|
|
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("ternary if datetime", async function () {
|
|
const table = await perspective.table({
|
|
a: "datetime",
|
|
b: "datetime",
|
|
});
|
|
|
|
const view = await table.view({
|
|
expressions: {
|
|
'"a" >= "b" ? 5 : 10;': '"a" >= "b" ? 5 : 10;',
|
|
'"a" < "b" ? 5 : 10': '"a" < "b" ? 5 : 10',
|
|
},
|
|
});
|
|
|
|
await table.update({
|
|
a: [
|
|
new Date(2020, 3, 1, 12, 30, 45, 850),
|
|
new Date(2012, 0, 30, 19, 25),
|
|
new Date(2018, 9, 31, 3, 13),
|
|
new Date(2020, 1, 29, 23, 59, 59),
|
|
],
|
|
b: [
|
|
new Date(2020, 3, 1, 12, 30, 45, 850),
|
|
new Date(2012, 1, 30),
|
|
new Date(2018, 10, 31),
|
|
new Date(2020, 1, 29),
|
|
],
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results['"a" >= "b" ? 5 : 10;']).toEqual([5, 10, 10, 5]);
|
|
expect(results['"a" < "b" ? 5 : 10']).toEqual([10, 5, 5, 10]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("if else", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
'if ("w" > 2) 5; else 10',
|
|
'if ("w" > 2) 5; else 10;',
|
|
'if ("w" > 2) { \n5; } else { \n10;}',
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results['if ("w" > 2) 5; else 10']).toEqual([
|
|
10, 5, 5, 5,
|
|
]);
|
|
expect(results['if ("w" > 2) 5; else 10;']).toEqual([
|
|
10, 5, 5, 5,
|
|
]);
|
|
expect(results['if ("w" > 2) { \n5; } else { \n10;}']).toEqual([
|
|
10, 5, 5, 5,
|
|
]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("if else if", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
'if ("w" == 3.5) 15; else if ("w" > 2) 5; else 10',
|
|
'if ("w" == 3.5) 15; else if ("w" > 2) 5; else 10;',
|
|
'if ("w" == 3.5) { \n15; } else if ("w" > 2) { \n5; } else { \n10;}',
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results['if ("w" == 3.5) 15; else if ("w" > 2) 5; else 10'],
|
|
).toEqual([10, 5, 15, 5]);
|
|
expect(
|
|
results[
|
|
'if ("w" == 3.5) 15; else if ("w" > 2) 5; else 10;'
|
|
],
|
|
).toEqual([10, 5, 15, 5]);
|
|
expect(
|
|
results[
|
|
'if ("w" == 3.5) { \n15; } else if ("w" > 2) { \n5; } else { \n10;}'
|
|
],
|
|
).toEqual([10, 5, 15, 5]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
});
|
|
|
|
test.describe("Switch", function () {
|
|
test("Switch on multiple columns", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`switch { case "w" > 2: sqrt(144); case "y" == 'a': sqrt(121); default: 0; }`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`switch { case "w" > 2: sqrt(144); case "y" == 'a': sqrt(121); default: 0; }`
|
|
],
|
|
).toEqual([11, 12, 12, 12]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Switch on multiple columns with resulting expression", async function () {
|
|
const table = await perspective.table({
|
|
w: "float",
|
|
x: "float",
|
|
y: "string",
|
|
z: "boolean",
|
|
});
|
|
await table.update(expressions_common.int_float_data);
|
|
const expr = `switch { case "w" > 2: (sqrt(144) * "w"); case "y" == 'a': (sqrt(121) * "w"); default: "x"; }`;
|
|
const view = await table.view({
|
|
expressions: { [expr]: expr },
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
const schema = await view.schema();
|
|
expect(schema[expr]).toEqual("float");
|
|
expect(results[expr]).toEqual([16.5, 30, 42, 54]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
});
|
|
|
|
test.describe("While loop", function () {
|
|
test("Scalar while", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
|
|
// 2 ^ 10 = 1024
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := 1; var y := 0; while (y < 10) { x := x * 2; y += 1; }; x`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`var x := 1; var y := 0; while (y < 10) { x := x * 2; y += 1; }; x`
|
|
],
|
|
).toEqual([1024, 1024, 1024, 1024]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Scalar while 2", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
|
|
// 2 * 2 = 4, 4 * 4 = 16, 16 * 16 = 256
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := 2; var y := 0; while (y < 3) { x := x * x; y += 1; }; x`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`var x := 2; var y := 0; while (y < 3) { x := x * x; y += 1; }; x`
|
|
],
|
|
).toEqual([256, 256, 256, 256]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("While without semicolon should not validate", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
|
|
const schema = await table.validate_expressions({
|
|
[`expr`]: `var x := 2; var y := 0; while (y < 3) { x := x * x; y += 1; } x`,
|
|
});
|
|
|
|
expect(schema.expression_schema["expr"]).toBeUndefined();
|
|
expect(schema.errors["expr"]).toEqual({
|
|
column: 62,
|
|
line: 0,
|
|
error_message:
|
|
"Invalid syntax 'x' possible missing operator or context",
|
|
});
|
|
|
|
await table.delete();
|
|
});
|
|
|
|
test("Column while", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := 0; var y := 0; while (y < 10) { x := "w" * 2; y += 1; }; x`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`var x := 0; var y := 0; while (y < 10) { x := "w" * 2; y += 1; }; x`
|
|
],
|
|
).toEqual([3, 5, 7, 9]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test.skip("Column while with break", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := 0; var y := 0; while (y < 10) { if (y % 2 == 0) { break; }; x := "w" * 2; y += 1; }; x`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`var x := 0; var y := 0; while (y < 10) { if (y % 2 == 0) { break; }; x := "w" * 2; y += 1; }; x`
|
|
],
|
|
).toEqual([16.5, 30, 42, 54]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
});
|
|
|
|
test.describe("For loop", function () {
|
|
test("For loop", async () => {
|
|
const expr = `var x := 0; for (var i := 0; i < 3; i += 1) { x += 1; }; x`;
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { expression: expr },
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results["expression"]).toEqual([3, 3, 3, 3]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Scalar for", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`for (var x := 0; x < 10; x += 1) { var y := x + 1; y}`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`for (var x := 0; x < 10; x += 1) { var y := x + 1; y}`
|
|
],
|
|
).toEqual([10, 10, 10, 10]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Column for", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`for (var x := 0; x < 10; x += 1) { var y := "w" + 1; y}`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`for (var x := 0; x < 10; x += 1) { var y := "w" + 1; y}`
|
|
],
|
|
).toEqual([2.5, 3.5, 4.5, 5.5]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test.skip("for loop only valid on numbers", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
// `for (var x := today(); x < 10; x += 1) { var y := "w" + 1; y}`
|
|
const expressions = [
|
|
`for (var x := 'abc'; x < 10; x += 1) { var y := "w" + 1; y}`,
|
|
];
|
|
const validate = await table.validate_expressions(expressions);
|
|
|
|
for (const expr of expressions) {
|
|
expect(validate.expression_schema[expr]).toBeUndefined();
|
|
}
|
|
|
|
await table.delete();
|
|
});
|
|
});
|
|
|
|
test.describe.skip("Repeat loop", function () {
|
|
test("Scalar repeat", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := 1; var y := 1; repeat x := x + (y * 2) until (x > 10)`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`var x := 1; var y := 1; repeat x := x + (y * 2) until (x > 10)`
|
|
],
|
|
).toEqual([11, 11, 11, 11]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Column repeat", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := 1; repeat x := x + ("x" * 2) until (x > 10)`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`var x := 1; repeat x := x + ("x" * 2) until (x > 10)`
|
|
],
|
|
).toEqual([16.5, 30, 42, 54]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
});
|
|
});
|
|
|
|
test.describe("Local variables", function () {
|
|
test("Declare numeric", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { 1: "1", [`100.0000001`]: "100.0000001" },
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results["1"]).toEqual([1, 1, 1, 1]);
|
|
expect(results["100.0000001"]).toEqual([
|
|
100.0000001, 100.0000001, 100.0000001, 100.0000001,
|
|
]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Declare string", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
"'hello'",
|
|
"'very long string that is very long and has many characters'",
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results["'hello'"]).toEqual([
|
|
"hello",
|
|
"hello",
|
|
"hello",
|
|
"hello",
|
|
]);
|
|
expect(
|
|
results[
|
|
"'very long string that is very long and has many characters'"
|
|
],
|
|
).toEqual([
|
|
"very long string that is very long and has many characters",
|
|
"very long string that is very long and has many characters",
|
|
"very long string that is very long and has many characters",
|
|
"very long string that is very long and has many characters",
|
|
]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Clear() and declare string", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
|
|
const view = await table.view({
|
|
expressions: [
|
|
"'hello'",
|
|
"'very long string that is very long and has many characters'",
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results["'hello'"]).toEqual([
|
|
"hello",
|
|
"hello",
|
|
"hello",
|
|
"hello",
|
|
]);
|
|
expect(
|
|
results[
|
|
"'very long string that is very long and has many characters'"
|
|
],
|
|
).toEqual([
|
|
"very long string that is very long and has many characters",
|
|
"very long string that is very long and has many characters",
|
|
"very long string that is very long and has many characters",
|
|
"very long string that is very long and has many characters",
|
|
]);
|
|
|
|
await view.delete();
|
|
await table.clear();
|
|
|
|
await table.update([expressions_common.int_float_data[0]]);
|
|
|
|
const view2 = await table.view({
|
|
expressions: [
|
|
"'hello'",
|
|
"'another very long string with many characters'",
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results2 = await view2.to_columns();
|
|
expect(results2["'hello'"]).toEqual(["hello"]);
|
|
expect(
|
|
results2["'another very long string with many characters'"],
|
|
).toEqual(["another very long string with many characters"]);
|
|
|
|
await view2.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Declare numeric var", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := 10; var y := -100.00005; var z := x + y; abs(z)`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`var x := 10; var y := -100.00005; var z := x + y; abs(z)`
|
|
],
|
|
).toEqual([90.00005, 90.00005, 90.00005, 90.00005]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Declare numeric var 0 and 1", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const expressions = ["1", "0", "var x := 1; x", "var x := 0; x"];
|
|
const view = await table.view({
|
|
expressions,
|
|
});
|
|
|
|
const schema = await view.expression_schema();
|
|
|
|
for (const expr of expressions) {
|
|
expect(schema[expr]).toEqual("float");
|
|
}
|
|
|
|
const results = await view.to_columns();
|
|
expect(results["1"]).toEqual(Array(4).fill(1));
|
|
expect(results["0"]).toEqual(Array(4).fill(0));
|
|
expect(results["var x := 1; x"]).toEqual(Array(4).fill(1));
|
|
expect(results["var x := 0; x"]).toEqual(Array(4).fill(0));
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Declare string var", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := 'long literal string here'; var y := 'long literal string here'; x == y ? concat('strings: ', x, ', ', y) : 'nope'`,
|
|
`var x := 'hello'; var y := upper(x); lower(y);`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`var x := 'long literal string here'; var y := 'long literal string here'; x == y ? concat('strings: ', x, ', ', y) : 'nope'`
|
|
],
|
|
).toEqual([
|
|
"strings: long literal string here, long literal string here",
|
|
"strings: long literal string here, long literal string here",
|
|
"strings: long literal string here, long literal string here",
|
|
"strings: long literal string here, long literal string here",
|
|
]);
|
|
expect(
|
|
results[`var x := 'hello'; var y := upper(x); lower(y);`],
|
|
).toEqual(["hello", "hello", "hello", "hello"]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Declare string var one long one short", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := 'abcdefghijklmnop'; var y := '123'; concat(x, y)`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`var x := 'abcdefghijklmnop'; var y := '123'; concat(x, y)`
|
|
],
|
|
).toEqual([
|
|
"abcdefghijklmnop123",
|
|
"abcdefghijklmnop123",
|
|
"abcdefghijklmnop123",
|
|
"abcdefghijklmnop123",
|
|
]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Declare string var short", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: {
|
|
"var x := 'abc'; var y := '123'; concat(x, y)":
|
|
"var x := 'abc'; var y := '123'; concat(x, y)",
|
|
},
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[`var x := 'abc'; var y := '123'; concat(x, y)`],
|
|
).toEqual(["abc123", "abc123", "abc123", "abc123"]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Clear() and Declare string var", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
"var x := 'Eabcdefghijklmn'; var y := '0123456789'; var z := 'ABCD'; var zz := 'EFG'; concat(x, y, z, zz)",
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
"var x := 'Eabcdefghijklmn'; var y := '0123456789'; var z := 'ABCD'; var zz := 'EFG'; concat(x, y, z, zz)"
|
|
],
|
|
).toEqual([
|
|
"Eabcdefghijklmn0123456789ABCDEFG",
|
|
"Eabcdefghijklmn0123456789ABCDEFG",
|
|
"Eabcdefghijklmn0123456789ABCDEFG",
|
|
"Eabcdefghijklmn0123456789ABCDEFG",
|
|
]);
|
|
|
|
await view.delete();
|
|
|
|
await table.clear();
|
|
|
|
await table.update([expressions_common.int_float_data[0]]);
|
|
|
|
const view2 = await table.view({
|
|
expressions: [
|
|
"var x := 'Eabcdefghijklmn'; var y := '0123456789'; var z := 'ABCD'; var zz := 'EFG'; concat(x, y, z, zz)",
|
|
"var x := 'abcdefghijklmn'; var y := 'ABCDEFG123456789'; x",
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results2 = await view2.to_columns();
|
|
expect(
|
|
results2[
|
|
"var x := 'Eabcdefghijklmn'; var y := '0123456789'; var z := 'ABCD'; var zz := 'EFG'; concat(x, y, z, zz)"
|
|
],
|
|
).toEqual(["Eabcdefghijklmn0123456789ABCDEFG"]);
|
|
|
|
expect(
|
|
results2[
|
|
"var x := 'abcdefghijklmn'; var y := 'ABCDEFG123456789'; x"
|
|
],
|
|
).toEqual(["abcdefghijklmn"]);
|
|
|
|
await view2.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Declare date var", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := today(); var y := today(); x == y ? 1 : 0;`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[`var x := today(); var y := today(); x == y ? 1 : 0;`],
|
|
).toEqual([1, 1, 1, 1]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Declare datetime var", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const now = new Date().getTime();
|
|
const view = await table.view({
|
|
expressions: { "now()": "now()" },
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
|
|
for (const x of results["now()"]) {
|
|
expect(now - 1000 < x < now + 1000).toBe(true);
|
|
}
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Declare boolean var", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := true; var y := false; x and y ? 1 : 0`,
|
|
`var x := true; var y := false; x or y`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[`var x := true; var y := false; x and y ? 1 : 0`],
|
|
).toEqual([0, 0, 0, 0]);
|
|
expect(results["var x := true; var y := false; x or y"]).toEqual([
|
|
true,
|
|
true,
|
|
true,
|
|
true,
|
|
]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Declare column as var", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: {
|
|
'var x := "w"; var y := 1.5; x > 2.5 ? x : y':
|
|
'var x := "w"; var y := 1.5; x > 2.5 ? x : y',
|
|
},
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[`var x := "w"; var y := 1.5; x > 2.5 ? x : y`],
|
|
).toEqual([1.5, 1.5, 3.5, 4.5]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Assign one type to var of another", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := 'w'; var y := 1.5; x := y; x`,
|
|
`var x := 'w'; var y := 1.5; y := x; y`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results[`var x := 'w'; var y := 1.5; x := y; x`]).toEqual([
|
|
1.5, 1.5, 1.5, 1.5,
|
|
]);
|
|
expect(results[`var x := 'w'; var y := 1.5; y := x; y`]).toEqual([
|
|
"w",
|
|
"w",
|
|
"w",
|
|
"w",
|
|
]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Assign to declared numeric var", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := 100; var y := 200.5; x := y; x`,
|
|
`var x := 10; var y := pow(x, 3); y := x; y`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results[`var x := 100; var y := 200.5; x := y; x`]).toEqual([
|
|
200.5, 200.5, 200.5, 200.5,
|
|
]);
|
|
expect(
|
|
results[`var x := 10; var y := pow(x, 3); y := x; y`],
|
|
).toEqual([10, 10, 10, 10]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Assign to declared string var", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := 'long literal string here'; var y := lower('ANOTHER VERY LONG STRING HERE'); x := y`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`var x := 'long literal string here'; var y := lower('ANOTHER VERY LONG STRING HERE'); x := y`
|
|
],
|
|
).toEqual([
|
|
"another very long string here",
|
|
"another very long string here",
|
|
"another very long string here",
|
|
"another very long string here",
|
|
]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Assign to declared date var", async function () {
|
|
const table = await perspective.table({
|
|
a: "date",
|
|
});
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := today(); var y := today(); var z := "a"; (x > z) and (y > z) ? 1 : 0`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const tomorrow = new Date();
|
|
tomorrow.setDate(new Date().getDate() + 1);
|
|
|
|
await table.update({
|
|
a: [
|
|
new Date(2020, 3, 1),
|
|
new Date(2012, 0, 30),
|
|
new Date(2018, 9, 31),
|
|
tomorrow,
|
|
],
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`var x := today(); var y := today(); var z := "a"; (x > z) and (y > z) ? 1 : 0`
|
|
],
|
|
).toEqual([1, 1, 1, 0]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Assign to declared datetime var", async function () {
|
|
const table = await perspective.table({
|
|
a: "datetime",
|
|
});
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := now(); var y := now(); var z := "a"; (x > z) and (y > z) ? 1 : 0`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const tomorrow = new Date();
|
|
tomorrow.setDate(new Date().getDate() + 1);
|
|
|
|
await table.update({
|
|
a: [
|
|
new Date(2020, 3, 1, 12, 30, 45, 850),
|
|
new Date(2012, 0, 30, 19, 25),
|
|
new Date(2018, 9, 31, 3, 13),
|
|
tomorrow,
|
|
],
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(
|
|
results[
|
|
`var x := now(); var y := now(); var z := "a"; (x > z) and (y > z) ? 1 : 0`
|
|
],
|
|
).toEqual([1, 1, 1, 0]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Assign to declared column as var", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
|
|
// test type transitions as assignments happen - from str to int,
|
|
// from float to str, etc.
|
|
const view = await table.view({
|
|
expressions: [
|
|
`var x := "w"; var y := x; x := "y"; x;`,
|
|
`var x := "z"; var y := x; x := "w"; x;`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
|
|
const results = await view.to_columns();
|
|
expect(results[`var x := "w"; var y := x; x := "y"; x;`]).toEqual([
|
|
"a",
|
|
"b",
|
|
"c",
|
|
"d",
|
|
]);
|
|
expect(results[`var x := "z"; var y := x; x := "w"; x;`]).toEqual([
|
|
1.5, 2.5, 3.5, 4.5,
|
|
]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
});
|
|
|
|
test.describe("Functionality", function () {
|
|
test("Should be able to create an expression column in `view()`", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result['"w" + "x"']).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should only parse first comment as an alias", async () => {
|
|
const table = await perspective.table({ a: [1, 2, 3] });
|
|
const view = await table.view({
|
|
expressions: [
|
|
"var x := 1 + 2;\n// another comment\nx + 3 + 4 # comment",
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
const schema = await view.expression_schema();
|
|
expect(schema).toEqual({
|
|
"var x := 1 + 2;\n// another comment\nx + 3 + 4 # comment":
|
|
"float",
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(
|
|
result[
|
|
"var x := 1 + 2;\n// another comment\nx + 3 + 4 # comment"
|
|
],
|
|
).toEqual(Array(3).fill(10));
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Should be able to alias a real column in `view()`", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.all_types_arrow.slice(),
|
|
);
|
|
const columns = await table.columns();
|
|
const view = await table.view({
|
|
expressions: columns.map((col) => `"${col}"`),
|
|
});
|
|
|
|
const schema = await view.schema();
|
|
const expression_schema = await view.expression_schema();
|
|
const result = await view.to_columns();
|
|
|
|
for (const col of columns) {
|
|
expect(expression_schema[`"${col}"`]).toEqual(schema[col]);
|
|
expect(result[`"${col}"`]).toEqual(result[col]);
|
|
}
|
|
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to create an expression column with scalars in `view()`", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: {
|
|
"1 + 2 + 3 + 4 + 5 + 6": "1 + 2 + 3 + 4 + 5 + 6",
|
|
},
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result["1 + 2 + 3 + 4 + 5 + 6"]).toEqual([21, 21, 21, 21]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to create a string expression column with scalars in `view()`", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
group_by: ["'abc'"], // checks that the strings are interned
|
|
expressions: { "'abc'": "'abc'" },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result["__ROW_PATH__"]).toEqual([[], ["abc"]]);
|
|
expect(result["'abc'"]).toEqual([4, 4]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to create a boolean expression column with scalars in `view()`", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
"0 and 1",
|
|
"0 or 1",
|
|
"true and true",
|
|
"false or true",
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
expect(await view.schema()).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
"0 and 1": "boolean",
|
|
"0 or 1": "boolean",
|
|
"true and true": "boolean",
|
|
"false or true": "boolean",
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result["0 and 1"]).toEqual([false, false, false, false]);
|
|
expect(result["0 or 1"]).toEqual([true, true, true, true]);
|
|
expect(result["true and true"]).toEqual([true, true, true, true]);
|
|
expect(result["false or true"]).toEqual([true, true, true, true]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Boolean scalars should not compare to numeric scalars", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
"0 and 1",
|
|
"0 or 1",
|
|
"true and true",
|
|
"false or true",
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
expect(await view.schema()).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
"0 and 1": "boolean",
|
|
"0 or 1": "boolean",
|
|
"true and true": "boolean",
|
|
"false or true": "boolean",
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result["0 and 1"]).toEqual([false, false, false, false]);
|
|
expect(result["0 or 1"]).toEqual([true, true, true, true]);
|
|
expect(result["true and true"]).toEqual([true, true, true, true]);
|
|
expect(result["false or true"]).toEqual([true, true, true, true]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to create an expression column with scalars and columns `view()`", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
columns: ['("w" + "x") ^ 2'],
|
|
expressions: { '("w" + "x") ^ 2': '("w" + "x") ^ 2' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result['("w" + "x") ^ 2']).toEqual(
|
|
[2.5, 4.5, 6.5, 8.5].map((x) => Math.pow(x, 2)),
|
|
);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to create a boolean expression column with scalars and columns in `view()`", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [
|
|
'"x" and 1',
|
|
'"x" or 1',
|
|
'"x" and true',
|
|
'"x" and false',
|
|
'"x" or true',
|
|
'"x" or false',
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
expect(await view.schema()).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"x" and 1': "boolean",
|
|
'"x" or 1': "boolean",
|
|
'"x" and true': "boolean",
|
|
'"x" and false': "boolean",
|
|
'"x" or true': "boolean",
|
|
'"x" or false': "boolean",
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result['"x" and 1']).toEqual([true, true, true, true]);
|
|
expect(result['"x" or 1']).toEqual([true, true, true, true]);
|
|
expect(result['"x" and true']).toEqual([true, true, true, true]);
|
|
expect(result['"x" and false']).toEqual([
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
]);
|
|
expect(result['"x" or true']).toEqual([true, true, true, true]);
|
|
expect(result['"x" or false']).toEqual([true, true, true, true]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to create an expression column in `view()` from schema, and updates propagate", async function () {
|
|
const table = await perspective.table({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
});
|
|
const view = await table.view({
|
|
expressions: { '("w" + "x") * 10': '("w" + "x") * 10' },
|
|
});
|
|
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
'("w" + "x") * 10': [],
|
|
w: [],
|
|
x: [],
|
|
y: [],
|
|
z: [],
|
|
});
|
|
|
|
await table.update(expressions_common.int_float_data);
|
|
|
|
const new_result = await view.to_columns();
|
|
expect(new_result['("w" + "x") * 10']).toEqual([25, 45, 65, 85]);
|
|
|
|
await table.update(expressions_common.int_float_data);
|
|
|
|
const new_result2 = await view.to_columns();
|
|
expect(new_result2['("w" + "x") * 10']).toEqual([
|
|
25, 45, 65, 85, 25, 45, 65, 85,
|
|
]);
|
|
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to create an expression column using an alias.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { "new column": '"w" + "x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result["new column"]).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Alias should be trimmed.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { "new column": '"w" + "x"' },
|
|
});
|
|
|
|
const result = await view.to_columns();
|
|
expect(result["new column"]).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
|
|
const view2 = await table.view({
|
|
expressions: { "new column": '"w" - "x"' },
|
|
});
|
|
|
|
const result2 = await view2.to_columns();
|
|
expect(result2["new column"]).toEqual([0.5, 0.5, 0.5, 0.5]);
|
|
|
|
await view2.delete();
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Should be able to create an expression column using a very long alias.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: {
|
|
"new column with lots of different strings and names and lots of good characters":
|
|
'"w" + "x"',
|
|
},
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(
|
|
result[
|
|
"new column with lots of different strings and names and lots of good characters"
|
|
],
|
|
).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Comments after the alias are not picked up.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: {
|
|
alias: 'var x := "w" + "x"\n// a comment\n# another comment\n/* another comment here */\n',
|
|
},
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result["alias"]).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Duplicate alias within the same view should resolve to the last expression.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
|
|
const view = await table.view({
|
|
expressions: {
|
|
"new column": '"w" + "x"',
|
|
"new column 1": '"w" - "x"',
|
|
"new column": "100 * 10",
|
|
"new column 1": '"w" + "x"',
|
|
"new column": '"w" - "x"',
|
|
},
|
|
});
|
|
|
|
expect(await view.expression_schema()).toEqual({
|
|
"new column": "float",
|
|
"new column 1": "float",
|
|
});
|
|
|
|
const result = await view.to_columns();
|
|
|
|
expect(result["new column"]).toEqual([0.5, 0.5, 0.5, 0.5]);
|
|
expect(result["new column 1"]).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Duplicate alias within the same view should resolve to the last expression, different types.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
|
|
const view = await table.view({
|
|
expressions: {
|
|
"new column": '"w" + "x"',
|
|
"new column 1": '"w" - "x"',
|
|
"new column": "100",
|
|
"new column": "upper('abc')",
|
|
"new column 1": '"w" + "x"',
|
|
},
|
|
});
|
|
|
|
expect(await view.expression_schema()).toEqual({
|
|
"new column": "string",
|
|
"new column 1": "float",
|
|
});
|
|
|
|
const result = await view.to_columns();
|
|
|
|
expect(result["new column"]).toEqual(Array(4).fill("ABC"));
|
|
expect(result["new column 1"]).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Duplicate alias across new views will not overwrite results in old view.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { "new column": '"w" + "x"' },
|
|
});
|
|
|
|
let result = await view.to_columns();
|
|
expect(result["new column"]).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
|
|
const view2 = await table.view({
|
|
expressions: { "new column": "100 * 10" },
|
|
});
|
|
|
|
expect(await view.expression_schema()).toEqual(
|
|
await view2.expression_schema(),
|
|
);
|
|
|
|
result = await view.to_columns();
|
|
const result2 = await view2.to_columns();
|
|
expect(result["new column"]).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
expect(result2["new column"]).toEqual([1000, 1000, 1000, 1000]);
|
|
|
|
const view3 = await table.view({
|
|
expressions: { "new column": "100 * 100" },
|
|
group_by: ["y"],
|
|
});
|
|
|
|
const result3 = await view3.to_columns();
|
|
expect(result3["new column"]).toEqual([
|
|
40000, 10000, 10000, 10000, 10000,
|
|
]);
|
|
|
|
await view3.delete();
|
|
await view2.delete();
|
|
await view.delete();
|
|
await table.delete();
|
|
});
|
|
|
|
test("Should not be able to overwrite table column with an expression", async function () {
|
|
expect.assertions(1);
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
let emit;
|
|
let emitReject;
|
|
let result = new Promise((success, reject) => {
|
|
emit = success;
|
|
emitReject = reject;
|
|
});
|
|
|
|
table
|
|
.view({
|
|
expressions: { w: "upper('abc')" },
|
|
})
|
|
.catch((e) => {
|
|
expect(e.message.split("\n")[0]).toMatch(
|
|
`Abort(): Value Error - expression \"w\" cannot overwrite an existing column.`,
|
|
);
|
|
table.delete();
|
|
emit();
|
|
})
|
|
.then(() => {
|
|
emitReject("Promise should have thrown an error");
|
|
});
|
|
|
|
await result;
|
|
});
|
|
|
|
test("Should be able to overwrite expression column with one that returns a different type", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { "new column": '"w" + "x"' },
|
|
});
|
|
|
|
let result = await view.to_columns();
|
|
expect(result["new column"]).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
|
|
const view2 = await table.view({
|
|
expressions: { "new column": " upper('abc')" },
|
|
});
|
|
|
|
const result2 = await view2.to_columns();
|
|
expect(result2["new column"]).toEqual(Array(4).fill("ABC"));
|
|
|
|
view2.delete();
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("A new view should not reference expression columns it did not create.", async function () {
|
|
expect.assertions(2);
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result['"w" + "x"']).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
let emit;
|
|
let result2 = new Promise((x) => {
|
|
emit = x;
|
|
});
|
|
table
|
|
.view({
|
|
columns: ['"w" + "x"', "x"],
|
|
})
|
|
.catch((e) => {
|
|
expect(e.message).toMatch(
|
|
`Abort(): Invalid column '"w" + "x"' found in View columns.\n`,
|
|
);
|
|
view.delete();
|
|
table.delete();
|
|
emit();
|
|
});
|
|
|
|
await result2;
|
|
});
|
|
|
|
test("A view should be able to shadow real columns with an expression column", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: {
|
|
'"w"': '"w"',
|
|
'"x"': '"x"',
|
|
'"y"': '"y"',
|
|
'"z"': '"z"',
|
|
},
|
|
});
|
|
expect(await view.expression_schema()).toEqual({
|
|
'"w"': "float",
|
|
'"x"': "integer",
|
|
'"y"': "string",
|
|
'"z"': "boolean",
|
|
});
|
|
expect(await view.to_json()).toEqual([
|
|
{
|
|
w: 1.5,
|
|
x: 1,
|
|
y: "a",
|
|
z: true,
|
|
'"w"': 1.5,
|
|
'"x"': 1,
|
|
'"y"': "a",
|
|
'"z"': true,
|
|
},
|
|
{
|
|
w: 2.5,
|
|
x: 2,
|
|
y: "b",
|
|
z: false,
|
|
'"w"': 2.5,
|
|
'"x"': 2,
|
|
'"y"': "b",
|
|
'"z"': false,
|
|
},
|
|
{
|
|
w: 3.5,
|
|
x: 3,
|
|
y: "c",
|
|
z: true,
|
|
'"w"': 3.5,
|
|
'"x"': 3,
|
|
'"y"': "c",
|
|
'"z"': true,
|
|
},
|
|
{
|
|
w: 4.5,
|
|
x: 4,
|
|
y: "d",
|
|
z: false,
|
|
'"w"': 4.5,
|
|
'"x"': 4,
|
|
'"y"': "d",
|
|
'"z"': false,
|
|
},
|
|
]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to create multiple expression columns in `view()`", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
|
|
const view = await table.view({
|
|
expressions: {
|
|
'"w" + "x"': '"w" + "x"',
|
|
'upper("y")': 'upper("y")',
|
|
},
|
|
});
|
|
|
|
expect(await view.expression_schema()).toEqual({
|
|
'"w" + "x"': "float",
|
|
'upper("y")': "string",
|
|
});
|
|
|
|
const result = await view.to_columns();
|
|
expect(result['"w" + "x"']).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
expect(result['upper("y")']).toEqual(["A", "B", "C", "D"]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to create multiple expression columns with unique names in multiple `view()`s", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: {
|
|
'"w" + "x"': '"w" + "x"',
|
|
'"w" - "x"': '"w" - "x"',
|
|
'"w" * "x"': '"w" * "x"',
|
|
},
|
|
});
|
|
const view2 = await table.view({
|
|
expressions: {
|
|
'"w" / "x"': '"w" / "x"',
|
|
'"x" * "w"': '"x" * "w"',
|
|
},
|
|
});
|
|
|
|
const schema = await view.schema();
|
|
const schema2 = await view2.schema();
|
|
|
|
expect(schema).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" + "x"': "float",
|
|
'"w" - "x"': "float",
|
|
'"w" * "x"': "float",
|
|
});
|
|
|
|
expect(schema2).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" / "x"': "float",
|
|
'"x" * "w"': "float",
|
|
});
|
|
|
|
const result = await view.to_columns();
|
|
const result2 = await view2.to_columns();
|
|
|
|
expect(result).toEqual({
|
|
w: [1.5, 2.5, 3.5, 4.5],
|
|
x: [1, 2, 3, 4],
|
|
y: ["a", "b", "c", "d"],
|
|
z: [true, false, true, false],
|
|
'"w" + "x"': [2.5, 4.5, 6.5, 8.5],
|
|
'"w" - "x"': [0.5, 0.5, 0.5, 0.5],
|
|
'"w" * "x"': [1.5, 5, 10.5, 18],
|
|
});
|
|
|
|
expect(result2).toEqual({
|
|
w: [1.5, 2.5, 3.5, 4.5],
|
|
x: [1, 2, 3, 4],
|
|
y: ["a", "b", "c", "d"],
|
|
z: [true, false, true, false],
|
|
'"w" / "x"': [1.5, 1.25, 1.1666666666666667, 1.125],
|
|
'"x" * "w"': [1.5, 5, 10.5, 18],
|
|
});
|
|
|
|
view2.delete();
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to create multiple expression columns in multiple `view()`s, and arbitarily delete views.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const view2 = await table.view({
|
|
expressions: { '"w" - "x"': '"w" - "x"' },
|
|
});
|
|
|
|
const schema = await view.schema();
|
|
|
|
expect(schema).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" + "x"': "float",
|
|
});
|
|
const result = await view.to_columns();
|
|
|
|
expect(result).toEqual({
|
|
w: [1.5, 2.5, 3.5, 4.5],
|
|
x: [1, 2, 3, 4],
|
|
y: ["a", "b", "c", "d"],
|
|
z: [true, false, true, false],
|
|
'"w" + "x"': [2.5, 4.5, 6.5, 8.5],
|
|
});
|
|
|
|
view.delete();
|
|
|
|
// force a process()
|
|
expect(await table.size()).toEqual(4);
|
|
|
|
const schema2 = await view2.schema();
|
|
|
|
expect(schema2).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" - "x"': "float",
|
|
});
|
|
|
|
const result2 = await view2.to_columns();
|
|
|
|
expect(result2).toEqual({
|
|
w: [1.5, 2.5, 3.5, 4.5],
|
|
x: [1, 2, 3, 4],
|
|
y: ["a", "b", "c", "d"],
|
|
z: [true, false, true, false],
|
|
'"w" - "x"': [0.5, 0.5, 0.5, 0.5],
|
|
});
|
|
|
|
view2.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to create multiple duplicate expression columns in multiple `view()`s, and delete preceding views without affecting later columns.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
|
|
const view2 = await table.view({
|
|
expressions: {
|
|
'"w" + "x"': '"w" + "x"',
|
|
'"w" - "x"': '"w" - "x"',
|
|
},
|
|
});
|
|
|
|
const schema = await view.schema();
|
|
|
|
expect(schema).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" + "x"': "float",
|
|
});
|
|
const result = await view.to_columns();
|
|
|
|
expect(result).toEqual({
|
|
w: [1.5, 2.5, 3.5, 4.5],
|
|
x: [1, 2, 3, 4],
|
|
y: ["a", "b", "c", "d"],
|
|
z: [true, false, true, false],
|
|
'"w" + "x"': [2.5, 4.5, 6.5, 8.5],
|
|
});
|
|
|
|
view.delete();
|
|
|
|
const schema2 = await view2.schema();
|
|
|
|
// force a process()
|
|
expect(await table.size()).toEqual(4);
|
|
|
|
expect(schema2).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" + "x"': "float",
|
|
'"w" - "x"': "float",
|
|
});
|
|
|
|
const result2 = await view2.to_columns();
|
|
|
|
expect(result2).toEqual({
|
|
w: [1.5, 2.5, 3.5, 4.5],
|
|
x: [1, 2, 3, 4],
|
|
y: ["a", "b", "c", "d"],
|
|
z: [true, false, true, false],
|
|
'"w" + "x"': [2.5, 4.5, 6.5, 8.5],
|
|
'"w" - "x"': [0.5, 0.5, 0.5, 0.5],
|
|
});
|
|
|
|
view2.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Multiple views inheriting the same expression columns with the same names should not conflict", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
|
|
const view = await table.view({
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
|
|
expect(await view.schema()).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" + "x"': "float",
|
|
});
|
|
|
|
const view2 = await table.view({
|
|
expressions: {
|
|
'"w" + "x"': '"w" + "x"',
|
|
'"w" - "x"': '"w" - "x"',
|
|
},
|
|
});
|
|
|
|
expect(await view2.schema()).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" + "x"': "float",
|
|
'"w" - "x"': "float",
|
|
});
|
|
|
|
const view3 = await table.view({
|
|
expressions: {
|
|
'"w" + "x"': '"w" + "x"',
|
|
'"w" - "x"': '"w" - "x"',
|
|
'("w" - "x") + "x"': '("w" - "x") + "x"',
|
|
},
|
|
});
|
|
|
|
expect(await view3.schema()).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" + "x"': "float",
|
|
'"w" - "x"': "float",
|
|
'("w" - "x") + "x"': "float",
|
|
});
|
|
|
|
const result = await view3.to_columns();
|
|
expect(result['("w" - "x") + "x"']).toEqual(result["w"]);
|
|
|
|
view3.delete();
|
|
view2.delete();
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("A view should be able to create an expression column with the same name as another deleted view's expression columns.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
|
|
const result = await view.to_columns();
|
|
expect(result['"w" + "x"']).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
view.delete();
|
|
|
|
const view2 = await table.view({
|
|
expressions: { '"w" - "x"': '"w" - "x"' },
|
|
});
|
|
|
|
const result2 = await view2.to_columns();
|
|
expect(result2['"w" - "x"']).toEqual([0.5, 0.5, 0.5, 0.5]);
|
|
|
|
view2.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("A view without expression columns should not serialize expression columns from other views.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
|
|
const result = await view.to_columns();
|
|
expect(result['"w" + "x"']).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
view.delete();
|
|
|
|
const view2 = await table.view();
|
|
|
|
const result2 = await view2.to_json();
|
|
expect(result2).toEqual(expressions_common.int_float_data);
|
|
|
|
view2.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("When expression columns are repeated between views, column indices should grow linearly.", async function () {
|
|
let expressions = [
|
|
'"w" + "x"',
|
|
'"w" - "x"',
|
|
'"w" * "x"',
|
|
'"w" / "x"',
|
|
];
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: [expressions[0]].reduce(
|
|
(x, y) => Object.assign(x, { [y]: y }),
|
|
{},
|
|
),
|
|
});
|
|
const view2 = await table.view({
|
|
expressions: [expressions[0], expressions[1]].reduce(
|
|
(x, y) => Object.assign(x, { [y]: y }),
|
|
{},
|
|
),
|
|
});
|
|
const view3 = await table.view({
|
|
expressions: [
|
|
expressions[0],
|
|
expressions[1],
|
|
expressions[2],
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
const view4 = await table.view({ expressions: expressions });
|
|
|
|
const schema = await view.schema();
|
|
const schema2 = await view2.schema();
|
|
const schema3 = await view3.schema();
|
|
const schema4 = await view4.schema();
|
|
|
|
expect(schema).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" + "x"': "float",
|
|
});
|
|
|
|
expect(schema2).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" + "x"': "float",
|
|
'"w" - "x"': "float",
|
|
});
|
|
|
|
expect(schema3).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" + "x"': "float",
|
|
'"w" - "x"': "float",
|
|
'"w" * "x"': "float",
|
|
});
|
|
|
|
expect(schema4).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" + "x"': "float",
|
|
'"w" - "x"': "float",
|
|
'"w" * "x"': "float",
|
|
'"w" / "x"': "float",
|
|
});
|
|
|
|
view4.delete();
|
|
view3.delete();
|
|
view2.delete();
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to create duplicate expressions in multiple views, and updates should propagate to both", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const view2 = await table.view({
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
|
|
const schema = await view.schema();
|
|
const schema2 = await view2.schema();
|
|
|
|
expect(schema).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" + "x"': "float",
|
|
});
|
|
|
|
expect(schema2).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
'"w" + "x"': "float",
|
|
});
|
|
|
|
const result = await view.to_columns();
|
|
const result2 = await view2.to_columns();
|
|
|
|
expect(result).toEqual({
|
|
w: [1.5, 2.5, 3.5, 4.5],
|
|
x: [1, 2, 3, 4],
|
|
y: ["a", "b", "c", "d"],
|
|
z: [true, false, true, false],
|
|
'"w" + "x"': [2.5, 4.5, 6.5, 8.5],
|
|
});
|
|
|
|
expect(result2).toEqual({
|
|
w: [1.5, 2.5, 3.5, 4.5],
|
|
x: [1, 2, 3, 4],
|
|
y: ["a", "b", "c", "d"],
|
|
z: [true, false, true, false],
|
|
'"w" + "x"': [2.5, 4.5, 6.5, 8.5],
|
|
});
|
|
|
|
await table.update({
|
|
w: [5, 6, 7, 8],
|
|
x: [1, 2, 3, 4],
|
|
});
|
|
|
|
expect(await view.to_columns()).toEqual({
|
|
w: [1.5, 2.5, 3.5, 4.5, 5, 6, 7, 8],
|
|
x: [1, 2, 3, 4, 1, 2, 3, 4],
|
|
y: ["a", "b", "c", "d", null, null, null, null],
|
|
z: [true, false, true, false, null, null, null, null],
|
|
'"w" + "x"': [2.5, 4.5, 6.5, 8.5, 6, 8, 10, 12],
|
|
});
|
|
|
|
expect(await view2.to_columns()).toEqual({
|
|
w: [1.5, 2.5, 3.5, 4.5, 5, 6, 7, 8],
|
|
x: [1, 2, 3, 4, 1, 2, 3, 4],
|
|
y: ["a", "b", "c", "d", null, null, null, null],
|
|
z: [true, false, true, false, null, null, null, null],
|
|
'"w" + "x"': [2.5, 4.5, 6.5, 8.5, 6, 8, 10, 12],
|
|
});
|
|
|
|
view2.delete();
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("A new view should not inherit expression columns if not created.", async function () {
|
|
expect.assertions(2);
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result['"w" + "x"']).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
|
|
try {
|
|
await table.view({
|
|
columns: ['"w" + "x"', "x"],
|
|
});
|
|
} catch (e) {
|
|
expect(e.message.split("\n")[0]).toEqual(
|
|
`Abort(): Invalid column '"w" + "x"' found in View columns.`,
|
|
);
|
|
}
|
|
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("The view's underlying table should not have a mutated schema.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result['"w" + "x"']).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
expect(await table.schema()).toEqual({
|
|
w: "float",
|
|
x: "integer",
|
|
y: "string",
|
|
z: "boolean",
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to show an expression column.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
columns: ['"w" + "x"'],
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result['"w" + "x"']).toEqual([2.5, 4.5, 6.5, 8.5]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to hide an expression column.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
columns: ["x"],
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
expect(await view.schema()).toEqual({
|
|
x: "integer",
|
|
});
|
|
expect(await view.expression_schema()).toEqual({
|
|
'"w" + "x"': "float",
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result['"w" + "x"']).toEqual(undefined);
|
|
expect(result["x"]).toEqual([1, 2, 3, 4]);
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to group by on a non-expression column and get correct results for the expression column.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
group_by: ["w"],
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
__ROW_PATH__: [[], [1.5], [2.5], [3.5], [4.5]],
|
|
'"w" + "x"': [22, 2.5, 4.5, 6.5, 8.5],
|
|
w: [12, 1.5, 2.5, 3.5, 4.5],
|
|
x: [10, 1, 2, 3, 4],
|
|
y: [4, 1, 1, 1, 1],
|
|
z: [4, 1, 1, 1, 1],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to group by on an expression column.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
group_by: ['"w" + "x"'],
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
__ROW_PATH__: [[], [2.5], [4.5], [6.5], [8.5]],
|
|
'"w" + "x"': [22, 2.5, 4.5, 6.5, 8.5],
|
|
w: [12, 1.5, 2.5, 3.5, 4.5],
|
|
x: [10, 1, 2, 3, 4],
|
|
y: [4, 1, 1, 1, 1],
|
|
z: [4, 1, 1, 1, 1],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Row-pivoted expression columns return correct column_paths()", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
|
|
// default order
|
|
let view = await table.view({
|
|
group_by: ["y"],
|
|
expressions: { column: '"w" + "x"' },
|
|
});
|
|
|
|
let paths = await view.column_paths();
|
|
expect(paths).toEqual(["w", "x", "y", "z", "column"]);
|
|
|
|
await view.delete();
|
|
|
|
const expected_paths = [
|
|
["x", "column"],
|
|
["column"],
|
|
["x", "column", "y"],
|
|
];
|
|
|
|
for (const expected of expected_paths) {
|
|
const output = expected.slice();
|
|
view = await table.view({
|
|
group_by: ["y"],
|
|
expressions: { column: '"w" + "x"' },
|
|
columns: expected,
|
|
});
|
|
paths = await view.column_paths();
|
|
expect(paths).toEqual(output);
|
|
view.delete();
|
|
}
|
|
|
|
for (const expected of expected_paths) {
|
|
const output = expected.slice();
|
|
view = await table.view({
|
|
group_by: ["column"],
|
|
expressions: { column: '"w" + "x"' },
|
|
columns: expected,
|
|
});
|
|
paths = await view.column_paths();
|
|
expect(paths).toEqual(output);
|
|
view.delete();
|
|
}
|
|
|
|
table.delete();
|
|
});
|
|
|
|
test("Row-pivoted numeric expression columns return correct column_paths()", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const config = {
|
|
group_by: ["y"],
|
|
expressions: { 1234: "1234" },
|
|
aggregates: {
|
|
x: "sum",
|
|
y: "count",
|
|
1234: "sum",
|
|
},
|
|
};
|
|
// default order
|
|
let view = await table.view(config);
|
|
|
|
let paths = await view.column_paths();
|
|
expect(paths).toEqual(["w", "x", "y", "z", "1234"]);
|
|
|
|
await view.delete();
|
|
|
|
const expected_paths = [
|
|
["x", "1234"],
|
|
["1234"],
|
|
["x", "1234", "y"],
|
|
];
|
|
|
|
for (const expected of expected_paths) {
|
|
const output = expected.slice();
|
|
view = await table.view({
|
|
...config,
|
|
columns: expected,
|
|
});
|
|
paths = await view.column_paths();
|
|
expect(paths).toEqual(output);
|
|
view.delete();
|
|
}
|
|
|
|
for (const expected of expected_paths) {
|
|
const output = expected.slice();
|
|
view = await table.view({
|
|
...config,
|
|
columns: expected,
|
|
});
|
|
paths = await view.column_paths();
|
|
expect(paths).toEqual(output);
|
|
view.delete();
|
|
}
|
|
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to split by on an expression column.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
split_by: ['"w" + "x"'],
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
"2.5|w": [1.5, null, null, null],
|
|
"2.5|x": [1, null, null, null],
|
|
"2.5|y": ["a", null, null, null],
|
|
"2.5|z": [true, null, null, null],
|
|
'2.5|"w" + "x"': [2.5, null, null, null],
|
|
"4.5|w": [null, 2.5, null, null],
|
|
"4.5|x": [null, 2, null, null],
|
|
"4.5|y": [null, "b", null, null],
|
|
"4.5|z": [null, false, null, null],
|
|
'4.5|"w" + "x"': [null, 4.5, null, null],
|
|
"6.5|w": [null, null, 3.5, null],
|
|
"6.5|x": [null, null, 3, null],
|
|
"6.5|y": [null, null, "c", null],
|
|
"6.5|z": [null, null, true, null],
|
|
'6.5|"w" + "x"': [null, null, 6.5, null],
|
|
"8.5|w": [null, null, null, 4.5],
|
|
"8.5|x": [null, null, null, 4],
|
|
"8.5|y": [null, null, null, "d"],
|
|
"8.5|z": [null, null, null, false],
|
|
'8.5|"w" + "x"': [null, null, null, 8.5],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to row + split by on an expression column.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
group_by: ['"w" + "x"'],
|
|
split_by: ['"w" + "x"'],
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
__ROW_PATH__: [[], [2.5], [4.5], [6.5], [8.5]],
|
|
"2.5|w": [1.5, 1.5, null, null, null],
|
|
"2.5|x": [1, 1, null, null, null],
|
|
"2.5|y": [1, 1, null, null, null],
|
|
"2.5|z": [1, 1, null, null, null],
|
|
'2.5|"w" + "x"': [2.5, 2.5, null, null, null],
|
|
"4.5|w": [2.5, null, 2.5, null, null],
|
|
"4.5|x": [2, null, 2, null, null],
|
|
"4.5|y": [1, null, 1, null, null],
|
|
"4.5|z": [1, null, 1, null, null],
|
|
'4.5|"w" + "x"': [4.5, null, 4.5, null, null],
|
|
"6.5|w": [3.5, null, null, 3.5, null],
|
|
"6.5|x": [3, null, null, 3, null],
|
|
"6.5|y": [1, null, null, 1, null],
|
|
"6.5|z": [1, null, null, 1, null],
|
|
'6.5|"w" + "x"': [6.5, null, null, 6.5, null],
|
|
"8.5|w": [4.5, null, null, null, 4.5],
|
|
"8.5|x": [4, null, null, null, 4],
|
|
"8.5|y": [1, null, null, null, 1],
|
|
"8.5|z": [1, null, null, null, 1],
|
|
'8.5|"w" + "x"': [8.5, null, null, null, 8.5],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to aggregate a numeric expression column.", async function () {
|
|
const table = await perspective.table({
|
|
x: [1, 2, 3, 4],
|
|
y: [100, 200, 300, 400],
|
|
z: [1.5, 2.5, 3.5, 4.5],
|
|
});
|
|
const view = await table.view({
|
|
group_by: ['"x" + "z"'],
|
|
aggregates: {
|
|
'"x" + "z"': "median",
|
|
x: "median",
|
|
},
|
|
expressions: { '"x" + "z"': '"x" + "z"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
__ROW_PATH__: [[], [2.5], [4.5], [6.5], [8.5]],
|
|
'"x" + "z"': [5.5, 2.5, 4.5, 6.5, 8.5],
|
|
x: [3, 1, 2, 3, 4],
|
|
y: [1000, 100, 200, 300, 400],
|
|
z: [12, 1.5, 2.5, 3.5, 4.5],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to weighted mean aggregate a numeric expression column.", async function () {
|
|
const table = await perspective.table({
|
|
x: [2, 2, 4, 4],
|
|
y: [100, 200, 300, 400],
|
|
z: [1.5, 2.5, 3.5, 4.5],
|
|
});
|
|
const view = await table.view({
|
|
group_by: ["y"],
|
|
columns: ['"x" + "z"'],
|
|
aggregates: {
|
|
'"x" + "z"': ["weighted mean", ["y"]],
|
|
},
|
|
expressions: { '"x" + "z"': '"x" + "z"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
__ROW_PATH__: [[], [100], [200], [300], [400]],
|
|
'"x" + "z"': [6.9, 3.5, 4.5, 7.5, 8.5],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to aggregate a numeric expression column that aliases a real column.", async function () {
|
|
const table = await perspective.table({
|
|
x: [1, 2, 3, 4],
|
|
y: [100, 200, 300, 400],
|
|
z: [1.5, 2.5, 3.5, 4.5],
|
|
});
|
|
const view = await table.view({
|
|
group_by: ['"x"'],
|
|
aggregates: {
|
|
'"x"': "median",
|
|
x: "median",
|
|
},
|
|
expressions: { '"x"': '"x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
__ROW_PATH__: [[], [1], [2], [3], [4]],
|
|
'"x"': [3, 1, 2, 3, 4],
|
|
x: [3, 1, 2, 3, 4],
|
|
y: [1000, 100, 200, 300, 400],
|
|
z: [12, 1.5, 2.5, 3.5, 4.5],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to aggregate a string expression column.", async function () {
|
|
const table = await perspective.table({
|
|
x: ["a", "a", "c", "a"],
|
|
y: ["w", "w", "y", "w"],
|
|
});
|
|
const view = await table.view({
|
|
group_by: ['upper("x")'],
|
|
aggregates: {
|
|
'upper("x")': "distinct count",
|
|
},
|
|
expressions: { 'upper("x")': 'upper("x")' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
__ROW_PATH__: [[], ["A"], ["C"]],
|
|
'upper("x")': [2, 1, 1],
|
|
x: [4, 3, 1],
|
|
y: [4, 3, 1],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to aggregate a date expression column.", async function () {
|
|
const table = await perspective.table({
|
|
x: [
|
|
new Date(2019, 0, 15),
|
|
new Date(2019, 0, 30),
|
|
new Date(2019, 1, 15),
|
|
],
|
|
});
|
|
const view = await table.view({
|
|
group_by: [`bucket("x", 'M')`],
|
|
aggregates: {
|
|
"bucket(\"x\", 'M')": "distinct count",
|
|
},
|
|
expressions: { "bucket(\"x\", 'M')": "bucket(\"x\", 'M')" },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
__ROW_PATH__: [[], [1546300800000], [1548979200000]],
|
|
"bucket(\"x\", 'M')": [2, 1, 1],
|
|
x: [3, 2, 1],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to weighted mean on an expression column.", async function () {
|
|
const table = await perspective.table({
|
|
x: [1, 2, 3, 4],
|
|
y: [100, 200, 300, 400],
|
|
z: [1.5, 2.5, 3.5, 4.5],
|
|
});
|
|
const view = await table.view({
|
|
group_by: ['"x" + "z"'],
|
|
aggregates: {
|
|
x: ["weighted mean", ['"x" + "z"']],
|
|
'"x" + "z"': ["weighted mean", ["y"]],
|
|
},
|
|
expressions: { '"x" + "z"': '"x" + "z"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
__ROW_PATH__: [[], [2.5], [4.5], [6.5], [8.5]],
|
|
'"x" + "z"': [6.5, 2.5, 4.5, 6.5, 8.5],
|
|
x: [2.9545454545454546, 1, 2, 3, 4],
|
|
y: [1000, 100, 200, 300, 400],
|
|
z: [12, 1.5, 2.5, 3.5, 4.5],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to filter on an expression column.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
filter: [['"w" + "x"', ">", 6.5]],
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
'"w" + "x"': [8.5],
|
|
w: [4.5],
|
|
x: [4],
|
|
y: ["d"],
|
|
z: [false],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to sort on an expression column.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
sort: [['"w" + "x"', "desc"]],
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
'"w" + "x"': [8.5, 6.5, 4.5, 2.5],
|
|
w: [4.5, 3.5, 2.5, 1.5],
|
|
x: [4, 3, 2, 1],
|
|
y: ["d", "c", "b", "a"],
|
|
z: [false, true, false, true],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should be able to sort on a hidden expression column.", async function () {
|
|
const table = await perspective.table(
|
|
expressions_common.int_float_data,
|
|
);
|
|
const view = await table.view({
|
|
columns: ["w"],
|
|
sort: [['"w" + "x"', "desc"]],
|
|
expressions: { '"w" + "x"': '"w" + "x"' },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
w: [4.5, 3.5, 2.5, 1.5],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test.describe("Validation using table expression schema", function () {
|
|
test("Should show correct expression column types in table expression schema.", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
});
|
|
const expressions = [
|
|
'"a" ^ 2',
|
|
"sqrt(144)",
|
|
"0 and 1",
|
|
"0 or 1",
|
|
'-"a"',
|
|
'upper("c")',
|
|
`bucket("b", 'M')`,
|
|
`bucket("b", 's')`,
|
|
];
|
|
const results = await table.validate_expressions(expressions);
|
|
expect(results.expression_schema).toEqual({
|
|
'"a" ^ 2': "float",
|
|
"sqrt(144)": "float",
|
|
'-"a"': "integer",
|
|
"0 and 1": "boolean",
|
|
"0 or 1": "boolean",
|
|
'upper("c")': "string",
|
|
"bucket(\"b\", 'M')": "date",
|
|
"bucket(\"b\", 's')": "datetime",
|
|
});
|
|
table.delete();
|
|
});
|
|
|
|
test("Should skip expressions that try to overwrite table columns", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
d: [1.5, 2.5, 3.5, 4.5],
|
|
});
|
|
const expressions = {
|
|
abc: " 123 + 345", //valid
|
|
a: " sqrt(144)", // invalid
|
|
b: " upper('abc')", // invalid
|
|
c: " concat('a', 'b')", // invalid
|
|
d: " today()", // invalid
|
|
};
|
|
const results = await table.validate_expressions(expressions);
|
|
expect(results.expression_schema).toEqual({
|
|
abc: "float",
|
|
});
|
|
table.delete();
|
|
});
|
|
|
|
test("Should not skip expressions that try to overwrite expressions with different types", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
d: [1.5, 2.5, 3.5, 4.5],
|
|
});
|
|
|
|
const view = await table.view({
|
|
expressions: {
|
|
abc: " 123 + 345",
|
|
def: " lower('ABC')",
|
|
},
|
|
});
|
|
|
|
const results = await table.validate_expressions({
|
|
abc: " upper('abc')",
|
|
def: " 1 + 2",
|
|
});
|
|
expect(results.expression_schema).toEqual({
|
|
abc: "string",
|
|
def: "float",
|
|
});
|
|
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should skip invalid columns due to type error, with alias", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
d: [1.5, 2.5, 3.5, 4.5],
|
|
});
|
|
const expressions = {
|
|
abc: '"a" + "d"', // valid
|
|
def: '"c" + "b"', // invalid
|
|
'"c"': '"c"', // valid
|
|
"new column": "bucket(\"b\", 'M')", // valid
|
|
"bucket(\"b\", 'abcde')": "bucket(\"b\", 'abcde')", // invalid
|
|
'concat("c", "a")': 'concat("c", "a")', // invalid
|
|
"more columns": "concat(\"c\", ' ', \"c\", 'abc')", // valid
|
|
'upper("c")': 'upper("c")', // valid
|
|
'lower("a")': 'lower("a")', // invalid,
|
|
'min("a", "c")': 'min("a", "c")', // invalid,
|
|
'max(100, "a")': 'max(100, "a")', // valid
|
|
};
|
|
const results = await table.validate_expressions(expressions);
|
|
expect(results.expression_schema).toEqual({
|
|
abc: "float",
|
|
'"c"': "string",
|
|
"new column": "date",
|
|
'upper("c")': "string",
|
|
'max(100, "a")': "float",
|
|
"more columns": "string",
|
|
});
|
|
|
|
for (const alias of Object.keys(expressions)) {
|
|
expect(results.expression_alias[alias]).toEqual(
|
|
expressions[alias],
|
|
);
|
|
}
|
|
table.delete();
|
|
});
|
|
|
|
test("Should skip invalid columns due to type error", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
d: [1.5, 2.5, 3.5, 4.5],
|
|
});
|
|
const expressions = [
|
|
'"a" + "d"', // valid
|
|
'"c" + "b"', // invalid
|
|
'"c"', // valid
|
|
"bucket(\"b\", 'M')", // valid
|
|
"bucket(\"b\", 'abcde')", // invalid
|
|
'concat("c", "a")', // invalid
|
|
"concat(\"c\", ' ', \"c\", 'abc')", // valid
|
|
'upper("c")', // valid
|
|
'lower("a")', // invalid,
|
|
'min("a", "c")', // invalid,
|
|
'max(100, "a")', // valid
|
|
];
|
|
const results = await table.validate_expressions(expressions);
|
|
|
|
expect(results.expression_schema).toEqual({
|
|
'"a" + "d"': "float",
|
|
'"c"': "string",
|
|
"bucket(\"b\", 'M')": "date",
|
|
'upper("c")': "string",
|
|
'max(100, "a")': "float",
|
|
"concat(\"c\", ' ', \"c\", 'abc')": "string",
|
|
});
|
|
|
|
for (const expr of expressions) {
|
|
expect(results.expression_alias[expr]).toEqual(expr);
|
|
}
|
|
|
|
table.delete();
|
|
});
|
|
|
|
test("Should skip a invalid column due to invalid column name", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
d: [1.5, 2.5, 3.5, 4.5],
|
|
});
|
|
const expressions = [
|
|
'"a" + "d"', // valid
|
|
'"abxbasd" + "sdfadsf"', // invalid
|
|
'"c"', // valid
|
|
"bucket(\"b\", 'M')", // valid
|
|
"bucket(\"basdsa\", 'Y')", // invalid
|
|
'upper("c")', // valid
|
|
'lower("sdfadsj")', // invalid
|
|
];
|
|
const results = await table.validate_expressions(expressions);
|
|
expect(results.expression_schema).toEqual({
|
|
'"a" + "d"': "float",
|
|
'"c"': "string",
|
|
"bucket(\"b\", 'M')": "date",
|
|
'upper("c")': "string",
|
|
});
|
|
|
|
for (const expr of expressions) {
|
|
expect(results.expression_alias[expr]).toEqual(expr);
|
|
}
|
|
|
|
table.delete();
|
|
});
|
|
|
|
test("Should skip a invalid column due to parse error", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
d: [1.5, 2.5, 3.5, 4.5],
|
|
});
|
|
const expressions = [
|
|
'"a" + "d"', // valid
|
|
"{", // invalid
|
|
"if (\"c\" == 'a') 123; else 0;", // valid
|
|
"if (", // invalid
|
|
];
|
|
const results = await table.validate_expressions(expressions);
|
|
expect(results.expression_schema).toEqual({
|
|
'"a" + "d"': "float",
|
|
"if (\"c\" == 'a') 123; else 0;": "float",
|
|
});
|
|
table.delete();
|
|
});
|
|
});
|
|
|
|
test.describe("View expression schema", function () {
|
|
test("Column types in view schema on 0-sided view.", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
});
|
|
const view = await table.view({
|
|
expressions: [
|
|
'"a" ^ 2',
|
|
"sqrt(144)",
|
|
"0 and 1",
|
|
"0 or 1",
|
|
'-"a"',
|
|
'upper("c")',
|
|
`bucket("b", 'M')`,
|
|
`bucket("b", 's')`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
const schema = await view.schema();
|
|
expect(schema).toEqual({
|
|
a: "integer",
|
|
b: "datetime",
|
|
c: "string",
|
|
'"a" ^ 2': "float",
|
|
"sqrt(144)": "float",
|
|
'-"a"': "integer",
|
|
"0 and 1": "boolean",
|
|
"0 or 1": "boolean",
|
|
'upper("c")': "string",
|
|
"bucket(\"b\", 'M')": "date",
|
|
"bucket(\"b\", 's')": "datetime",
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Column types in view expression schema on 0-sided view.", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
});
|
|
const view = await table.view({
|
|
expressions: [
|
|
'"a" ^ 2',
|
|
"sqrt(144)",
|
|
"0 and 1",
|
|
"0 or 1",
|
|
'-"a"',
|
|
'upper("c")',
|
|
`bucket("b", 'M')`,
|
|
`bucket("b", 's')`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
const schema = await view.expression_schema();
|
|
expect(schema).toEqual({
|
|
'"a" ^ 2': "float",
|
|
"sqrt(144)": "float",
|
|
'-"a"': "integer",
|
|
"0 and 1": "boolean",
|
|
"0 or 1": "boolean",
|
|
'upper("c")': "string",
|
|
"bucket(\"b\", 'M')": "date",
|
|
"bucket(\"b\", 's')": "datetime",
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Should show ALL columns in view expression schema regardless of custom columns.", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
});
|
|
const view = await table.view({
|
|
columns: ["a"],
|
|
expressions: [
|
|
'"a" ^ 2',
|
|
"sqrt(144)",
|
|
"0 and 1",
|
|
"0 or 1",
|
|
'-"a"',
|
|
'upper("c")',
|
|
`bucket("b", 'M')`,
|
|
`bucket("b", 's')`,
|
|
`bucket("b",'M')`,
|
|
`bucket("b",'s')`,
|
|
`bucket("b", 'M')`,
|
|
`bucket("b", 's')`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
const schema = await view.expression_schema();
|
|
expect(schema).toEqual({
|
|
'"a" ^ 2': "float",
|
|
"sqrt(144)": "float",
|
|
'-"a"': "integer",
|
|
"0 and 1": "boolean",
|
|
"0 or 1": "boolean",
|
|
'upper("c")': "string",
|
|
"bucket(\"b\", 'M')": "date",
|
|
"bucket(\"b\", 's')": "datetime",
|
|
"bucket(\"b\",'M')": "date",
|
|
"bucket(\"b\",'s')": "datetime",
|
|
"bucket(\"b\", 'M')": "date",
|
|
"bucket(\"b\", 's')": "datetime",
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Aggregated types in view expression schema on 1-sided view.", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
});
|
|
const view = await table.view({
|
|
group_by: ["c"],
|
|
expressions: [
|
|
'"a" ^ 2',
|
|
"sqrt(144)",
|
|
"0 and 1",
|
|
"0 or 1",
|
|
'-"a"',
|
|
'upper("c")',
|
|
`bucket("b", 'M')`,
|
|
`bucket("b", 's')`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
const schema = await view.expression_schema();
|
|
expect(schema).toEqual({
|
|
'"a" ^ 2': "float",
|
|
"sqrt(144)": "float",
|
|
'-"a"': "integer",
|
|
"0 and 1": "integer",
|
|
"0 or 1": "integer",
|
|
'upper("c")': "integer",
|
|
"bucket(\"b\", 'M')": "integer",
|
|
"bucket(\"b\", 's')": "integer",
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Aggregated types in view expression schema on 1-sided view with custom aggregates.", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
});
|
|
const view = await table.view({
|
|
group_by: ["c"],
|
|
aggregates: {
|
|
"0 and 1": "any",
|
|
"0 or 1": "any",
|
|
"bucket(\"b\", 's')": "last",
|
|
},
|
|
expressions: [
|
|
'"a" ^ 2',
|
|
"sqrt(144)",
|
|
"0 and 1",
|
|
"0 or 1",
|
|
'-"a"',
|
|
'upper("c")',
|
|
`bucket("b", 'M')`,
|
|
`bucket("b", 's')`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
const schema = await view.expression_schema();
|
|
expect(schema).toEqual({
|
|
'"a" ^ 2': "float",
|
|
"sqrt(144)": "float",
|
|
'-"a"': "integer",
|
|
"0 and 1": "boolean",
|
|
"0 or 1": "boolean",
|
|
'upper("c")': "integer",
|
|
"bucket(\"b\", 'M')": "integer",
|
|
"bucket(\"b\", 's')": "datetime",
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Aggregated types in view expression schema on 2-sided view.", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
});
|
|
const view = await table.view({
|
|
group_by: ["c"],
|
|
split_by: ["a"],
|
|
expressions: [
|
|
'"a" ^ 2',
|
|
"sqrt(144)",
|
|
"0 and 1",
|
|
"0 or 1",
|
|
'-"a"',
|
|
'upper("c")',
|
|
`bucket("b", 'M')`,
|
|
`bucket("b", 's')`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
const schema = await view.expression_schema();
|
|
expect(schema).toEqual({
|
|
'"a" ^ 2': "float",
|
|
"sqrt(144)": "float",
|
|
'-"a"': "integer",
|
|
"0 and 1": "integer", // aggregated bool = count
|
|
"0 or 1": "integer",
|
|
'upper("c")': "integer",
|
|
"bucket(\"b\", 'M')": "integer",
|
|
"bucket(\"b\", 's')": "integer",
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Aggregated types in view expression schema on 2-sided column-only view.", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [new Date(), new Date(), new Date(), new Date()],
|
|
c: ["a", "b", "c", "d"],
|
|
});
|
|
const view = await table.view({
|
|
group_by: ["c"],
|
|
split_by: ["a"],
|
|
aggregates: {
|
|
"0 and 1": "any",
|
|
"0 or 1": "any",
|
|
"bucket(\"b\", 's')": "last",
|
|
},
|
|
expressions: [
|
|
'"a" ^ 2',
|
|
"sqrt(144)",
|
|
"0 and 1",
|
|
"0 or 1",
|
|
'-"a"',
|
|
'upper("c")',
|
|
`bucket("b", 'M')`,
|
|
`bucket("b", 's')`,
|
|
].reduce((x, y) => Object.assign(x, { [y]: y }), {}),
|
|
});
|
|
const schema = await view.expression_schema();
|
|
expect(schema).toEqual({
|
|
'"a" ^ 2': "float",
|
|
"sqrt(144)": "float",
|
|
'-"a"': "integer",
|
|
"0 and 1": "boolean",
|
|
"0 or 1": "boolean",
|
|
'upper("c")': "integer",
|
|
"bucket(\"b\", 'M')": "integer",
|
|
"bucket(\"b\", 's')": "datetime",
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Vlookup should access the correct row", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: ["a", "b", "c", "d"],
|
|
});
|
|
const expr = "vlookup('b', integer(0))";
|
|
const view = await table.view({
|
|
expressions: [expr].reduce(
|
|
(x, y) => Object.assign(x, { [y]: y }),
|
|
{},
|
|
),
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
a: [1, 2, 3, 4],
|
|
b: ["a", "b", "c", "d"],
|
|
[expr]: ["a", "a", "a", "a"],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Col should behave the same as direct column access", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: ["a", "b", "c", "d"],
|
|
});
|
|
const view = await table.view({
|
|
expressions: { "col('b')": "col('b')" },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
a: [1, 2, 3, 4],
|
|
b: ["a", "b", "c", "d"],
|
|
"col('b')": ["a", "b", "c", "d"],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("index() should return the correct row number", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
});
|
|
const view = await table.view({
|
|
expressions: { "index()": "index()" },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
a: [1, 2, 3, 4],
|
|
"index()": [0, 1, 2, 3],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("index() should work with custom a index", async function () {
|
|
const table = await perspective.table(
|
|
{
|
|
a: [1, 2, 3, 4],
|
|
},
|
|
{ index: "a" },
|
|
);
|
|
const view = await table.view({
|
|
expressions: { "index()": "index()" },
|
|
});
|
|
const result = await view.to_columns();
|
|
expect(result).toEqual({
|
|
a: [1, 2, 3, 4],
|
|
"index()": [1, 2, 3, 4],
|
|
});
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("index() should work with an update", async function () {
|
|
const table = await perspective.table(
|
|
{
|
|
a: [1, 2, 3, 4],
|
|
},
|
|
{ index: "a" },
|
|
);
|
|
|
|
const view = await table.view({
|
|
expressions: { "index()": "index()" },
|
|
});
|
|
|
|
let sentinel = false;
|
|
view.on_update(() => {
|
|
sentinel = true;
|
|
});
|
|
|
|
await table.update({ a: [5, 6] });
|
|
const result = await view.to_columns();
|
|
|
|
expect(sentinel).toBeTruthy();
|
|
expect(result).toEqual({
|
|
a: [1, 2, 3, 4, 5, 6],
|
|
"index()": [1, 2, 3, 4, 5, 6],
|
|
});
|
|
|
|
view.delete();
|
|
table.delete();
|
|
});
|
|
|
|
test("Validation works with both input formats", async function () {
|
|
const table = await perspective.table({
|
|
a: [1, 2, 3, 4],
|
|
b: [1, 2, 3, 4],
|
|
});
|
|
|
|
const str_exprs = {
|
|
x: '"a"',
|
|
y: '"b" * 0.5',
|
|
c: "'abcdefg'",
|
|
d: "true and false",
|
|
e: 'float("a") > 2 ? null : 1',
|
|
f: "today()",
|
|
g: "now()",
|
|
h: "length(123)",
|
|
};
|
|
|
|
const dict_exprs = {
|
|
x: '"a"',
|
|
y: '"b" * 0.5',
|
|
c: "'abcdefg'",
|
|
d: "true and false",
|
|
e: 'float("a") > 2 ? null : 1',
|
|
f: "today()",
|
|
g: "now()",
|
|
h: "length(123)",
|
|
};
|
|
|
|
let vstrs = await table.validate_expressions(str_exprs);
|
|
let vdicts = await table.validate_expressions(dict_exprs);
|
|
expect(vstrs.errors).toEqual(vdicts.errors);
|
|
expect(vstrs.expression_schema).toEqual(
|
|
vdicts.expression_schema,
|
|
);
|
|
|
|
for (let [key, val] of Object.entries(vstrs.expression_alias)) {
|
|
let dict_val = vdicts.expression_alias[key];
|
|
// let parsed_val = `${dict_val}`;
|
|
expect(val).toEqual(dict_val);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
})(perspective);
|