@finos/legend-cube-builder 0.0.2 → 0.0.4

package/src/stores/fixtures/CubeTradesModel.ts

@@ -0,0 +1,241 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { ModelContext } from '@finos/legend-cube';
+import {
+  addSampleDays,
+  createSampleRandom,
+  pickSample,
+  sampleInsert,
+  type SampleSqlValue,
+  toPureSetupSqls,
+} from './CubeSampleSql.js';
+
+// The trades sample: made-up trades of the first half of 2026 by six desks in
+// made-up instruments, in an in-memory H2 database the engine fills from the
+// model's setup SQL
+
+export const CUBE_TRADES_DATABASE = 'cube::samples::trades::TradesDatabase';
+export const CUBE_TRADES_CONNECTION = 'cube::samples::trades::TradesConnection';
+export const CUBE_TRADES_RUNTIME = 'cube::samples::trades::TradesRuntime';
+export const CUBE_TRADES_SCHEMA = 'TRADES_SAMPLE';
+export const CUBE_TRADES_TRADE_COUNT = 400;
+
+/** Each desk, its region, and the asset classes it trades */
+const DESKS: readonly (readonly [string, string, readonly string[]])[] = [
+  ['Equities Cash', 'Americas', ['Equity']],
+  ['Equity Derivatives', 'Europe', ['Equity', 'Commodity']],
+  ['Rates', 'Americas', ['Bond', 'FX']],
+  ['Credit', 'Europe', ['Bond']],
+  ['FX', 'Asia', ['FX']],
+  ['Commodities', 'Americas', ['Commodity', 'FX']],
+];
+
+/** Each instrument: symbol, name, asset class, currency and a typical price */
+const INSTRUMENTS: readonly (readonly [
+  string,
+  string,
+  string,
+  string,
+  number,
+])[] = [
+  ['ACME', 'Acme Industries', 'Equity', 'USD', 182.5],
+  ['GLBX', 'Globex Corp', 'Equity', 'USD', 64.2],
+  ['INIT', 'Initech', 'Equity', 'USD', 23.75],
+  ['UMBR', 'Umbrella Holdings', 'Equity', 'EUR', 96.4],
+  ['STRK', 'Stark Works', 'Equity', 'EUR', 310.1],
+  ['UST10', 'Treasury 10Y', 'Bond', 'USD', 98.6],
+  ['UST2', 'Treasury 2Y', 'Bond', 'USD', 99.8],
+  ['BUND10', 'Bund 10Y', 'Bond', 'EUR', 101.3],
+  ['ACME28', 'Acme 4.5% 2028', 'Bond', 'USD', 97.2],
+  ['EURUSD', 'Euro / Dollar', 'FX', 'USD', 1.0875],
+  ['USDJPY', 'Dollar / Yen', 'FX', 'JPY', 148.35],
+  ['GBPUSD', 'Pound / Dollar', 'FX', 'USD', 1.265],
+  ['GOLD', 'Gold', 'Commodity', 'USD', 2350.0],
+  ['BRENT', 'Brent Crude', 'Commodity', 'USD', 82.4],
+  ['COPPER', 'Copper', 'Commodity', 'USD', 4.15],
+];
+
+/** What a unit of each currency is worth in dollars, fixed for the sample */
+export const CUBE_TRADES_USD_RATES: ReadonlyMap<string, number> = new Map([
+  ['USD', 1],
+  ['EUR', 1.08],
+  ['JPY', 0.0067],
+]);
+
+/** How many units a trade of an asset class is for, at most */
+const MAX_QUANTITY = new Map([
+  ['Equity', 5_000],
+  ['Bond', 2_000],
+  ['FX', 1_000_000],
+  ['Commodity', 1_000],
+]);
+
+/** A whole number of ten-thousandths as a decimal text, e.g. 12345 is 1.2345 */
+const fromTenThousandths = (value: number, scale: number): string => {
+  const text = String(value).padStart(5, '0');
+  const whole = text.slice(0, -4);
+  const fraction = text.slice(-4).slice(0, scale);
+  return scale === 0 ? whole : `${whole}.${fraction}`;
+};
+
+const createTrades = (): SampleSqlValue[][] => {
+  const random = createSampleRandom(20260102);
+  const trades: SampleSqlValue[][] = [];
+  for (let id = 1; id <= CUBE_TRADES_TRADE_COUNT; id++) {
+    const deskIndex = Math.floor(random() * DESKS.length);
+    const [, , assetClasses] = pickSample(DESKS, deskIndex / DESKS.length);
+    const assetClass = pickSample(assetClasses, random());
+    const choices = INSTRUMENTS.flatMap((instrument, index) =>
+      instrument[2] === assetClass ? [index] : [],
+    );
+    const instrumentIndex = pickSample(choices, random());
+    const [, , , currency, price] = pickSample(
+      INSTRUMENTS,
+      instrumentIndex / INSTRUMENTS.length,
+    );
+    const quantity = Math.max(
+      1,
+      Math.round(random() * (MAX_QUANTITY.get(assetClass) ?? 1_000)),
+    );
+    // prices move up to 5% either way, kept to four decimals
+    const priceInTenThousandths = Math.round(
+      price * (0.95 + random() * 0.1) * 10_000,
+    );
+    // the notional in dollars, at a fixed rate, kept to cents
+    const notionalInTenThousandths =
+      Math.round(
+        (quantity *
+          priceInTenThousandths *
+          (CUBE_TRADES_USD_RATES.get(currency) ?? 1)) /
+          100,
+      ) * 100;
+    // trading days: Monday to Friday
+    let day = Math.floor(random() * 181);
+    while ([0, 6].includes(new Date(Date.UTC(2026, 0, 1 + day)).getUTCDay())) {
+      day = (day + 1) % 181;
+    }
+    trades.push([
+      id,
+      { date: addSampleDays('2026-01-01', day) },
+      deskIndex + 1,
+      instrumentIndex + 1,
+      random() < 0.5 ? 'BUY' : 'SELL',
+      quantity,
+      { decimal: fromTenThousandths(priceInTenThousandths, 4) },
+      { decimal: fromTenThousandths(notionalInTenThousandths, 2) },
+    ]);
+  }
+  return trades;
+};
+
+/** The SQL that makes and fills the tables, run on every connection checkout */
+export const CUBE_TRADES_SETUP_SQLS = [
+  `drop schema if exists ${CUBE_TRADES_SCHEMA} cascade`,
+  `create schema ${CUBE_TRADES_SCHEMA}`,
+  `create table ${CUBE_TRADES_SCHEMA}.DESKS (ID INTEGER PRIMARY KEY, DESK VARCHAR(20) NOT NULL, REGION VARCHAR(10) NOT NULL)`,
+  sampleInsert(
+    `${CUBE_TRADES_SCHEMA}.DESKS`,
+    DESKS.map(([desk, region], index) => [index + 1, desk, region]),
+  ),
+  `create table ${CUBE_TRADES_SCHEMA}.INSTRUMENTS (ID INTEGER PRIMARY KEY, SYMBOL VARCHAR(10) NOT NULL, INSTRUMENT VARCHAR(30) NOT NULL, ASSET_CLASS VARCHAR(10) NOT NULL, CURRENCY VARCHAR(3) NOT NULL)`,
+  sampleInsert(
+    `${CUBE_TRADES_SCHEMA}.INSTRUMENTS`,
+    INSTRUMENTS.map(([symbol, name, assetClass, currency], index) => [
+      index + 1,
+      symbol,
+      name,
+      assetClass,
+      currency,
+    ]),
+  ),
+  `create table ${CUBE_TRADES_SCHEMA}.TRADES (TRADE_ID INTEGER PRIMARY KEY, TRADE_DATE DATE NOT NULL, DESK_ID INTEGER NOT NULL, INSTRUMENT_ID INTEGER NOT NULL, SIDE VARCHAR(4) NOT NULL, QUANTITY INTEGER NOT NULL, PRICE DECIMAL(14,4) NOT NULL, NOTIONAL_USD DECIMAL(18,2) NOT NULL)`,
+  sampleInsert(`${CUBE_TRADES_SCHEMA}.TRADES`, createTrades()),
+];
+
+export const CUBE_TRADES_MODEL_CODE = `###Relational
+Database ${CUBE_TRADES_DATABASE}
+(
+  Schema ${CUBE_TRADES_SCHEMA}
+  (
+    Table DESKS
+    (
+      ID INTEGER PRIMARY KEY,
+      DESK VARCHAR(20) NOT NULL,
+      REGION VARCHAR(10) NOT NULL
+    )
+    Table INSTRUMENTS
+    (
+      ID INTEGER PRIMARY KEY,
+      SYMBOL VARCHAR(10) NOT NULL,
+      INSTRUMENT VARCHAR(30) NOT NULL,
+      ASSET_CLASS VARCHAR(10) NOT NULL,
+      CURRENCY VARCHAR(3) NOT NULL
+    )
+    Table TRADES
+    (
+      TRADE_ID INTEGER PRIMARY KEY,
+      TRADE_DATE DATE NOT NULL,
+      DESK_ID INTEGER NOT NULL,
+      INSTRUMENT_ID INTEGER NOT NULL,
+      SIDE VARCHAR(4) NOT NULL,
+      QUANTITY INTEGER NOT NULL,
+      PRICE DECIMAL(14,4) NOT NULL,
+      NOTIONAL_USD DECIMAL(18,2) NOT NULL
+    )
+  )
+
+  Join TRADE_DESK(${CUBE_TRADES_SCHEMA}.TRADES.DESK_ID = ${CUBE_TRADES_SCHEMA}.DESKS.ID)
+  Join TRADE_INSTRUMENT(${CUBE_TRADES_SCHEMA}.TRADES.INSTRUMENT_ID = ${CUBE_TRADES_SCHEMA}.INSTRUMENTS.ID)
+)
+
+
+###Connection
+RelationalDatabaseConnection ${CUBE_TRADES_CONNECTION}
+{
+  store: ${CUBE_TRADES_DATABASE};
+  type: H2;
+  specification: LocalH2
+  {
+    testDataSetupSqls: [
+${toPureSetupSqls(CUBE_TRADES_SETUP_SQLS)}
+    ];
+  };
+  auth: DefaultH2;
+}
+
+
+###Runtime
+Runtime ${CUBE_TRADES_RUNTIME}
+{
+  mappings:
+  [
+  ];
+  connections:
+  [
+    ${CUBE_TRADES_DATABASE}:
+    [
+      connection_1: ${CUBE_TRADES_CONNECTION}
+    ]
+  ];
+}
+`;
+
+/** The trades sample as a cube saves it (PLAN §6.2.2) */
+export const CUBE_TRADES_MODEL: ModelContext = Object.freeze({
+  _type: 'text',
+  code: CUBE_TRADES_MODEL_CODE,
+});

package/src/stores/source-picker/CubeCsvSetupSql.ts

@@ -0,0 +1,444 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { CUBE_CSV_MESSAGE } from '../../__lib__/LegendCubeDirectConnectionLabels.js';
+
+// A CSV loaded into an in-memory DuckDB connection: the CSV becomes setup SQL
+// (a table, then its rows as inserts), which the engine runs on every
+// connection and the cube saves with its connection. No file reaches the
+// engine's host
+
+/** The most rows a CSV may have: the cube saves them, and every connection inserts them again */
+export const CUBE_CSV_MAX_ROWS = 10_000;
+
+/** The most characters a CSV may have */
+export const CUBE_CSV_MAX_LENGTH = 5_000_000;
+
+/** The schema a CSV's table is created in */
+export const CUBE_CSV_SCHEMA = 'csv';
+
+/** How many rows one insert statement holds */
+const ROWS_PER_INSERT = 1000;
+
+/** The DuckDB types a CSV's columns are given, from their values */
+export enum CubeCsvColumnType {
+  INTEGER = 'INTEGER',
+  BIGINT = 'BIGINT',
+  DOUBLE = 'DOUBLE',
+  BOOLEAN = 'BOOLEAN',
+  DATE = 'DATE',
+  TIMESTAMP = 'TIMESTAMP',
+  VARCHAR = 'VARCHAR',
+}
+
+export class CubeCsvError extends Error {}
+
+/** A CSV loaded as a table: its name, its columns and their types, and the setup SQL that creates it */
+export interface CubeCsvTable {
+  readonly table: string;
+  readonly columns: readonly {
+    readonly name: string;
+    readonly type: CubeCsvColumnType;
+  }[];
+  readonly rowCount: number;
+  /** Statements in the form's setup SQL text: each ends on a line ending in ';' */
+  readonly sql: string;
+}
+
+/**
+ * The records of a CSV (RFC 4180): fields split on commas, a field in double
+ * quotes may hold commas, line breaks and doubled quotes; blank lines are
+ * skipped
+ */
+export const parseCubeCsv = (text: string): string[][] => {
+  const source = text.startsWith('') ? text.slice(1) : text;
+  const records: string[][] = [];
+  let record: string[] = [];
+  let field = '';
+  let quoted = false;
+  let wasQuoted = false;
+  let line = 1;
+  let quoteLine = 1;
+  const endField = (): void => {
+    record.push(field);
+    field = '';
+    wasQuoted = false;
+  };
+  const endRecord = (): void => {
+    const lastWasQuoted = wasQuoted;
+    endField();
+    // a blank line is one empty field, never quoted
+    if (record.length > 1 || record[0] !== '' || lastWasQuoted) {
+      records.push(record);
+    }
+    record = [];
+  };
+  for (let index = 0; index < source.length; index++) {
+    const char = source.charAt(index);
+    if (quoted) {
+      if (char === '"') {
+        if (source.charAt(index + 1) === '"') {
+          field += '"';
+          index++;
+        } else {
+          quoted = false;
+        }
+      } else {
+        if (char === '\n') {
+          line++;
+        }
+        field += char;
+      }
+    } else if (char === '"' && field === '') {
+      quoted = true;
+      wasQuoted = true;
+      quoteLine = line;
+    } else if (char === ',') {
+      endField();
+    } else if (char === '\r' || char === '\n') {
+      if (char === '\r' && source.charAt(index + 1) === '\n') {
+        index++;
+      }
+      line++;
+      endRecord();
+    } else {
+      field += char;
+    }
+  }
+  if (quoted) {
+    throw new CubeCsvError(CUBE_CSV_MESSAGE.UNCLOSED_QUOTE(quoteLine));
+  }
+  if (field !== '' || record.length || wasQuoted) {
+    endRecord();
+  }
+  return records;
+};
+
+const INTEGER_TEXT = /^[+-]?(?:0|[1-9]\d*)$/u;
+const NUMBER_TEXT = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/u;
+const BOOLEAN_TEXT = /^(?:true|false)$/iu;
+const DATE_TEXT = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/u;
+const TIMESTAMP_TEXT =
+  /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})[ T](?<hour>\d{2}):(?<minute>\d{2})(?::(?<second>\d{2})(?:\.\d{1,9})?)?$/u;
+
+const INT32 = { min: -(2n ** 31n), max: 2n ** 31n - 1n };
+const INT64 = { min: -(2n ** 63n), max: 2n ** 63n - 1n };
+
+const fits = (text: string, range: { min: bigint; max: bigint }): boolean => {
+  const value = BigInt(text);
+  return value >= range.min && value <= range.max;
+};
+
+/** Whether year, month and day name a real day */
+const isDay = (year: string, month: string, day: string): boolean => {
+  const date = new Date(Date.UTC(Number(year), Number(month) - 1, Number(day)));
+  return (
+    date.getUTCFullYear() === Number(year) &&
+    date.getUTCMonth() === Number(month) - 1 &&
+    date.getUTCDate() === Number(day)
+  );
+};
+
+const isDate = (text: string): boolean => {
+  const day = DATE_TEXT.exec(text)?.groups;
+  return Boolean(day && isDay(day.year ?? '', day.month ?? '', day.day ?? ''));
+};
+
+const isTimestamp = (text: string): boolean => {
+  const at = TIMESTAMP_TEXT.exec(text)?.groups;
+  return Boolean(
+    at &&
+      isDay(at.year ?? '', at.month ?? '', at.day ?? '') &&
+      Number(at.hour) < 24 &&
+      Number(at.minute) < 60 &&
+      Number(at.second ?? '0') < 60,
+  );
+};
+
+/**
+ * A column's type from its values, empty ones left out: the narrowest type
+ * every value fits. Whole numbers with a leading zero (codes, such as
+ * `007`) and ones past 64 bits stay text, so no digit is lost; numbers
+ * with a fraction are DOUBLE. A column of empty values is text.
+ */
+export const inferCubeCsvColumnType = (
+  values: readonly string[],
+): CubeCsvColumnType => {
+  const present = values.filter((value) => value !== '');
+  if (!present.length) {
+    return CubeCsvColumnType.VARCHAR;
+  }
+  if (present.every((value) => INTEGER_TEXT.test(value))) {
+    if (present.every((value) => fits(value, INT32))) {
+      return CubeCsvColumnType.INTEGER;
+    }
+    return present.every((value) => fits(value, INT64))
+      ? CubeCsvColumnType.BIGINT
+      : CubeCsvColumnType.VARCHAR;
+  }
+  if (
+    present.every((value) => NUMBER_TEXT.test(value)) &&
+    // a whole number with a leading zero is a code, not a number
+    !present.some((value) => /^[+-]?0\d/u.test(value))
+  ) {
+    return CubeCsvColumnType.DOUBLE;
+  }
+  if (present.every((value) => BOOLEAN_TEXT.test(value))) {
+    return CubeCsvColumnType.BOOLEAN;
+  }
+  if (present.every(isDate)) {
+    return CubeCsvColumnType.DATE;
+  }
+  if (present.every((value) => isDate(value) || isTimestamp(value))) {
+    return CubeCsvColumnType.TIMESTAMP;
+  }
+  return CubeCsvColumnType.VARCHAR;
+};
+
+/**
+ * The keywords that can't name a column or table unquoted: DuckDB's
+ * `reserved` and `type_function` ones, as `duckdb_keywords()` lists them on
+ * the engine's DuckDB (1.3)
+ */
+const RESERVED_WORDS = new Set([
+  'all',
+  'analyse',
+  'analyze',
+  'and',
+  'anti',
+  'any',
+  'array',
+  'as',
+  'asc',
+  'asof',
+  'asymmetric',
+  'at',
+  'authorization',
+  'binary',
+  'both',
+  'case',
+  'cast',
+  'check',
+  'collate',
+  'collation',
+  'column',
+  'columns',
+  'concurrently',
+  'constraint',
+  'create',
+  'cross',
+  'default',
+  'deferrable',
+  'desc',
+  'describe',
+  'distinct',
+  'do',
+  'else',
+  'end',
+  'except',
+  'false',
+  'fetch',
+  'for',
+  'foreign',
+  'freeze',
+  'from',
+  'full',
+  'generated',
+  'glob',
+  'group',
+  'having',
+  'ilike',
+  'in',
+  'initially',
+  'inner',
+  'intersect',
+  'into',
+  'is',
+  'isnull',
+  'join',
+  'lambda',
+  'lateral',
+  'leading',
+  'left',
+  'like',
+  'limit',
+  'map',
+  'natural',
+  'not',
+  'notnull',
+  'null',
+  'offset',
+  'on',
+  'only',
+  'or',
+  'order',
+  'outer',
+  'overlaps',
+  'pivot',
+  'pivot_longer',
+  'pivot_wider',
+  'placing',
+  'positional',
+  'primary',
+  'qualify',
+  'references',
+  'returning',
+  'right',
+  'select',
+  'semi',
+  'show',
+  'similar',
+  'some',
+  'struct',
+  'summarize',
+  'symmetric',
+  'table',
+  'tablesample',
+  'then',
+  'to',
+  'trailing',
+  'true',
+  'try_cast',
+  'union',
+  'unique',
+  'unpack',
+  'unpivot',
+  'using',
+  'variadic',
+  'verbose',
+  'when',
+  'where',
+  'window',
+  'with',
+]);
+
+/**
+ * A name the database takes unquoted: letters, digits and underscores, not
+ * starting with a digit, and no reserved word (one gets a trailing
+ * underscore)
+ */
+export const toCubeCsvName = (text: string, fallback: string): string => {
+  const name = text.trim().replace(/[^A-Za-z0-9_]+/gu, '_');
+  const safe = !name || /^_*$/u.test(name) ? fallback : name;
+  const start = /^[0-9]/u.test(safe) ? `_${safe}` : safe;
+  return RESERVED_WORDS.has(start.toLowerCase()) ? `${start}_` : start;
+};
+
+/** The header's names made safe, and distinct whatever their case */
+const toColumnNames = (header: readonly string[]): string[] => {
+  const used = new Set<string>();
+  return header.map((text, index) => {
+    const base = toCubeCsvName(text, `column_${index + 1}`);
+    let name = base;
+    for (let suffix = 2; used.has(name.toLowerCase()); suffix++) {
+      name = `${base}_${suffix}`;
+    }
+    used.add(name.toLowerCase());
+    return name;
+  });
+};
+
+/** A string literal: quotes doubled, line breaks as chr(10), so no line of the setup SQL ends inside it */
+const quote = (value: string): string =>
+  `'${value
+    .replace(/'/gu, "''")
+    .split(/\r\n|\r|\n/u)
+    .join("' || chr(10) || '")}'`;
+
+const toLiteral = (value: string, type: CubeCsvColumnType): string => {
+  if (value === '') {
+    return 'NULL';
+  }
+  switch (type) {
+    case CubeCsvColumnType.INTEGER:
+    case CubeCsvColumnType.BIGINT:
+    case CubeCsvColumnType.DOUBLE:
+      return value;
+    case CubeCsvColumnType.BOOLEAN:
+      return value.toLowerCase();
+    case CubeCsvColumnType.DATE:
+      return `DATE '${value}'`;
+    case CubeCsvColumnType.TIMESTAMP:
+      return `TIMESTAMP '${value.replace('T', ' ')}'`;
+    default:
+      return quote(value);
+  }
+};
+
+/**
+ * A CSV, with a header row, as a table of the `csv` schema: setup SQL that
+ * creates the schema if needed, drops and creates the table, then inserts
+ * the rows. Refuses an empty CSV, a record whose values don't match the
+ * header, and one past the limits.
+ */
+export const buildCubeCsvTable = (
+  text: string,
+  tableName: string,
+): CubeCsvTable => {
+  if (text.length > CUBE_CSV_MAX_LENGTH) {
+    throw new CubeCsvError(CUBE_CSV_MESSAGE.TOO_LONG(CUBE_CSV_MAX_LENGTH));
+  }
+  const [header, ...rows] = parseCubeCsv(text);
+  if (!header) {
+    throw new CubeCsvError(CUBE_CSV_MESSAGE.EMPTY);
+  }
+  if (rows.length > CUBE_CSV_MAX_ROWS) {
+    throw new CubeCsvError(
+      CUBE_CSV_MESSAGE.TOO_MANY_ROWS(rows.length, CUBE_CSV_MAX_ROWS),
+    );
+  }
+  rows.forEach((row, index) => {
+    if (row.length !== header.length) {
+      throw new CubeCsvError(
+        CUBE_CSV_MESSAGE.RAGGED_ROW(index + 1, row.length, header.length),
+      );
+    }
+  });
+  const table = toCubeCsvName(tableName, 'csv_data');
+  const names = toColumnNames(header);
+  const columns = names.map((name, index) => ({
+    name,
+    type: inferCubeCsvColumnType(rows.map((row) => row[index] ?? '')),
+  }));
+  const qualified = `${CUBE_CSV_SCHEMA}.${table}`;
+  const statements = [
+    `create schema if not exists ${CUBE_CSV_SCHEMA};`,
+    `drop table if exists ${qualified};`,
+    `create table ${qualified} (${columns
+      .map((column) => `${column.name} ${column.type}`)
+      .join(', ')});`,
+  ];
+  for (let start = 0; start < rows.length; start += ROWS_PER_INSERT) {
+    const chunk = rows.slice(start, start + ROWS_PER_INSERT);
+    statements.push(
+      [
+        `insert into ${qualified} values`,
+        ...chunk.map(
+          (row, index) =>
+            `(${row
+              .map((value, column) =>
+                toLiteral(
+                  value,
+                  columns[column]?.type ?? CubeCsvColumnType.VARCHAR,
+                ),
+              )
+              .join(', ')})${index === chunk.length - 1 ? ';' : ','}`,
+        ),
+      ].join('\n'),
+    );
+  }
+  return { table, columns, rowCount: rows.length, sql: statements.join('\n') };
+};