Skip to content

Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.

23.7 KB
Raw Blame
// SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project

import test from 'tape';
import * as arrow from 'apache-arrow';
import Console from 'global/console';

import {
  SUPPORTED_DUCKDB_DROP_EXTENSIONS,
  getDuckDBColumnTypesMap,
  castDuckDBTypesForKepler,
  setGeoArrowWKBExtension,
  removeUnsupportedExtensions,
  restoreArrowTable,
  restoreUnsupportedExtensions,
  isGeoArrowPoint,
  isGeoArrowLineString,
  isGeoArrowPolygon,
  isGeoArrowMultiPoint,
  isGeoArrowMultiLineString,
  isGeoArrowMultiPolygon,
  splitSqlStatements,
  removeSQLComments,
  sanitizeDuckDBTableName,
  quoteTableName
} from '../../../src/duckdb/src/table/duckdb-table-utils';
import {KeplerGlDuckDbTable} from '../../../src/duckdb/src/table/duckdb-table';

import {GEOARROW_EXTENSIONS, GEOARROW_METADATA_KEY} from '@kepler.gl/constants';

test('restoreArrowTable -> numeric names preserve column order and supplied schema', t => {
  const columns = [
    arrow.vectorFromArray([37, null], new arrow.Float64()),
    arrow.vectorFromArray([1000, 2000], new arrow.Int32())
  ];
  const fields = ['lat', '2020'].map(
    (name, i) => new arrow.Field(name, columns[i].type, true, new Map([['source', name]]))
  );
  const schema = new arrow.Schema(fields, new Map([['source', 'original']]));
  for (const originalSchema of [undefined, schema]) {
    const restored = restoreArrowTable(columns, fields, originalSchema);
    t.deepEqual(
      restored.schema.fields.map(f => f.name),
      ['lat', '2020']
    );
    t.deepEqual(Array.from(restored.getChildAt(0)), [37, null]);
    t.deepEqual(Array.from(restored.getChildAt(1)), [1000, 2000]);
    columns.forEach((column, i) => {
      t.equal(restored.getChildAt(i).type.toString(), column.type.toString());
      t.equal(restored.getChildAt(i).data[0].values.buffer, column.data[0].values.buffer);
    });
    if (originalSchema) {
      t.deepEqual(restored.schema.metadata, schema.metadata);
      t.deepEqual(restored.schema.fields[0].metadata, fields[0].metadata);
    }
    t.equal(arrow.tableFromIPC(arrow.tableToIPC(restored)).getChild('2020').get(0), 1000);
    const empty = restoreArrowTable(
      columns.map(column => column.slice(0, 0)),
      fields,
      originalSchema
    );
    t.equal(empty.numRows, 0);
    t.equal(empty.getChildAt(1).type.toString(), 'Int32');
  }
  t.end();
});

// Test getDuckDBColumnTypesMap
test('duckdb-utils -> getDuckDBColumnTypesMap', t => {
  const columns = [
    {name: 'id', type: 'INTEGER'},
    {name: 'name', type: 'VARCHAR'},
    {name: 'location', type: 'GEOMETRY'}
  ];

  const result = getDuckDBColumnTypesMap(columns);

  t.equal(result.id, 'INTEGER', 'should map id to INTEGER');
  t.equal(result.name, 'VARCHAR', 'should map name to VARCHAR');
  t.equal(result.location, 'GEOMETRY', 'should map location to GEOMETRY');
  t.equal(Object.keys(result).length, 3, 'should have correct number of mappings');

  t.end();
});

// Test getDuckDBColumnTypesMap with empty array
test('duckdb-utils -> getDuckDBColumnTypesMap empty', t => {
  const columns = [];
  const result = getDuckDBColumnTypesMap(columns);

  t.deepEqual(result, {}, 'should return empty object for empty array');
  t.end();
});

// Test castDuckDBTypesForKepler
test('duckdb-utils -> castDuckDBTypesForKepler', t => {
  const tableName = 'test_table';
  const columns = [
    {name: 'id', type: 'INTEGER'},
    {name: 'name', type: 'VARCHAR'},
    {name: 'location', type: 'GEOMETRY'},
    {name: 'big_number', type: 'BIGINT'}
  ];

  const result = castDuckDBTypesForKepler(tableName, columns);

  const resultMock = `SELECT "id", "name", ST_AsWKB("location") as "location", CAST("big_number" AS DOUBLE) as "big_number" FROM "test_table"`;
  t.equal(result, resultMock, 'should return correct SQL');

  t.end();
});

// Test castDuckDBTypesForKepler with options
test('duckdb-utils -> castDuckDBTypesForKepler options', t => {
  const tableName = 'test_table';
  const columns = [
    {name: 'location', type: 'GEOMETRY'},
    {name: 'big_number', type: 'BIGINT'}
  ];

  const resultNoGeometry = castDuckDBTypesForKepler(tableName, columns, {
    geometryToWKB: false,
    bigIntToDouble: true
  });
  const resultNoGeometryMock = `SELECT "location", CAST("big_number" AS DOUBLE) as "big_number" FROM "test_table"`;
  t.equal(resultNoGeometry, resultNoGeometryMock, 'should return correct SQL');

  const resultNoBigInt = castDuckDBTypesForKepler(tableName, columns, {
    geometryToWKB: true,
    bigIntToDouble: false
  });
  const resultNoBigIntMock = `SELECT ST_AsWKB("location") as "location", "big_number" FROM "test_table"`;
  t.equal(resultNoBigInt, resultNoBigIntMock, 'should return correct SQL');

  t.end();
});

// Test castDuckDBTypesForKepler with DECIMAL types
test('duckdb-utils -> castDuckDBTypesForKepler with DECIMAL', t => {
  const tableName = 'test_table';
  const columns = [
    {name: 'id', type: 'INTEGER'},
    {name: 'price', type: 'DECIMAL(18,2)'},
    {name: 'amount', type: 'DECIMAL'},
    {name: 'rate', type: 'DECIMAL(10,5)'}
  ];

  const result = castDuckDBTypesForKepler(tableName, columns);

  const resultMock = `SELECT "id", CAST("price" AS DOUBLE) as "price", CAST("amount" AS DOUBLE) as "amount", CAST("rate" AS DOUBLE) as "rate" FROM "test_table"`;
  t.equal(result, resultMock, 'should cast DECIMAL types to DOUBLE');

  t.end();
});

// Test castDuckDBTypesForKepler
test('duckdb-utils -> castDuckDBTypesForKepler with complex table name', t => {
  const tableName = '"memory"."main"."earthquakes"';
  const columns = [{name: 'id', type: 'INTEGER'}];

  const result = castDuckDBTypesForKepler(tableName, columns);

  const resultMock = `SELECT "id" FROM "memory"."main"."earthquakes"`;
  t.equal(result, resultMock, 'should return correct SQL');

  t.end();
});

// Test setGeoArrowWKBExtension
test('duckdb-utils -> setGeoArrowWKBExtension', t => {
  const columns = [
    {name: 'id', type: 'INTEGER'},
    {name: 'location', type: 'GEOMETRY'}
  ];

  // Create a mock arrow table with schema
  const schema = new arrow.Schema([
    new arrow.Field('id', new arrow.Int32()),
    new arrow.Field('location', new arrow.Binary())
  ]);

  const table = new arrow.Table(schema);

  setGeoArrowWKBExtension(table, columns);

  // Check if the metadata was set for the geometry field
  const locationField = table.schema.fields.find(f => f.name === 'location');
  t.equal(
    locationField.metadata.get(GEOARROW_METADATA_KEY),
    GEOARROW_EXTENSIONS.WKB,
    'should set WKB extension for GEOMETRY fields'
  );

  const idField = table.schema.fields.find(f => f.name === 'id');
  t.equal(
    idField.metadata.get(GEOARROW_METADATA_KEY),
    undefined,
    'should not set extension for non-GEOMETRY fields'
  );

  t.end();
});

// Test removeUnsupportedExtensions
test('duckdb-utils -> removeUnsupportedExtensions', t => {
  const schema = new arrow.Schema([
    new arrow.Field('id', new arrow.Int32()),
    new arrow.Field('location', new arrow.Binary())
  ]);

  const table = new arrow.Table(schema);

  // Add geoarrow extension to location field
  table.schema.fields[1].metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.WKB);

  const removedExtensions = removeUnsupportedExtensions(table);

  t.equal(removedExtensions.location, GEOARROW_EXTENSIONS.WKB, 'should return removed extension');
  t.equal(
    table.schema.fields[1].metadata.get(GEOARROW_METADATA_KEY),
    undefined,
    'should remove extension from field'
  );

  t.end();
});

// Test restoreUnsupportedExtensions
test('duckdb-utils -> restoreUnsupportedExtensions', t => {
  const schema = new arrow.Schema([
    new arrow.Field('id', new arrow.Int32()),
    new arrow.Field('location', new arrow.Binary())
  ]);

  const table = new arrow.Table(schema);

  const removedExtensions = {
    location: GEOARROW_EXTENSIONS.WKB
  };

  restoreUnsupportedExtensions(table, removedExtensions);

  t.equal(
    table.schema.fields[1].metadata.get(GEOARROW_METADATA_KEY),
    GEOARROW_EXTENSIONS.WKB,
    'should restore extension to field'
  );

  t.end();
});

// Test isGeoArrowPoint
test('duckdb-utils -> isGeoArrowPoint', t => {
  // Create a valid point type (FixedSizeList of 2 float64s)
  const pointType = new arrow.FixedSizeList(2, new arrow.Field('', new arrow.Float64()));
  t.ok(isGeoArrowPoint(pointType), 'should recognize valid 2D point');

  // Create a valid 3D point type (FixedSizeList of 3 float64s)
  const point3DType = new arrow.FixedSizeList(3, new arrow.Field('', new arrow.Float64()));
  t.ok(isGeoArrowPoint(point3DType), 'should recognize valid 3D point');

  // Create an invalid point type (FixedSizeList of 5 float64s)
  const invalidPointType = new arrow.FixedSizeList(5, new arrow.Field('', new arrow.Float64()));
  t.notOk(isGeoArrowPoint(invalidPointType), 'should not recognize invalid point with size 5');

  // Create a non-FixedSizeList type
  const nonPointType = new arrow.Utf8();
  t.notOk(isGeoArrowPoint(nonPointType), 'should not recognize non-FixedSizeList type');

  // Create a FixedSizeList with non-float child
  const nonFloatPointType = new arrow.FixedSizeList(2, new arrow.Field('', new arrow.Int32()));
  t.notOk(isGeoArrowPoint(nonFloatPointType), 'should not recognize point with non-float child');

  t.end();
});

// Test isGeoArrowLineString
test('duckdb-utils -> isGeoArrowLineString', t => {
  // Create a valid linestring type (List of points)
  const pointType = new arrow.FixedSizeList(2, new arrow.Field('', new arrow.Float64()));
  const lineStringType = new arrow.List(new arrow.Field('', pointType));
  t.ok(isGeoArrowLineString(lineStringType), 'should recognize valid linestring');

  // Create an invalid linestring type (List of non-points)
  const invalidLineStringType = new arrow.List(new arrow.Field('', new arrow.Int32()));
  t.notOk(isGeoArrowLineString(invalidLineStringType), 'should not recognize list of non-points');

  // Create a non-List type
  const nonListType = new arrow.Utf8();
  t.notOk(isGeoArrowLineString(nonListType), 'should not recognize non-List type');

  t.end();
});

// Test isGeoArrowPolygon
test('duckdb-utils -> isGeoArrowPolygon', t => {
  // Create a valid polygon type (List of linestrings)
  const pointType = new arrow.FixedSizeList(2, new arrow.Field('', new arrow.Float64()));
  const lineStringType = new arrow.List(new arrow.Field('', pointType));
  const polygonType = new arrow.List(new arrow.Field('', lineStringType));
  t.ok(isGeoArrowPolygon(polygonType), 'should recognize valid polygon');

  // Create an invalid polygon type (List of non-linestrings)
  const invalidPolygonType = new arrow.List(new arrow.Field('', new arrow.Int32()));
  t.notOk(isGeoArrowPolygon(invalidPolygonType), 'should not recognize list of non-linestrings');

  // Create a non-List type
  const nonListType = new arrow.Utf8();
  t.notOk(isGeoArrowPolygon(nonListType), 'should not recognize non-List type');

  t.end();
});

// Test isGeoArrowMultiPoint
test('duckdb-utils -> isGeoArrowMultiPoint', t => {
  // Create a valid multipoint type (List of points)
  const pointType = new arrow.FixedSizeList(2, new arrow.Field('', new arrow.Float64()));
  const multiPointType = new arrow.List(new arrow.Field('', pointType));
  t.ok(isGeoArrowMultiPoint(multiPointType), 'should recognize valid multipoint');

  // Create an invalid multipoint type (List of non-points)
  const invalidMultiPointType = new arrow.List(new arrow.Field('', new arrow.Int32()));
  t.notOk(isGeoArrowMultiPoint(invalidMultiPointType), 'should not recognize list of non-points');

  // Create a non-List type
  const nonListType = new arrow.Utf8();
  t.notOk(isGeoArrowMultiPoint(nonListType), 'should not recognize non-List type');

  t.end();
});

// Test isGeoArrowMultiLineString
test('duckdb-utils -> isGeoArrowMultiLineString', t => {
  // Create a valid multilinestring type (List of linestrings)
  const pointType = new arrow.FixedSizeList(2, new arrow.Field('', new arrow.Float64()));
  const lineStringType = new arrow.List(new arrow.Field('', pointType));
  const multiLineStringType = new arrow.List(new arrow.Field('', lineStringType));
  t.ok(isGeoArrowMultiLineString(multiLineStringType), 'should recognize valid multilinestring');

  // Create an invalid multilinestring type (List of non-linestrings)
  const invalidMultiLineStringType = new arrow.List(new arrow.Field('', new arrow.Int32()));
  t.notOk(
    isGeoArrowMultiLineString(invalidMultiLineStringType),
    'should not recognize list of non-linestrings'
  );

  // Create a non-List type
  const nonListType = new arrow.Utf8();
  t.notOk(isGeoArrowMultiLineString(nonListType), 'should not recognize non-List type');

  t.end();
});

// Test isGeoArrowMultiPolygon
test('duckdb-utils -> isGeoArrowMultiPolygon', t => {
  // Create a valid multipolygon type (List of polygons)
  const pointType = new arrow.FixedSizeList(2, new arrow.Field('', new arrow.Float64()));
  const lineStringType = new arrow.List(new arrow.Field('', pointType));
  const polygonType = new arrow.List(new arrow.Field('', lineStringType));
  const multiPolygonType = new arrow.List(new arrow.Field('', polygonType));
  t.ok(isGeoArrowMultiPolygon(multiPolygonType), 'should recognize valid multipolygon');

  // Create an invalid multipolygon type (List of non-polygons)
  const invalidMultiPolygonType = new arrow.List(new arrow.Field('', new arrow.Int32()));
  t.notOk(
    isGeoArrowMultiPolygon(invalidMultiPolygonType),
    'should not recognize list of non-polygons'
  );

  // Create a non-List type
  const nonListType = new arrow.Utf8();
  t.notOk(isGeoArrowMultiPolygon(nonListType), 'should not recognize non-List type');

  t.end();
});

// Test splitSqlStatements
test('duckdb-utils -> splitSqlStatements', t => {
  // Test simple case
  const simpleSQL = 'SELECT * FROM table1; SELECT * FROM table2;';
  const simpleResult = splitSqlStatements(simpleSQL);
  t.equal(simpleResult.length, 2, 'should split simple statements');
  t.equal(simpleResult[0], 'SELECT * FROM table1', 'should trim semicolon');
  t.equal(simpleResult[1], 'SELECT * FROM table2', 'should trim semicolon');

  // Test with quoted strings
  const quotedSQL = 'SELECT \'hello;world\' FROM table1; SELECT "col;name" FROM table2;';
  const quotedResult = splitSqlStatements(quotedSQL);
  t.equal(quotedResult.length, 2, 'should handle quoted semicolons');
  t.ok(quotedResult[0].includes('hello;world'), 'should preserve semicolon in single quotes');
  t.ok(quotedResult[1].includes('col;name'), 'should preserve semicolon in double quotes');

  // Test with comments
  const commentSQL = 'SELECT * FROM table1; -- comment with ; semicolon\nSELECT * FROM table2;';
  const commentResult = splitSqlStatements(commentSQL);
  t.equal(commentResult.length, 2, 'should handle line comments');

  // Test with block comments
  const blockCommentSQL =
    'SELECT * FROM table1 /* block comment ; with semicolon */ SELECT * FROM table2;';
  const blockCommentResult = splitSqlStatements(blockCommentSQL);
  t.equal(blockCommentResult.length, 1, 'should handle block comments');

  // Test with escaped quotes
  const escapedSQL =
    'SELECT \'it\'\'s working\' FROM table1; SELECT "he said ""hello""" FROM table2;';
  const escapedResult = splitSqlStatements(escapedSQL);
  t.equal(escapedResult.length, 2, 'should handle escaped quotes');

  // Test empty statements
  const emptySQL = ';;; SELECT * FROM table1;; ; SELECT * FROM table2;;;';
  const emptyResult = splitSqlStatements(emptySQL);
  t.equal(emptyResult.length, 2, 'should filter out empty statements');

  // Test single statement without semicolon
  const singleSQL = 'SELECT * FROM table1';
  const singleResult = splitSqlStatements(singleSQL);
  t.equal(singleResult.length, 1, 'should handle single statement without semicolon');
  t.equal(singleResult[0], 'SELECT * FROM table1', 'should return trimmed statement');

  // Test empty string
  const emptyString = '';
  const emptyStringResult = splitSqlStatements(emptyString);
  t.equal(emptyStringResult.length, 0, 'should return empty array for empty string');

  t.end();
});

// Test removeSQLComments
test('duckdb-utils -> removeSQLComments', t => {
  // Test line comments
  const lineComment = 'SELECT * FROM table1; -- this is a comment';
  const lineResult = removeSQLComments(lineComment);
  t.equal(lineResult, 'SELECT * FROM table1;', 'should remove line comments');

  // Test block comments
  const blockComment = 'SELECT * FROM table1 /* this is a block comment */ WHERE id = 1;';
  const blockResult = removeSQLComments(blockComment);
  t.equal(blockResult, 'SELECT * FROM table1  WHERE id = 1;', 'should remove block comments');

  // Test multiple line comments
  const multiLineComment = 'SELECT * FROM table1; -- comment 1\nSELECT * FROM table2; -- comment 2';
  const multiLineResult = removeSQLComments(multiLineComment);
  t.equal(
    multiLineResult,
    'SELECT * FROM table1; \nSELECT * FROM table2;',
    'should remove multiple line comments'
  );

  // Test multiline block comments
  const multiBlockComment =
    'SELECT * FROM table1 /* this is a\nmultiline\nblock comment */ WHERE id = 1;';
  const multiBlockResult = removeSQLComments(multiBlockComment);
  t.equal(
    multiBlockResult,
    'SELECT * FROM table1  WHERE id = 1;',
    'should remove multiline block comments'
  );

  // Test mixed comments
  const mixedComment = 'SELECT * FROM table1 /* block */ WHERE id = 1; -- line comment';
  const mixedResult = removeSQLComments(mixedComment);
  t.equal(mixedResult, 'SELECT * FROM table1  WHERE id = 1;', 'should remove mixed comments');

  // Test no comments
  const noComment = 'SELECT * FROM table1 WHERE id = 1;';
  const noCommentResult = removeSQLComments(noComment);
  t.equal(
    noCommentResult,
    'SELECT * FROM table1 WHERE id = 1;',
    'should leave SQL without comments unchanged'
  );

  t.end();
});

// Test sanitizeDuckDBTableName
test('duckdb-utils -> sanitizeDuckDBTableName', t => {
  // Test valid name
  const validName = 'valid_table_name';
  t.equal(sanitizeDuckDBTableName(validName), validName, 'should keep valid name unchanged');

  // Test name with spaces
  const spaceName = 'table name with spaces';
  t.equal(
    sanitizeDuckDBTableName(spaceName),
    'table_name_with_spaces',
    'should replace spaces with underscores'
  );

  // Test name with special characters
  const specialName = 'table-name.with@special#chars';
  t.equal(
    sanitizeDuckDBTableName(specialName),
    'table_name_with_special_chars',
    'should replace special characters with underscores'
  );

  // Test name starting with number
  const numberName = '123table';
  t.equal(
    sanitizeDuckDBTableName(numberName),
    't_123table',
    'should prepend t_ to names starting with number'
  );

  // Test empty string
  const emptyName = '';
  t.equal(
    sanitizeDuckDBTableName(emptyName),
    'default_table',
    'should return default_table for empty string'
  );

  // Test file extensions
  const csvFile = 'data.csv';
  t.equal(sanitizeDuckDBTableName(csvFile), 'data_csv', 'should handle file extensions');

  // Test complex case
  const complexName = '123-data file.csv';
  t.equal(
    sanitizeDuckDBTableName(complexName),
    't_123_data_file_csv',
    'should handle complex cases'
  );

  t.end();
});

// Test quoteTableName
test('duckdb-utils -> quoteTableName', t => {
  // Test simple table names (should get quoted)
  t.equal(quoteTableName('simple_table'), '"simple_table"', 'should quote simple table name');
  t.equal(quoteTableName('table'), '"table"', 'should quote single word table name');

  // Test table names with special characters (should get quoted)
  t.equal(quoteTableName('table name'), '"table name"', 'should quote table name with spaces');
  t.equal(quoteTableName('table-name'), '"table-name"', 'should quote table name with hyphens');
  t.equal(
    quoteTableName('table@name'),
    '"table@name"',
    'should quote table name with special chars'
  );

  // Test already quoted simple names (should get quoted again with proper escaping)
  t.equal(
    quoteTableName('already"quoted'),
    '"already""quoted"',
    'should escape quotes in table name'
  );
  t.equal(quoteTableName('"quoted"'), '"quoted"', 'should preserve already quoted table name');
  t.equal(
    quoteTableName('"table with spaces"'),
    '"table with spaces"',
    'should preserve already quoted table name with spaces'
  );
  t.equal(
    quoteTableName('"table-with-hyphens"'),
    '"table-with-hyphens"',
    'should preserve already quoted table name with hyphens'
  );

  t.equal(
    quoteTableName('"memory"."main"."earthquakes"'),
    '"memory"."main"."earthquakes"',
    'should preserve complex qualified name'
  );

  t.equal(
    quoteTableName('"my schema"."db-name"."schema_name"."table-name"'),
    '"my schema"."db-name"."schema_name"."table-name"',
    'should preserve qualified name with special chars'
  );

  // Test qualified names with dots inside quotes (would break old parsing logic)
  t.equal(
    quoteTableName('"my.schema"."table.name"'),
    '"my.schema"."table.name"',
    'should preserve qualified name with dots inside quotes'
  );

  // Test invalid fully qualified names (should get quoted)
  t.equal(quoteTableName('schema.table'), '"schema.table"', 'should quote unquoted qualified name');
  t.equal(
    quoteTableName('"schema".table'),
    '"schema".table',
    'should preserve partially quoted name (trust user intent)'
  );
  t.equal(
    quoteTableName('schema."table"'),
    'schema."table"',
    'should preserve partially quoted name (trust user intent)'
  );
  t.equal(
    quoteTableName('bad."format'),
    'bad."format',
    'should preserve name with dots and quotes (trust user intent)'
  );

  // Test edge cases
  t.equal(quoteTableName(''), '""', 'should handle empty string');
  t.equal(quoteTableName('123table'), '"123table"', 'should quote name starting with number');
  t.equal(quoteTableName('table.'), '"table."', 'should quote name ending with dot');
  t.equal(quoteTableName('.table'), '".table"', 'should quote name starting with dot');

  // Test cases that should NOT be treated as qualified names
  t.equal(
    quoteTableName('table.with.dots'),
    '"table.with.dots"',
    'should quote name with dots but no quotes'
  );
  t.equal(
    quoteTableName('"single.quoted.name"'),
    '"single.quoted.name"',
    'should preserve single quoted name with dots as simple identifier'
  );

  t.end();
});

// Test SUPPORTED_DUCKDB_DROP_EXTENSIONS constant
test('duckdb-utils -> SUPPORTED_DUCKDB_DROP_EXTENSIONS', t => {
  t.ok(Array.isArray(SUPPORTED_DUCKDB_DROP_EXTENSIONS), 'should be an array');
  t.ok(SUPPORTED_DUCKDB_DROP_EXTENSIONS.includes('csv'), 'should include csv');
  t.ok(SUPPORTED_DUCKDB_DROP_EXTENSIONS.includes('json'), 'should include json');
  t.ok(SUPPORTED_DUCKDB_DROP_EXTENSIONS.includes('parquet'), 'should include parquet');
  t.ok(SUPPORTED_DUCKDB_DROP_EXTENSIONS.includes('geojson'), 'should include geojson');
  t.ok(SUPPORTED_DUCKDB_DROP_EXTENSIONS.includes('arrow'), 'should include arrow');
  t.equal(SUPPORTED_DUCKDB_DROP_EXTENSIONS.length, 5, 'should have 5 supported extensions');

  t.end();
});

test('KeplerGlDuckDbTable -> row edits stay a warned no-op', t => {
  const snapshot = arrow.tableFromJSON([{id: 'a', value: 1}]);
  const table = new KeplerGlDuckDbTable({info: {id: 'duck', label: 'duck'}}).updateSchema({
    fields: [
      {name: 'id', type: 'string'},
      {name: 'value', type: 'real'}
    ],
    cols: snapshot.schema.fields.map((_, i) => snapshot.getChildAt(i)),
    arrowTable: snapshot,
    rows: []
  });
  const originalWarn = Console.warn;
  const warnings = [];
  Console.warn = message => warnings.push(String(message));

  try {
    t.equal(table.appendRows([['b', 2]]), false, 'appendRows should no-op');
    t.equal(table.upsertRows([['a', 2]], 'id'), false, 'upsertRows should no-op');
    t.equal(table.removeRows([0]), false, 'removeRows should no-op');
    t.deepEqual(table.dataContainer.flattenData(), [['a', 1]], 'snapshot stays unchanged');
    t.ok(
      warnings.some(message => message.includes('DuckDB INSERT')),
      'should warn that DuckDB INSERT is not implemented'
    );
  } finally {
    Console.warn = originalWarn;
  }
  t.end();
});