generate typescript definitions

api/src/DuckDBAppender.ts

@@ -0,0 +1,18 @@
+import * as ddb from '../..';
+import { throwOnFailure } from './throwOnFailure';
+
+export class DuckDBAppender {
+  private readonly appender: ddb.duckdb_appender;
+  constructor(appender: ddb.duckdb_appender) {
+    this.appender = appender;
+  }
+  public async dispose() {
+    throwOnFailure(await ddb.duckdb_appender_destroy(this.appender),
+      'Failed to destroy appender', () => ddb.duckdb_appender_error(this.appender));
+  }
+  public async flush() {
+    throwOnFailure(await ddb.duckdb_appender_flush(this.appender),
+      'Failed to flush appender', () => ddb.duckdb_appender_error(this.appender));
+  }
+  // TODO
+}

api/src/DuckDBConnection.ts

@@ -0,0 +1,63 @@
+import * as ddb from '../..';
+import { DuckDBAppender } from './DuckDBAppender';
+import { DuckDBExtractedStatements } from './DuckDBExtractedStatements';
+import { DuckDBInstance } from './DuckDBInstance';
+import { DuckDBPreparedStatement } from './DuckDBPreparedStatement';
+import { DuckDBMaterializedResult } from './DuckDBResult';
+import { throwOnFailure } from './throwOnFailure';
+
+export class DuckDBConnection {
+  private readonly connection: ddb.duckdb_connection;
+  constructor(connection: ddb.duckdb_connection) {
+    this.connection = connection;
+  }
+  public static async create(instance: DuckDBInstance): Promise<DuckDBConnection> {
+    return instance.connect();
+  }
+  public dispose(): Promise<void> {
+    return ddb.duckdb_disconnect(this.connection);
+  }
+  public interrupt() {
+    ddb.duckdb_interrupt(this.connection);
+  }
+  /** Returns -1 if no progress or a percentage of the progress. */
+  public get progress(): number {
+    return ddb.duckdb_query_progress(this.connection);
+  }
+  public get finished(): boolean {
+    return ddb.duckdb_execution_is_finished(this.connection);
+  }
+  public async run(sql: string): Promise<DuckDBMaterializedResult> {
+    const result = new ddb.duckdb_result;
+    throwOnFailure(await ddb.duckdb_query(this.connection, sql, result),
+      'Failed to query', () => ddb.duckdb_result_error(result),
+      () => ddb.duckdb_destroy_result(result));
+    return new DuckDBMaterializedResult(result);
+  }
+  public async prepare(sql: string): Promise<DuckDBPreparedStatement> {
+    const prepared_statement = new ddb.duckdb_prepared_statement;
+    throwOnFailure(await ddb.duckdb_prepare(this.connection, sql, prepared_statement),
+      'Failed to prepare', () => ddb.duckdb_prepare_error(prepared_statement),
+      () => ddb.duckdb_destroy_prepare(prepared_statement));
+    return new DuckDBPreparedStatement(prepared_statement);
+  }
+  public async extractStatements(sql: string): Promise<DuckDBExtractedStatements> {
+    const extracted_statements = new ddb.duckdb_extracted_statements;
+    const statementCount = await ddb.duckdb_extract_statements(this.connection, sql, extracted_statements);
+    if (statementCount === 0) {
+      try {
+        throw new Error(`Failed to extract statements: ${ddb.duckdb_extract_statements_error(extracted_statements)}`);
+      } finally {
+        ddb.duckdb_destroy_extracted(extracted_statements);
+      }
+    }
+    return new DuckDBExtractedStatements(this.connection, extracted_statements, statementCount);
+  }
+  public async createAppender(schema: string, table: string): Promise<DuckDBAppender> {
+    const appender = new ddb.duckdb_appender;
+    throwOnFailure(await ddb.duckdb_appender_create(this.connection, schema, table, appender),
+      'Failed to create appender', () => ddb.duckdb_appender_error(appender),
+      () => ddb.duckdb_appender_destroy(appender));
+    return new DuckDBAppender(appender);
+  }
+}

api/src/DuckDBDataChunk.ts

@@ -0,0 +1,32 @@
+import * as ddb from '../..';
+import { DuckDBVector } from './DuckDBVector';
+
+export class DuckDBDataChunk {
+  private readonly chunk: ddb.duckdb_data_chunk;
+  constructor(chunk: ddb.duckdb_data_chunk) {
+    this.chunk = chunk;
+  }
+  public static create(): DuckDBDataChunk {
+    // TODO: C API takes raw pointer (list of types)
+    throw new Error('not implemented');
+  }
+  public dispose() {
+    ddb.duckdb_destroy_data_chunk(this.chunk);
+  }
+  public reset() {
+    ddb.duckdb_data_chunk_reset(this.chunk);
+  }
+  public get columnCount(): number {
+    return ddb.duckdb_data_chunk_get_column_count(this.chunk);
+  }
+  public getColumn(columnIndex: number): DuckDBVector<any> {
+    // TODO: cache vectors?
+    return DuckDBVector.create(ddb.duckdb_data_chunk_get_vector(this.chunk, columnIndex), this.rowCount);
+  }
+  public get rowCount(): number {
+    return ddb.duckdb_data_chunk_get_size(this.chunk);
+  }
+  public set rowCount(count: number) {
+    ddb.duckdb_data_chunk_set_size(this.chunk, count);
+  }
+}

api/src/DuckDBExtractedStatements.ts

@@ -0,0 +1,28 @@
+import * as ddb from '../..';
+import { DuckDBPreparedStatement } from './DuckDBPreparedStatement';
+import { throwOnFailure } from './throwOnFailure';
+
+export class DuckDBExtractedStatements {
+  private readonly connection: ddb.duckdb_connection;
+  private readonly extracted_statements: ddb.duckdb_extracted_statements;
+  private readonly statementCount: number;
+  constructor(connection: ddb.duckdb_connection, extracted_statements: ddb.duckdb_extracted_statements, statementCount: number) {
+    this.connection = connection;
+    this.extracted_statements = extracted_statements;
+    this.statementCount = statementCount;
+  }
+  public dispose() {
+    ddb.duckdb_destroy_extracted(this.extracted_statements);
+  }
+  public get count(): number {
+    return this.statementCount;
+  }
+  public async prepare(index: number): Promise<DuckDBPreparedStatement> {
+    const prepared_statement = new ddb.duckdb_prepared_statement;
+    throwOnFailure(await ddb.duckdb_prepare_extracted_statement(this.connection, this.extracted_statements, index, prepared_statement),
+      'Failed to prepare extracted statement', () => ddb.duckdb_prepare_error(prepared_statement),
+      () => ddb.duckdb_destroy_prepare(prepared_statement));
+    return new DuckDBPreparedStatement(prepared_statement);
+  }
+  // TODO
+}

api/src/DuckDBInstance.ts

@@ -0,0 +1,40 @@
+import * as ddb from '../..';
+import { DuckDBConnection } from './DuckDBConnection';
+import { throwOnFailure } from './throwOnFailure';
+
+export class DuckDBInstance {
+  private readonly db: ddb.duckdb_database;
+  constructor(db: ddb.duckdb_database) {
+    this.db = db;
+  }
+  public static async create(path: string = ':memory:', options?: Record<string, string>): Promise<DuckDBInstance> {
+    const db = new ddb.duckdb_database;
+    if (options) {
+      const config = new ddb.duckdb_config;
+      throwOnFailure(ddb.duckdb_create_config(config),
+        'Failed to create config', undefined,
+        () => ddb.duckdb_destroy_config(config));
+      for (const optionName in options) {
+        const optionValue = options[optionName];
+        throwOnFailure(ddb.duckdb_set_config(config, optionName, optionValue),
+          'Failed to set config option', () => optionName,
+          () => ddb.duckdb_destroy_config(config));
+      }
+      const errorWrapper = new ddb.out_string_wrapper;
+      throwOnFailure(await ddb.duckdb_open_ext(path, db, config, errorWrapper),
+        'Failed to open', () => ddb.out_get_string(errorWrapper),
+        () => ddb.duckdb_destroy_config(config));      
+    } else {
+      throwOnFailure(await ddb.duckdb_open(path, db), 'Failed to open');
+    }
+    return new DuckDBInstance(db);
+  }
+  public dispose(): Promise<void> {
+    return ddb.duckdb_close(this.db);
+  }
+  public async connect(): Promise<DuckDBConnection> {
+    const connection = new ddb.duckdb_connection;
+    throwOnFailure(await ddb.duckdb_connect(this.db, connection), 'Failed to connect');
+    return new DuckDBConnection(connection);
+  }
+}