@duckdb/react-duckdb 1.13.1-dev267.0 → 1.13.1-dev282.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@duckdb/react-duckdb",
-    "version": "1.13.1-dev267.0",
+    "version": "1.13.1-dev282.0",
     "description": "React components for DuckDB-Wasm",
     "license": "MPL-2.0",
     "repository": {

package/src/index.ts

@@ -1,7 +1,4 @@
 export * from './connection_provider';
 export * from './database_provider';
 export * from './platform_provider';
-export * from './table_schema';
-export * from './table_schema_provider';
-export * from './epoch_contexts';
 export * from './resolvable';

package/src/epoch_contexts.tsx

@@ -1,7 +0,0 @@
-import React from 'react';
-
-export const TABLE_SCHEMA_EPOCH = React.createContext<number | null>(null);
-export const useTableSchemaEpoch = (): number | null => React.useContext(TABLE_SCHEMA_EPOCH);
-
-export const TABLE_DATA_EPOCH = React.createContext<number | null>(null);
-export const useTableDataEpoch = (): number | null => React.useContext(TABLE_DATA_EPOCH);

package/src/table_schema.ts

@@ -1,117 +0,0 @@
-import * as arrow from 'apache-arrow';
-import * as duckdb from '@duckdb/duckdb-wasm';
-
-/// A column group
-export interface TableSchemaColumnGroup {
-    /// The group title
-    title: string;
-    /// The begin of the column span
-    spanBegin: number;
-    /// The size of the column span
-    spanSize: number;
-}
-
-/// A table metadatStorea
-export interface TableSchema {
-    /// The table schema
-    readonly tableSchema: string;
-    /// The table name
-    readonly tableName: string;
-
-    /// The column names
-    readonly columnNames: string[];
-    /// The column name indices
-    readonly columnNameMapping: Map<string, number>;
-    /// The column types
-    readonly columnTypes: arrow.DataType[];
-    /// The number of data columns.
-    /// Allows to append compute metadata columns that are not rendered in the table viewer.
-    readonly dataColumns: number;
-
-    /// The column aliases (if any)
-    readonly columnAliases: (string | null)[];
-    /// The column grouping sets (if any)
-    readonly columnGroupingSets: TableSchemaColumnGroup[][];
-    /// The row grouping sets (if any)
-    readonly rowGroupingSets: number[][];
-}
-
-/// Get raw qualified name
-export function getQualifiedNameRaw(schema: string, name: string) {
-    return `${schema || 'main'}.${name}`;
-}
-/// Get qualified name
-export function getQualifiedName(table: TableSchema) {
-    return `${table.tableSchema}.${table.tableName}`;
-}
-
-/// Collect table info
-export async function collectTableSchema(
-    conn: duckdb.AsyncDuckDBConnection,
-    info: Partial<TableSchema> & { tableSchema?: string; tableName: string },
-): Promise<TableSchema> {
-    // Use DESCRIBE to find all column types
-    const columnNames: string[] = [];
-    const columnNameMapping: Map<string, number> = new Map();
-    const columnTypes: arrow.DataType[] = [];
-    const describe = await conn.query<{ Field: arrow.Utf8; Type: arrow.Utf8 }>(
-        `DESCRIBE ${info.tableSchema || 'main'}.${info.tableName}`,
-    );
-    let column = 0;
-    for (const row of describe) {
-        columnNames.push(row!.Field!);
-        columnNameMapping.set(row!.Field!, column++);
-        const mapType = (type: string): arrow.DataType => {
-            switch (type) {
-                case 'BOOLEAN':
-                    return new arrow.Bool();
-                case 'TINYINT':
-                    return new arrow.Int8();
-                case 'SMALLINT':
-                    return new arrow.Int16();
-                case 'INTEGER':
-                    return new arrow.Int32();
-                case 'BIGINT':
-                    return new arrow.Int64();
-                case 'UTINYINT':
-                    return new arrow.Uint8();
-                case 'USMALLINT':
-                    return new arrow.Uint16();
-                case 'UINTEGER':
-                    return new arrow.Uint32();
-                case 'UBIGINT':
-                    return new arrow.Uint64();
-                case 'FLOAT':
-                    return new arrow.Float32();
-                case 'HUGEINT':
-                    return new arrow.Decimal(32, 0);
-                case 'DOUBLE':
-                    return new arrow.Float64();
-                case 'VARCHAR':
-                    return new arrow.Utf8();
-                case 'DATE':
-                    return new arrow.DateDay();
-                case 'TIME':
-                    return new arrow.Time(arrow.TimeUnit.MILLISECOND, 32);
-                case 'TIMESTAMP':
-                    return new arrow.TimeNanosecond();
-                default:
-                    return new arrow.Null();
-            }
-        };
-        columnTypes.push(mapType(row!.Type!));
-    }
-    const table: TableSchema = {
-        ...info,
-        tableSchema: info.tableSchema || 'main',
-        columnNames,
-        columnTypes,
-        dataColumns: columnTypes.length,
-        columnNameMapping,
-        columnAliases: [],
-        columnGroupingSets: [],
-        rowGroupingSets: [],
-    };
-
-    return table;
-}

package/src/table_schema_provider.tsx

@@ -1,70 +0,0 @@
-import * as React from 'react';
-import { TableSchema, collectTableSchema } from './table_schema';
-import { useTableSchemaEpoch } from './epoch_contexts';
-import { useDuckDBConnection } from './connection_provider';
-
-interface Props {
-    /// The children
-    children: React.ReactElement | React.ReactElement[];
-    /// The schema
-    schema?: string;
-    /// The name
-    name: string;
-}
-
-interface State {
-    /// The schema
-    schema: string | null;
-    /// The name
-    name: string | null;
-    /// The metadata
-    metadata: TableSchema | null;
-    /// The own epoch
-    ownEpoch: number | null;
-}
-
-export const TABLE_METADATA = React.createContext<TableSchema | null>(null);
-export const useTableSchema = (): TableSchema | null => React.useContext(TABLE_METADATA);
-
-export const DuckDBTableSchemaProvider: React.FC<Props> = (props: Props) => {
-    const conn = useDuckDBConnection();
-    const epoch = useTableSchemaEpoch();
-    const [state, setState] = React.useState<State>({
-        schema: null,
-        name: null,
-        ownEpoch: epoch,
-        metadata: null,
-    });
-    const inFlight = React.useRef<boolean>(false);
-
-    // Detect unmount
-    const isMounted = React.useRef(true);
-    React.useEffect(() => {
-        return () => void (isMounted.current = false);
-    }, []);
-
-    // Resolve the metadata
-    React.useEffect(() => {
-        if (!isMounted.current || !conn || inFlight.current) {
-            return;
-        }
-        inFlight.current = true;
-        const resolve = async (schema: string, name: string, epoch: number | null) => {
-            const metadata = await collectTableSchema(conn!, {
-                tableSchema: schema,
-                tableName: name,
-            });
-            inFlight.current = false;
-            if (!isMounted.current) return;
-            setState({
-                schema,
-                name,
-                ownEpoch: epoch,
-                metadata,
-            });
-        };
-        resolve(props.schema || 'main', props.name, epoch).catch(e => console.error(e));
-    }, [conn, props.schema, props.name, epoch]);
-
-    return <TABLE_METADATA.Provider value={state.metadata}>{props.children}</TABLE_METADATA.Provider>;
-};