duckdb 0.8.2-dev11.0 → 0.8.2-dev33.0

package/lib/duckdb.d.ts

@@ -171,6 +171,63 @@ export class Database {
   ): Promise<void>;
 }
 
+export type GenericTypeInfo = {
+  id: string,
+  sql_type: string,
+  alias?: string,
+}
+
+export type StructTypeInfo = {
+  id: "STRUCT",
+  alias?: string,
+  sql_type: string,
+  children: TypeInfoChildren,
+}
+
+export type ListTypeInfo = {
+  id: "LIST",
+  alias?: string,
+  sql_type: string,
+  child: TypeInfo,
+}
+
+export type MapTypeInfo = {
+  id: "MAP",
+  alias?: string,
+  sql_type: string,
+  key: TypeInfo,
+  value: TypeInfo,
+}
+
+export type UnionTypeInfo = {
+  id: "UNION",
+  alias?: string,
+  sql_type: string,
+  children: TypeInfoChildren,
+}
+
+export type DecimalTypeInfo = {
+  id: "DECIMAL",
+  alias?: string,
+  sql_type: string,
+  width: number,
+  scale: number,
+}
+
+export type EnumTypeInfo = {
+  id: "ENUM",
+  alias?: string,
+  sql_type: string,
+  name: string,
+  values: string[],
+}
+
+export type TypeInfoChildren = { name: string, type: TypeInfo }[];
+
+export type TypeInfo = GenericTypeInfo | StructTypeInfo | ListTypeInfo | MapTypeInfo | UnionTypeInfo | DecimalTypeInfo | EnumTypeInfo;
+
+export type ColumnInfo = { name: string, type: TypeInfo };
+
 export class Statement {
   sql: string;
 
@@ -185,6 +242,8 @@ export class Statement {
   finalize(callback?: Callback<void>): void;
 
   run(...args: [...any, Callback<void>] | any[]): Statement;
+
+  columns(): ColumnInfo[];
 }
 
 export const ERROR: number;

package/lib/duckdb.js

@@ -689,6 +689,27 @@ Statement.prototype.stream;
  */
 Statement.prototype.sql;
 
+/**
+ * @method
+ * @return {ColumnInfo[]} - Array of column names and types
+ */
+Statement.prototype.columns;
+
+/**
+ * @typedef ColumnInfo
+ * @type {object}
+ * @property {string} name - Column name
+ * @property {TypeInfo} type - Column type
+ */
+
+/**
+ * @typedef TypeInfo
+ * @type {object}
+ * @property {string} id - Type ID
+ * @property {string} [alias] - SQL type alias
+ * @property {string} sql_type - SQL type name
+ */
+
 /**
  * @typedef DuckDbError
  * @type {object}

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev11.0",
+  "version": "0.8.2-dev33.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/common/arrow/arrow_wrapper.cpp

@@ -14,12 +14,6 @@ namespace duckdb {
 
 ArrowSchemaWrapper::~ArrowSchemaWrapper() {
 	if (arrow_schema.release) {
-		for (int64_t child_idx = 0; child_idx < arrow_schema.n_children; child_idx++) {
-			auto &child = *arrow_schema.children[child_idx];
-			if (child.release) {
-				child.release(&child);
-			}
-		}
 		arrow_schema.release(&arrow_schema);
 		arrow_schema.release = nullptr;
 	}
@@ -27,12 +21,6 @@ ArrowSchemaWrapper::~ArrowSchemaWrapper() {
 
 ArrowArrayWrapper::~ArrowArrayWrapper() {
 	if (arrow_array.release) {
-		for (int64_t child_idx = 0; child_idx < arrow_array.n_children; child_idx++) {
-			auto &child = *arrow_array.children[child_idx];
-			if (child.release) {
-				child.release(&child);
-			}
-		}
 		arrow_array.release(&arrow_array);
 		arrow_array.release = nullptr;
 	}

package/src/duckdb/src/common/types/vector.cpp

@@ -855,38 +855,39 @@ void Vector::Flatten(const SelectionVector &sel, idx_t count) {
 	}
 }
 
-void Vector::ToUnifiedFormat(idx_t count, UnifiedVectorFormat &data) {
+void Vector::ToUnifiedFormat(idx_t count, UnifiedVectorFormat &format) {
 	switch (GetVectorType()) {
 	case VectorType::DICTIONARY_VECTOR: {
 		auto &sel = DictionaryVector::SelVector(*this);
+		format.owned_sel.Initialize(sel);
+		format.sel = &format.owned_sel;
+
 		auto &child = DictionaryVector::Child(*this);
 		if (child.GetVectorType() == VectorType::FLAT_VECTOR) {
-			data.sel = &sel;
-			data.data = FlatVector::GetData(child);
-			data.validity = FlatVector::Validity(child);
+			format.data = FlatVector::GetData(child);
+			format.validity = FlatVector::Validity(child);
 		} else {
-			// dictionary with non-flat child: create a new reference to the child and normalify it
+			// dictionary with non-flat child: create a new reference to the child and flatten it
 			Vector child_vector(child);
 			child_vector.Flatten(sel, count);
 			auto new_aux = make_buffer<VectorChildBuffer>(std::move(child_vector));
 
-			data.sel = &sel;
-			data.data = FlatVector::GetData(new_aux->data);
-			data.validity = FlatVector::Validity(new_aux->data);
+			format.data = FlatVector::GetData(new_aux->data);
+			format.validity = FlatVector::Validity(new_aux->data);
 			this->auxiliary = std::move(new_aux);
 		}
 		break;
 	}
 	case VectorType::CONSTANT_VECTOR:
-		data.sel = ConstantVector::ZeroSelectionVector(count, data.owned_sel);
-		data.data = ConstantVector::GetData(*this);
-		data.validity = ConstantVector::Validity(*this);
+		format.sel = ConstantVector::ZeroSelectionVector(count, format.owned_sel);
+		format.data = ConstantVector::GetData(*this);
+		format.validity = ConstantVector::Validity(*this);
 		break;
 	default:
 		Flatten(count);
-		data.sel = FlatVector::IncrementalSelectionVector();
-		data.data = FlatVector::GetData(*this);
-		data.validity = FlatVector::Validity(*this);
+		format.sel = FlatVector::IncrementalSelectionVector();
+		format.data = FlatVector::GetData(*this);
+		format.validity = FlatVector::Validity(*this);
 		break;
 	}
 }

package/src/duckdb/src/common/vector_operations/is_distinct_from.cpp

@@ -564,10 +564,12 @@ static idx_t DistinctSelectList(Vector &left, Vector &right, idx_t count, const
 	SelectionVector lcursor(count);
 	SelectionVector rcursor(count);
 
-	ListVector::GetEntry(left).Flatten(ListVector::GetListSize(left));
-	ListVector::GetEntry(right).Flatten(ListVector::GetListSize(right));
-	Vector lchild(ListVector::GetEntry(left), lcursor, count);
-	Vector rchild(ListVector::GetEntry(right), rcursor, count);
+	Vector lentry_flattened(ListVector::GetEntry(left));
+	Vector rentry_flattened(ListVector::GetEntry(right));
+	lentry_flattened.Flatten(ListVector::GetListSize(left));
+	rentry_flattened.Flatten(ListVector::GetListSize(right));
+	Vector lchild(lentry_flattened, lcursor, count);
+	Vector rchild(rentry_flattened, rcursor, count);
 
 	// To perform the positional comparison, we use a vectorisation of the following algorithm:
 	// bool CompareLists(T *left, idx_t nleft, T *right, nright) {

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev11"
+#define DUCKDB_VERSION "0.8.2-dev33"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "eefa9c9213"
+#define DUCKDB_SOURCE_ID "5e5bd3d4f7"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb_node.hpp

@@ -165,6 +165,7 @@ public:
 	Napi::Value Run(const Napi::CallbackInfo &info);
 	Napi::Value Finish(const Napi::CallbackInfo &info);
 	Napi::Value Stream(const Napi::CallbackInfo &info);
+	Napi::Value Columns(const Napi::CallbackInfo &info);
 
 public:
 	static Napi::FunctionReference constructor;

package/src/statement.cpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/helper.hpp"
 #include "duckdb/common/vector.hpp"
+#include "duckdb/common/types.hpp"
 
 using duckdb::unique_ptr;
 using duckdb::vector;
@@ -25,7 +26,8 @@ Napi::Object Statement::Init(Napi::Env env, Napi::Object exports) {
 	    DefineClass(env, "Statement",
 	                {InstanceMethod("run", &Statement::Run), InstanceMethod("all", &Statement::All),
 	                 InstanceMethod("arrowIPCAll", &Statement::ArrowIPCAll), InstanceMethod("each", &Statement::Each),
-	                 InstanceMethod("finalize", &Statement::Finish), InstanceMethod("stream", &Statement::Stream)});
+	                 InstanceMethod("finalize", &Statement::Finish), InstanceMethod("stream", &Statement::Stream),
+	                 InstanceMethod("columns", &Statement::Columns)});
 
 	constructor = Napi::Persistent(t);
 	constructor.SuppressDestruct();
@@ -503,6 +505,97 @@ Napi::Value Statement::Stream(const Napi::CallbackInfo &info) {
 	return deferred.Promise();
 }
 
+static Napi::Value TypeToObject(Napi::Env &env, const duckdb::LogicalType &type) {
+	auto obj = Napi::Object::New(env);
+
+	auto id = duckdb::LogicalTypeIdToString(type.id());
+	obj.Set("id", id);
+	obj.Set("sql_type", type.ToString());
+
+	if (type.HasAlias()) {
+		obj.Set("alias", type.GetAlias());
+	}
+
+	switch (type.id()) {
+	case duckdb::LogicalTypeId::STRUCT: {
+		auto &child_types = duckdb::StructType::GetChildTypes(type);
+		auto arr = Napi::Array::New(env, child_types.size());
+		for (size_t i = 0; i < child_types.size(); i++) {
+			auto child_name = child_types[i].first;
+			auto child_type = child_types[i].second;
+			auto child_obj = Napi::Object::New(env);
+			child_obj.Set("name", child_name);
+			child_obj.Set("type", TypeToObject(env, child_type));
+			arr.Set(i, child_obj);
+		}
+		obj.Set("children", arr);
+	} break;
+	case duckdb::LogicalTypeId::LIST: {
+		auto &child_type = duckdb::ListType::GetChildType(type);
+		obj.Set("child", TypeToObject(env, child_type));
+	} break;
+	case duckdb::LogicalTypeId::MAP: {
+		auto &key_type = duckdb::MapType::KeyType(type);
+		auto &value_type = duckdb::MapType::ValueType(type);
+		obj.Set("key", TypeToObject(env, key_type));
+		obj.Set("value", TypeToObject(env, value_type));
+	} break;
+	case duckdb::LogicalTypeId::ENUM: {
+		auto name = duckdb::EnumType::GetTypeName(type);
+		auto &values_vec = duckdb::EnumType::GetValuesInsertOrder(type);
+		auto enum_size = duckdb::EnumType::GetSize(type);
+		auto arr = Napi::Array::New(env, enum_size);
+		for (size_t i = 0; i < enum_size; i++) {
+			auto child_name = values_vec.GetValue(i).GetValue<duckdb::string>();
+			arr.Set(i, child_name);
+		}
+		obj.Set("name", name);
+		obj.Set("values", arr);
+	} break;
+	case duckdb::LogicalTypeId::UNION: {
+		auto child_count = duckdb::UnionType::GetMemberCount(type);
+		auto arr = Napi::Array::New(env, child_count);
+		for (size_t i = 0; i < child_count; i++) {
+			auto &child_name = duckdb::UnionType::GetMemberName(type, i);
+			auto &child_type = duckdb::UnionType::GetMemberType(type, i);
+			auto child_obj = Napi::Object::New(env);
+			child_obj.Set("name", child_name);
+			child_obj.Set("type", TypeToObject(env, child_type));
+			arr.Set(i, child_obj);
+		}
+		obj.Set("children", arr);
+	} break;
+	case duckdb::LogicalTypeId::DECIMAL: {
+		auto width = duckdb::DecimalType::GetWidth(type);
+		auto scale = duckdb::DecimalType::GetScale(type);
+		obj.Set("width", width);
+		obj.Set("scale", scale);
+	} break;
+	default:
+		break;
+	}
+	return obj;
+}
+
+Napi::Value Statement::Columns(const Napi::CallbackInfo &info) {
+	Napi::Env env = info.Env();
+
+	if (!statement) {
+		return env.Null();
+	}
+
+	auto &names = statement->GetNames();
+	auto &types = statement->GetTypes();
+	auto arr = Napi::Array::New(env, names.size());
+	for (size_t i = 0; i < names.size(); i++) {
+		auto obj = Napi::Object::New(env);
+		obj.Set("name", Napi::String::New(env, names[i]));
+		obj.Set("type", TypeToObject(env, types[i]));
+		arr.Set(i, obj);
+	}
+	return arr;
+}
+
 struct FinishTask : public Task {
 	FinishTask(Statement &statement, Napi::Function callback) : Task(statement, callback) {
 	}

package/test/columns.test.ts

@@ -0,0 +1,243 @@
+import * as duckdb from '..';
+import * as assert from 'assert';
+
+describe('Column Types', function() {
+    let db: duckdb.Database;
+    before(function(done) { db = new duckdb.Database(':memory:', done); });
+
+    it('should prepare a statement and return the columns and their types', function(done) {
+      // we dont include the large_enum and small_enum since they are huge and test the same code path as the small_enum
+      var stmt = db.prepare("SELECT * EXCLUDE(medium_enum, large_enum) FROM test_all_types()", function(err: null | Error) {
+          if (err) throw err;
+
+          let cols = stmt.columns();
+          
+          assert.equal(cols.length, 41);
+
+          var expected = [
+            { name: 'bool', type: { id: 'BOOLEAN',  sql_type: 'BOOLEAN' } },
+            { name: 'tinyint', type: { id: 'TINYINT', sql_type: 'TINYINT' } },
+            { name: 'smallint', type: { id: 'SMALLINT', sql_type: 'SMALLINT' } },
+            { name: 'int', type: { id: 'INTEGER', sql_type: 'INTEGER' } },
+            { name: 'bigint', type: { id: 'BIGINT', sql_type: 'BIGINT' } },
+            { name: 'hugeint', type: { id: 'HUGEINT', sql_type: 'HUGEINT' } },
+            { name: 'utinyint', type: { id: 'UTINYINT', sql_type: 'UTINYINT' } },
+            { name: 'usmallint', type: { id: 'USMALLINT', sql_type: 'USMALLINT' } },
+            { name: 'uint', type: { id: 'UINTEGER', sql_type: 'UINTEGER' } },
+            { name: 'ubigint', type: { id: 'UBIGINT', sql_type: 'UBIGINT' } },
+            { name: 'date', type: { id: 'DATE', sql_type: 'DATE' } },
+            { name: 'time', type: { id: 'TIME', sql_type: 'TIME' } },
+            { name: 'timestamp', type: { id: 'TIMESTAMP', sql_type: 'TIMESTAMP' } },
+            { name: 'timestamp_s', type: { id: 'TIMESTAMP_S', sql_type: 'TIMESTAMP_S' } },
+            { name: 'timestamp_ms', type: { id: 'TIMESTAMP_MS', sql_type: 'TIMESTAMP_MS' } },
+            { name: 'timestamp_ns', type: { id: 'TIMESTAMP_NS', sql_type: 'TIMESTAMP_NS' } },
+            { name: 'time_tz', type: { id: 'TIME WITH TIME ZONE', sql_type: 'TIME WITH TIME ZONE' } },
+            { name: 'timestamp_tz', type: { id: 'TIMESTAMP WITH TIME ZONE', sql_type: 'TIMESTAMP WITH TIME ZONE' } },
+            { name: 'float', type: { id: 'FLOAT', sql_type: 'FLOAT' } },
+            { name: 'double', type: { id: 'DOUBLE', sql_type: 'DOUBLE' } },
+            { name: 'dec_4_1', type: { id: 'DECIMAL', sql_type: 'DECIMAL(4,1)', width: 4, scale: 1 } },
+            { name: 'dec_9_4', type: { id: 'DECIMAL', sql_type: 'DECIMAL(9,4)', width: 9, scale: 4 } },
+            { name: 'dec_18_6', type: { id: 'DECIMAL', sql_type: 'DECIMAL(18,6)', width: 18, scale: 6 } },
+            { name: 'dec38_10', type: { id: 'DECIMAL', sql_type: 'DECIMAL(38,10)', width: 38, scale: 10 } },
+            { name: 'uuid', type: { id: 'UUID', sql_type: 'UUID' } },
+            { name: 'interval', type: { id: 'INTERVAL', sql_type: 'INTERVAL' } },
+            { name: 'varchar', type: { id: 'VARCHAR', sql_type: 'VARCHAR' } },
+            { name: 'blob', type: { id: 'BLOB', sql_type: 'BLOB' } },
+            { name: 'bit', type: { id: 'BIT', sql_type: 'BIT' } },
+            {
+              name: 'small_enum',
+              type: {
+                id: 'ENUM',
+                sql_type: 'small_enum',
+                name: 'small_enum',
+                values: [
+                  "DUCK_DUCK_ENUM",
+                  "GOOSE"
+                ]
+              }
+            },
+            {
+              name: 'int_array',
+              type: { 
+                id: 'LIST', 
+                sql_type: 'INTEGER[]', 
+                child: {
+                  id: 'INTEGER',
+                  sql_type: 'INTEGER'
+                } 
+              }
+            },
+            {
+              name: 'double_array',
+              type: { 
+                id: 'LIST', 
+                sql_type: 'DOUBLE[]', 
+                child: {
+                  id: 'DOUBLE',
+                  sql_type: 'DOUBLE'
+                } 
+              }
+            },
+            {
+              name: 'date_array',
+              type: { 
+                id: 'LIST', 
+                sql_type: 'DATE[]', 
+                child: {
+                  id: 'DATE',
+                  sql_type: 'DATE'
+                } 
+              }
+            },
+            {
+              name: 'timestamp_array',
+              type: { 
+                id: 'LIST', 
+                sql_type: 'TIMESTAMP[]', 
+                child: {
+                  id: 'TIMESTAMP',
+                  sql_type: 'TIMESTAMP'
+                } 
+              }
+            },
+            {
+              name: 'timestamptz_array',
+              type: {
+                id: 'LIST',
+                sql_type: 'TIMESTAMP WITH TIME ZONE[]',
+                child: {
+                  id: 'TIMESTAMP WITH TIME ZONE',
+                  sql_type: 'TIMESTAMP WITH TIME ZONE'
+                }
+              }
+            },
+            {
+              name: 'varchar_array',
+              type: { 
+                id: 'LIST', 
+                sql_type: 'VARCHAR[]', 
+                child: {
+                  id: 'VARCHAR',
+                  sql_type: 'VARCHAR'
+                }
+              }  
+            },
+            {
+              name: 'nested_int_array',
+              type: { 
+                id: 'LIST', 
+                sql_type: 'INTEGER[][]', 
+                child: {
+                  id: 'LIST',
+                  sql_type: 'INTEGER[]',
+                  child: {
+                    id: 'INTEGER',
+                    sql_type: 'INTEGER'
+                  }
+                } 
+              }
+            },
+            {
+              name: 'struct',
+              type: {
+                id: 'STRUCT',
+                sql_type: 'STRUCT(a INTEGER, b VARCHAR)',
+                children: [
+                  { 
+                    name: 'a',
+                    type: {
+                      id: 'INTEGER',
+                      sql_type: 'INTEGER'
+                    }
+                  },
+                  {
+                    name: 'b',
+                    type: {
+                      id: 'VARCHAR',
+                      sql_type: 'VARCHAR'
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              name: 'struct_of_arrays',
+              type: {
+                id: 'STRUCT',
+                sql_type: 'STRUCT(a INTEGER[], b VARCHAR[])',
+                children: [
+                  {
+                    name: 'a',
+                    type: {
+                      id: 'LIST',
+                      sql_type: 'INTEGER[]',
+                      child: {
+                        id: 'INTEGER',
+                        sql_type: 'INTEGER'
+                      }
+                    }
+                  },
+                  {
+                    name: 'b',
+                    type: {
+                      id: 'LIST',
+                      sql_type: 'VARCHAR[]',
+                      child: {
+                        id: 'VARCHAR',
+                        sql_type: 'VARCHAR'
+                      }
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              name: 'array_of_structs',
+              type: {
+                id: 'LIST',
+                sql_type: 'STRUCT(a INTEGER, b VARCHAR)[]',
+                child: {
+                  id: 'STRUCT',
+                  sql_type: 'STRUCT(a INTEGER, b VARCHAR)',
+                  children: [
+                    {
+                      name: 'a',
+                      type: {
+                        id: 'INTEGER',
+                        sql_type: 'INTEGER'
+                      }
+                    },
+                    {
+                      name: 'b',
+                      type: {
+                        id: 'VARCHAR',
+                        sql_type: 'VARCHAR'
+                      }
+                    }
+                  ]
+                }
+              }
+            },
+            {
+              name: 'map',
+              type: {
+                id: 'MAP',
+                sql_type: 'MAP(VARCHAR, VARCHAR)',
+                key: {
+                  id: 'VARCHAR',
+                  sql_type: 'VARCHAR'
+                },
+                value: {
+                  id: 'VARCHAR',
+                  sql_type: 'VARCHAR'
+                }
+              }
+            }
+        ]
+
+        assert.deepEqual(cols, expected);
+
+      });
+      stmt.finalize(done);
+  });
+});