kepler.gl 3.1.0 → 3.1.1

package/src/duckdb/src/table/duckdb-table-utils.ts

@@ -7,9 +7,153 @@
 
 // Copied from loaders.gl/geoarrow
 
-// TODO: Remove once Kepler.gl is upgraded to loaders.gl 4.4+
+// TODO: Remove isGeoArrow* once Kepler.gl is upgraded to loaders.gl 4.4+
 
+import * as arrow from 'apache-arrow';
 import {DataType} from 'apache-arrow/type';
+import {AsyncDuckDBConnection, DuckDBDataProtocol} from '@duckdb/duckdb-wasm';
+
+import {GEOARROW_EXTENSIONS, GEOARROW_METADATA_KEY} from '@kepler.gl/constants';
+import {ProtoDatasetField} from '@kepler.gl/types';
+
+import {getDuckDB} from '../init';
+
+export const SUPPORTED_DUCKDB_DROP_EXTENSIONS = ['arrow', 'csv', 'geojson', 'json', 'parquet'];
+
+export type DuckDBColumnDesc = {name: string; type: string};
+
+/**
+ * Queries a DuckDB table for the schema description.
+ * @param connection An active DuckDB connection.
+ * @param tableName A name of DuckDB table to query.
+ * @returns An array of column names and DuckDB types.
+ */
+export async function getDuckDBColumnTypes(
+  connection: AsyncDuckDBConnection,
+  tableName: string
+): Promise<DuckDBColumnDesc[]> {
+  const resDescribe = await connection.query(`DESCRIBE "${tableName}";`);
+
+  const duckDbTypes: DuckDBColumnDesc[] = [];
+  const numRows = resDescribe.numRows;
+  for (let i = 0; i < numRows; ++i) {
+    const columnName = resDescribe.getChildAt(0)?.get(i);
+    const columnType = resDescribe.getChildAt(1)?.get(i);
+
+    duckDbTypes.push({
+      name: columnName,
+      type: columnType
+    });
+  }
+
+  return duckDbTypes;
+}
+
+/**
+ * Generates a mapping of column names to their corresponding DuckDB data types.
+ * @param columns An array of column descriptions from DuckDB. Check getDuckDBColumnTypes.
+ * @returns A record where keys are column names and values are their data types.
+ */
+export function getDuckDBColumnTypesMap(columns: DuckDBColumnDesc[]) {
+  return columns.reduce((acc, value) => {
+    acc[value.name] = value.type;
+    return acc;
+  }, {} as Record<string, string>);
+}
+
+/**
+ * Constructs an SQL query to select all columns from a given table,
+ * converting specified columns to Well-Known Binary (WKB) format using ST_AsWKB.
+ * @param tableName The name of the table from which to select data.
+ * @param columnsToConvertToWKB An array of column names that should be converted to WKB format.
+ * @returns The constructed SQL query.
+ */
+export function constructST_asWKBQuery(tableName: string, columnsToConvertToWKB: string[]): string {
+  const exclude =
+    columnsToConvertToWKB.length > 0 ? `EXCLUDE ${columnsToConvertToWKB.join(', ')}` : '';
+  const asWKB =
+    columnsToConvertToWKB.length > 0
+      ? `, ${columnsToConvertToWKB.map(column => `ST_AsWKB(${column}) as ${column}`).join(', ')}`
+      : '';
+  return `SELECT * ${exclude} ${asWKB} FROM '${tableName}';`;
+}
+
+/**
+ * Finds the names of columns that have a GEOMETRY type.
+ * @param columns An array of column descriptors from a DuckDB table.
+ * @returns An array of column names that are of type GEOMETRY.
+ */
+export function getGeometryColumns(columns: DuckDBColumnDesc[]): string[] {
+  return columns.filter(column => column.type === 'GEOMETRY').map(column => column.name);
+}
+
+/**
+ * Sets the GeoArrow WKB extension metadata for columns of type GEOMETRY in an Arrow table.
+ * @param table The Apache Arrow table whose schema fields will be modified.
+ * @param columns An array of column descriptors from a DuckDB table.
+ */
+export function setGeoArrowWKBExtension(table: arrow.Table, columns: DuckDBColumnDesc[]) {
+  table.schema.fields.forEach(field => {
+    const info = columns.find(t => t.name === field.name);
+    if (info?.type === 'GEOMETRY') {
+      field.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.WKB);
+    }
+  });
+}
+
+/**
+ * Creates an arrow table from an array of arrow vectors and fields.
+ * @param columns An array of arrow vectors.
+ * @param fields An array of fields per arrow vector.
+ * @param arrowSchema Optional arrow table schema when available.
+ * @returns An arrow table.
+ */
+export const restoreArrowTable = (
+  columns: arrow.Vector[],
+  fields: ProtoDatasetField[],
+  arrowSchema?: arrow.Schema
+) => {
+  const creaOpts = {};
+  fields.map((field, index) => {
+    creaOpts[field.name] = columns[index];
+  });
+
+  return arrowSchema ? new arrow.Table(arrowSchema, creaOpts) : new arrow.Table(creaOpts);
+};
+
+/**
+ * DuckDb throws when geoarrow extensions are present in metadata.
+ * @param table An arrow table to clear from extensions.
+ * @returns A map of removed per field geoarrow extensions.
+ */
+export const removeUnsupportedExtensions = (table: arrow.Table): Record<string, string> => {
+  const removedMetadata: Record<string, string> = {};
+  table.schema.fields.forEach(field => {
+    const extension = field.metadata.get(GEOARROW_METADATA_KEY);
+    if (extension?.startsWith('geoarrow')) {
+      removedMetadata[field.name] = extension;
+      field.metadata.delete(GEOARROW_METADATA_KEY);
+    }
+  });
+  return removedMetadata;
+};
+
+/**
+ * Restore removed metadata extensions after a call to removeUnsupportedExtensions.
+ * @param table An arrow table to restore geoarrow extensions.
+ * @param removedExtensions A map of per field geoarrow extensions to restore.
+ */
+export const restoreUnsupportedExtensions = (
+  table: arrow.Table,
+  removedExtensions: Record<string, string>
+) => {
+  table.schema.fields.forEach(field => {
+    const extension = removedExtensions[field.name];
+    if (extension) {
+      field.metadata.set(GEOARROW_METADATA_KEY, extension);
+    }
+  });
+};
 
 /** Checks whether the given Apache Arrow JS type is a Point data type */
 export function isGeoArrowPoint(type: DataType) {
@@ -104,3 +248,265 @@ export function isGeoArrowMultiPolygon(type: DataType) {
 
   return true;
 }
+
+/**
+ * Checks if the given SQL query is a SELECT query by using the EXPLAIN command.
+ * @param connection The DuckDB connection instance.
+ * @param query The SQL query to check.
+ * @returns Resolves to `true` if the query is a SELECT statement, otherwise `false`.
+ */
+export async function checkIsSelectQuery(
+  connection: AsyncDuckDBConnection,
+  query: string
+): Promise<boolean> {
+  try {
+    const result = await connection.query(`EXPLAIN (${query})`);
+    return result.numRows > 0;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Split a string with potentially multiple SQL queries (separated as usual by ';') into an array of queries.
+ * This implementation:
+ *  - Handles single and double quoted strings with proper escaping
+ *  - Ignores semicolons in line comments (--) and block comments (slash asterisk)
+ *  - Trims whitespace from queries
+ *  - Handles SQL-style escaped quotes ('' inside strings)
+ *  - Returns only non-empty queries
+ * @param input A string with potentially multiple SQL queries.
+ * @returns An array of queries.
+ */
+export function splitSqlStatements(input: string): string[] {
+  const queries: string[] = [];
+  let currentQuery = '';
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+
+    if (inLineComment) {
+      currentQuery += char;
+      if (char === '\n') {
+        inLineComment = false;
+      }
+      continue;
+    }
+
+    if (inBlockComment) {
+      currentQuery += char;
+      if (char === '*' && input[i + 1] === '/') {
+        inBlockComment = false;
+        currentQuery += input[++i]; // Consume '/'
+      }
+      continue;
+    }
+
+    if (inSingleQuote) {
+      currentQuery += char;
+      if (char === "'") {
+        // Handle escaped single quotes in SQL
+        if (i + 1 < input.length && input[i + 1] === "'") {
+          currentQuery += input[++i];
+        } else {
+          inSingleQuote = false;
+        }
+      }
+      continue;
+    }
+
+    if (inDoubleQuote) {
+      currentQuery += char;
+      if (char === '"') {
+        // Handle escaped double quotes
+        if (i + 1 < input.length && input[i + 1] === '"') {
+          currentQuery += input[++i];
+        } else {
+          inDoubleQuote = false;
+        }
+      }
+      continue;
+    }
+
+    // Check for comment starts
+    if (char === '-' && input[i + 1] === '-') {
+      inLineComment = true;
+      currentQuery += char + input[++i];
+      continue;
+    }
+
+    if (char === '/' && input[i + 1] === '*') {
+      inBlockComment = true;
+      currentQuery += char + input[++i];
+      continue;
+    }
+
+    // Check for quote starts
+    if (char === "'") {
+      inSingleQuote = true;
+      currentQuery += char;
+      continue;
+    }
+
+    if (char === '"') {
+      inDoubleQuote = true;
+      currentQuery += char;
+      continue;
+    }
+
+    // Handle query separator
+    if (char === ';') {
+      const trimmed = currentQuery.trim();
+      if (trimmed.length > 0) {
+        queries.push(trimmed);
+      }
+      currentQuery = '';
+      continue;
+    }
+
+    currentQuery += char;
+  }
+
+  // Add the final query
+  const trimmed = currentQuery.trim();
+  if (trimmed.length > 0) {
+    queries.push(trimmed);
+  }
+
+  return queries;
+}
+
+/**
+ * Removes SQL comments from a given SQL string.
+ * @param sql The SQL query string from which comments should be removed.
+ * @returns The cleaned SQL string without comments.
+ */
+export function removeSQLComments(sql: string): string {
+  // Remove multi-line comments (/* ... */)
+  sql = sql.replace(/\/\*[\s\S]*?\*\//g, '');
+  // Remove single-line comments (-- ...)
+  sql = sql.replace(/--.*$/gm, '');
+  return sql.trim();
+}
+
+/**
+ * Drops a table if it exists in the DuckDB database.
+ * @param connection The DuckDB connection instance.
+ * @param tableName The name of the table to drop.
+ * @returns A promise that resolves when the operation is complete.
+ * @throws Logs an error if the table drop operation fails.
+ */
+export const dropTableIfExists = async (connection: AsyncDuckDBConnection, tableName: string) => {
+  try {
+    await connection.query(`DROP TABLE IF EXISTS "${tableName}";`);
+  } catch (error) {
+    console.error('Dropping table failed', tableName, error);
+  }
+};
+
+/**
+ * Imports a file into DuckDB as a table, supporting multiple formats from SUPPORTED_DUCKDB_DROP_EXTENSIONS.
+ * @param file The file to be imported.
+ * @returns A promise that resolves when the file has been processed into a DuckDB table.
+ */
+export async function tableFromFile(file: File | null): Promise<null | Error> {
+  if (!file) return new Error('File Drag & Drop: No file');
+
+  const fileExt = SUPPORTED_DUCKDB_DROP_EXTENSIONS.find(ext => file.name.endsWith(ext));
+  if (!fileExt) {
+    return new Error("File Drag & Drop: File extension isn't supported");
+  }
+
+  const db = await getDuckDB();
+  const c = await db.connect();
+
+  let error: Error | null = null;
+
+  try {
+    const tableName = sanitizeDuckDBTableName(file.name);
+    const sourceName = 'temp_file_handle';
+
+    c.query(`install spatial;
+      load spatial;`);
+
+    if (fileExt === 'arrow') {
+      const arrayBuffer = await file.arrayBuffer();
+      const uint8Array = new Uint8Array(arrayBuffer);
+      const arrowTable = arrow.tableFromIPC(uint8Array);
+
+      await c.insertArrowTable(arrowTable, {name: tableName});
+    } else {
+      await db.registerFileHandle(sourceName, file, DuckDBDataProtocol.BROWSER_FILEREADER, true);
+
+      if (fileExt === 'csv') {
+        await c.query(`
+            CREATE TABLE '${tableName}' AS
+            SELECT *
+            FROM read_csv('${sourceName}', header = true, auto_detect = true, sample_size = -1);
+          `);
+      } else if (fileExt === 'json') {
+        await c.query(`
+            CREATE TABLE '${tableName}' AS
+            SELECT *
+            FROM read_json_auto('${sourceName}');
+          `);
+      } else if (fileExt === 'geojson') {
+        await c.query(`
+            CREATE TABLE '${tableName}' AS
+            SELECT *
+            FROM ST_READ('${sourceName}', keep_wkb = TRUE);
+          `);
+      } else if (fileExt === 'parquet') {
+        await c.query(`
+            CREATE TABLE '${tableName}' AS
+            SELECT *
+            FROM read_parquet('${sourceName}')
+          `);
+      }
+    }
+  } catch (errorData) {
+    if (errorData instanceof Error) {
+      const message = errorData.message || '';
+      // output more readable errors for known issues
+      if (message.includes('Arrow Type with extension name: geoarrow')) {
+        error = new Error(
+          'The GeoArrow extensions are not implemented in the connected DuckDB version.'
+        );
+      } else if (message.includes("Geoparquet column 'geometry' does not have geometry types")) {
+        error = new Error(
+          `Invalid Input Error: Geoparquet column 'geometry' does not have geometry types.
+Possible reasons:
+  - Old .parquet files that don't match the Parquet format specification.
+  - Unsupported compression.`
+        );
+      }
+    }
+
+    if (!error) {
+      error = errorData as Error;
+    }
+  }
+
+  await c.close();
+
+  return error;
+}
+
+/**
+ * Sanitizes a file name to be a valid DuckDB table name.
+ * @param fileName The input file name to be sanitized.
+ * @returns A valid DuckDB table name.
+ */
+export function sanitizeDuckDBTableName(fileName: string): string {
+  // Replace invalid characters with underscores
+  let name = fileName.replace(/[^a-zA-Z0-9_]/g, '_');
+  // Ensure it doesn't start with a digit
+  if (/^\d/.test(name)) {
+    name = `t_${name}`;
+  }
+  return name || 'default_table';
+}

package/src/duckdb/src/table/duckdb-table.ts

@@ -4,9 +4,12 @@
 import * as arrow from 'apache-arrow';
 import {AsyncDuckDB, AsyncDuckDBConnection} from '@duckdb/duckdb-wasm';
 
-import {DatasetType, DATASET_FORMATS} from '@kepler.gl/constants';
-import {KeplerTable} from '@kepler.gl/table';
-import {Field, ProtoDatasetField} from '@kepler.gl/types';
+import {
+  DatasetType,
+  DATASET_FORMATS,
+  GEOARROW_EXTENSIONS,
+  GEOARROW_METADATA_KEY
+} from '@kepler.gl/constants';
 import {
   arrowSchemaToFields,
   isArrowData,
@@ -15,6 +18,8 @@ import {
   isRowObject,
   processArrowBatches
 } from '@kepler.gl/processors';
+import {KeplerTable} from '@kepler.gl/table';
+import {Field} from '@kepler.gl/types';
 
 import {getDuckDB} from '../init';
 import {
@@ -33,6 +38,17 @@ import {
   isGeoArrowMultiPolygon
 } from './duckdb-table-utils';
 
+import {
+  constructST_asWKBQuery,
+  dropTableIfExists,
+  getDuckDBColumnTypes,
+  getDuckDBColumnTypesMap,
+  getGeometryColumns,
+  removeUnsupportedExtensions,
+  restoreArrowTable,
+  restoreUnsupportedExtensions
+} from '../table/duckdb-table-utils';
+
 // TODO use files from disk or url directly, without parsing by loaders and then ingection into DeckDb
 
 /**
@@ -52,47 +68,24 @@ const KEPLER_GEOM_FROM_GEOJSON_COLUMN = '_geojson';
  * Names of columns that most likely contain binary wkb geometry
  */
 const SUGGESTED_GEOM_COLUMNS = {
-  [KEPLER_GEOM_FROM_GEOJSON_COLUMN]: true,
-  [DUCKDB_GEOM_COLUMN]: true,
-  geometry: true
+  [KEPLER_GEOM_FROM_GEOJSON_COLUMN]: GEOARROW_EXTENSIONS.WKB,
+  [DUCKDB_GEOM_COLUMN]: GEOARROW_EXTENSIONS.WKB,
+  geometry: GEOARROW_EXTENSIONS.WKB
 };
 
 type ImportDataToDuckProps = {
-  data: ProcessorResult;
+  data: ProcessorResult & {arrowSchema: arrow.Schema};
   db: AsyncDuckDB;
   c: AsyncDuckDBConnection;
 };
 
 type ImportDataToDuckResult = {
-  // DuckDb drops geoarrow metadata, so try to preserve someting
-  addWKBMetadata?: Record<string, boolean>;
+  // DuckDb drops geoarrow metadata, so try to preserve and then restore the extension name
+  geoarrowMetadata?: Record<string, string>;
   // Use fields from arrow table even if fields are provided
   useNewFields?: boolean;
 };
 
-/**
- * Creates an arrow table from arrow vectors and fields.
- * @param columns An array of arrow vectors.
- * @param fields An array of fields per arrow vector.
- * @returns An arrow table.
- */
-// TODO: consider using original drag&dropped arrow table, as it could contain extra metadata, not passed to the fields.
-const restoreArrowTable = (columns: arrow.Vector[], fields: ProtoDatasetField[]) => {
-  const creaOpts = {};
-  fields.map((field, index) => {
-    creaOpts[field.name] = columns[index];
-  });
-  return new arrow.Table(creaOpts);
-};
-
-const dropIfTableExists = async (c: AsyncDuckDBConnection, tableName: string) => {
-  try {
-    await c.query(`DROP TABLE IF EXISTS "${tableName}";`);
-  } catch (error) {
-    console.error('Dropping table failed', tableName, error);
-  }
-};
-
 export class KeplerGlDuckDbTable extends KeplerTable {
   declare readonly id: string;
   declare label: string;
@@ -157,18 +150,23 @@ export class KeplerGlDuckDbTable extends KeplerTable {
     }
 
     return {
-      addWKBMetadata: {[KEPLER_GEOM_FROM_GEOJSON_COLUMN]: true}
+      // _geojson column is created from geometry with keep_wkb flag and contains valid WKB data.
+      geoarrowMetadata: {[KEPLER_GEOM_FROM_GEOJSON_COLUMN]: GEOARROW_EXTENSIONS.WKB}
     };
   }
 
-  async importArrowData({data, db, c}: ImportDataToDuckProps): Promise<ImportDataToDuckResult> {
+  async importArrowData({data, c}: ImportDataToDuckProps): Promise<ImportDataToDuckResult> {
+    let adjustedMetadata = {};
     try {
       // 1) data.rows contains an arrow table created by Add to Map data from DuckDb query.
       // 2) arrow table is in cols & fields when a file is dragged & dropped into Add Data To Map dialog.
       const arrowTable =
         data.rows instanceof arrow.Table
           ? data.rows
-          : restoreArrowTable(data.cols || [], data.fields);
+          : restoreArrowTable(data.cols || [], data.fields, data.arrowSchema);
+
+      // remove unsupported extensions from an arrow table that throw exceptions in DuckDB.
+      adjustedMetadata = removeUnsupportedExtensions(arrowTable);
 
       const setupSql = `
         install spatial;
@@ -176,6 +174,9 @@ export class KeplerGlDuckDbTable extends KeplerTable {
       `;
       await c.query(setupSql);
       await c.insertArrowTable(arrowTable, {name: this.label});
+
+      // restore unsupported extensions that throw exceptions in DuckDb
+      restoreUnsupportedExtensions(arrowTable, adjustedMetadata);
     } catch (error) {
       // Known issues:
       // 1) Arrow Type with extension name: geoarrow.point and format: +w:2 is not currently supported in DuckDB.
@@ -183,8 +184,8 @@ export class KeplerGlDuckDbTable extends KeplerTable {
     }
 
     return {
-      addWKBMetadata: {...SUGGESTED_GEOM_COLUMNS},
-      // use metadata from arrow table
+      geoarrowMetadata: {...SUGGESTED_GEOM_COLUMNS, ...adjustedMetadata},
+      // use fields generated from the created arrow table
       useNewFields: true
     };
   }
@@ -199,7 +200,7 @@ export class KeplerGlDuckDbTable extends KeplerTable {
     const c = await db.connect();
 
     const tableName = this.label;
-    await dropIfTableExists(c, tableName);
+    await dropTableIfExists(c, tableName);
 
     let format = this.metadata.format;
     if (!format) {
@@ -228,27 +229,26 @@ export class KeplerGlDuckDbTable extends KeplerTable {
     let cols: arrow.Vector[] = [];
 
     try {
-      const {addWKBMetadata = {}, useNewFields = false} = importDetails || {};
+      const {geoarrowMetadata = {}, useNewFields = false} = importDetails || {};
 
-      // Try to figure out whether geometry should be transformed by ST_AsWKB
-      // TODO if canCastST_asWKB contains any keys then add ST_AsWKB to the following query
-      const canCastST_asWKB = await tryST_AsWKB({tableName, c});
+      const duckDbColumns = await getDuckDBColumnTypes(c, tableName);
+      const tableDuckDBTypes = getDuckDBColumnTypesMap(duckDbColumns);
+      const columnsToConvertToWKB = getGeometryColumns(duckDbColumns);
+      const adjustedQuery = constructST_asWKBQuery(tableName, columnsToConvertToWKB);
+      const arrowResult = await c.query(adjustedQuery);
 
-      const getArrowQuery = `SELECT * FROM '${tableName}';`;
-      const arrowResult = await c.query(getArrowQuery);
+      // TODO if format is an arrow table then just use the original one, instead of the new table from the query?
 
-      restoreGeoarrowMetadata(arrowResult, canCastST_asWKB, addWKBMetadata);
+      restoreGeoarrowMetadata(arrowResult, geoarrowMetadata);
 
       fields = useNewFields
-        ? arrowSchemaToFields(arrowResult.schema)
-        : data.fields ?? arrowSchemaToFields(arrowResult.schema);
+        ? arrowSchemaToFields(arrowResult, tableDuckDBTypes)
+        : data.fields ?? arrowSchemaToFields(arrowResult, tableDuckDBTypes);
       cols = [...Array(arrowResult.numCols).keys()]
         .map(i => arrowResult.getChildAt(i))
         .filter(col => col) as arrow.Vector[];
     } catch (error) {
-      // Known issues:
-      // 1) ST_AsWKB binder error, no type match
-      console.error('DuckDb table: binary geometry column to wkb', error);
+      console.error('DuckDB table: createTableAndGetArrow', error);
     }
 
     await c.close();
@@ -285,7 +285,6 @@ export class KeplerGlDuckDbTable extends KeplerTable {
     let format;
     if (inputFormat === DATASET_FORMATS.arrow || isArrowData(data)) {
       format = DATASET_FORMATS.arrow;
-      // TODO injest arrow files from disk without loaders
       processor = processArrowBatches;
     } else if (inputFormat === DATASET_FORMATS.keplergl || isKeplerGlMap(data)) {
       format = DATASET_FORMATS.keplergl;
@@ -302,6 +301,7 @@ export class KeplerGlDuckDbTable extends KeplerTable {
   };
 
   static getInputDataValidator = function () {
+    // In DuckDB mode data is validated later during import.
     return d => d;
   };
 }
@@ -310,58 +310,27 @@ export class KeplerGlDuckDbTable extends KeplerTable {
  * Try to restore geoarrow metadata lost during DuckDb ingestion.
  * Note that this function can generate wrong geometry types.
  * @param arrowTable Arrow table to update.
- * @param canCastST_asWKB A map with fields that are likely in DeckDB's internal WBK format.
- * @param addWKBMetadata A map with field names that usually used to store WKB geometry.
+ * @param geoarrowMetadata A map with field names that usually used to store geoarrow geometry.
  */
 const restoreGeoarrowMetadata = async (
   arrowTable: arrow.Table,
-  canCastST_asWKB: Record<string, boolean>,
-  addWKBMetadata: Record<string, boolean>
+  geoarrowMetadata: Record<string, string>
 ) => {
   arrowTable.schema.fields.forEach(f => {
-    if (arrow.DataType.isBinary(f.type) && (addWKBMetadata[f.name] || canCastST_asWKB[f.name])) {
-      f.metadata.set('ARROW:extension:name', 'geoarrow.wkb');
+    if (arrow.DataType.isBinary(f.type) && geoarrowMetadata[f.name]) {
+      f.metadata.set(GEOARROW_METADATA_KEY, geoarrowMetadata[f.name]);
     } else if (isGeoArrowPoint(f.type)) {
-      f.metadata.set('ARROW:extension:name', 'geoarrow.point');
+      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.POINT);
     } else if (isGeoArrowLineString(f.type)) {
-      f.metadata.set('ARROW:extension:name', 'geoarrow.linestring');
+      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.LINESTRING);
     } else if (isGeoArrowPolygon(f.type)) {
-      f.metadata.set('ARROW:extension:name', 'geoarrow.polygon');
+      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.POLYGON);
     } else if (isGeoArrowMultiPoint(f.type)) {
-      f.metadata.set('ARROW:extension:name', 'geoarrow.multipoint');
+      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.MULTIPOINT);
     } else if (isGeoArrowMultiLineString(f.type)) {
-      f.metadata.set('ARROW:extension:name', 'geoarrow.multilinestring');
+      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.MULTILINESTRING);
     } else if (isGeoArrowMultiPolygon(f.type)) {
-      f.metadata.set('ARROW:extension:name', 'geoarrow.multipolygon');
+      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.MULTIPOLYGON);
     }
   });
 };
-
-/**
- * For all binary columns tries to transform geometry from DuckDB's internal format into proper WKB.
- * @param props
- * @returns A map of fields that should be transformed to valid WKB.
- */
-const tryST_AsWKB = async (props: {tableName: string; c: AsyncDuckDBConnection}) => {
-  const {c, tableName} = props;
-
-  const resultWithSchema = await c.query(`
-        SELECT * FROM '${tableName}' LIMIT 0;
-      `);
-  const binaryColumns = resultWithSchema.schema.fields.filter(f => arrow.DataType.isBinary(f.type));
-
-  const canCastST_asWKB: Record<string, boolean> = {};
-  for (const column of binaryColumns) {
-    try {
-      const columnName = column.name;
-      const query = `SELECT * EXCLUDE ${columnName}, ST_AsWKB(${columnName}) as ${columnName} FROM '${tableName}' LIMIT 1;`;
-      await c.query(query);
-
-      canCastST_asWKB[column.name] = true;
-    } catch (error) {
-      canCastST_asWKB[column.name] = false;
-    }
-  }
-
-  return canCastST_asWKB;
-};