duckdb 0.8.2-dev15.0 → 0.8.2-dev157.0

package/binding.gyp

@@ -237,18 +237,18 @@
                 "src/duckdb/third_party/zstd/compress/zstd_lazy.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
-                "src/duckdb/extension/icu/./icu_extension.cpp", 
-                "src/duckdb/extension/icu/./icu-list-range.cpp", 
-                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
                 "src/duckdb/extension/icu/./icu-datepart.cpp", 
-                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
+                "src/duckdb/extension/icu/./icu-timezone.cpp", 
+                "src/duckdb/extension/icu/./icu-makedate.cpp", 
                 "src/duckdb/extension/icu/./icu-table-range.cpp", 
+                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
+                "src/duckdb/extension/icu/./icu-list-range.cpp", 
                 "src/duckdb/extension/icu/./icu-dateadd.cpp", 
-                "src/duckdb/extension/icu/./icu-strptime.cpp", 
                 "src/duckdb/extension/icu/./icu-datesub.cpp", 
-                "src/duckdb/extension/icu/./icu-makedate.cpp", 
-                "src/duckdb/extension/icu/./icu-timezone.cpp", 
                 "src/duckdb/extension/icu/./icu-timebucket.cpp", 
+                "src/duckdb/extension/icu/./icu-strptime.cpp", 
+                "src/duckdb/extension/icu/./icu_extension.cpp", 
+                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_common.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp", 
                 "src/duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp", 

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-dev15.0",
+  "version": "0.8.2-dev157.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/icu/icu_extension.cpp

@@ -65,17 +65,15 @@ struct IcuBindData : public FunctionData {
 
 static int32_t ICUGetSortKey(icu::Collator &collator, string_t input, duckdb::unique_ptr<char[]> &buffer,
                              int32_t &buffer_size) {
-	int32_t string_size =
-	    collator.getSortKey(icu::UnicodeString::fromUTF8(icu::StringPiece(input.GetData(), input.GetSize())),
-	                        (uint8_t *)buffer.get(), buffer_size);
+	icu::UnicodeString unicode_string =
+	    icu::UnicodeString::fromUTF8(icu::StringPiece(input.GetData(), input.GetSize()));
+	int32_t string_size = collator.getSortKey(unicode_string, (uint8_t *)buffer.get(), buffer_size);
 	if (string_size > buffer_size) {
 		// have to resize the buffer
 		buffer_size = string_size;
 		buffer = duckdb::unique_ptr<char[]>(new char[buffer_size]);
 
-		string_size =
-		    collator.getSortKey(icu::UnicodeString::fromUTF8(icu::StringPiece(input.GetData(), input.GetSize())),
-		                        (uint8_t *)buffer.get(), buffer_size);
+		string_size = collator.getSortKey(unicode_string, (uint8_t *)buffer.get(), buffer_size);
 	}
 	return string_size;
 }

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/execution/operator/persistent/physical_batch_insert.cpp

@@ -327,10 +327,11 @@ SinkResultType PhysicalBatchInsert::Sink(ExecutionContext &context, DataChunk &c
 		// no collection yet: create a new one
 		lstate.CreateNewCollection(table, insert_types);
 		lstate.writer = &table.GetStorage().CreateOptimisticWriter(context.client);
-	} else if (lstate.current_index != batch_index) {
+	}
+
+	if (lstate.current_index != batch_index) {
 		throw InternalException("Current batch differs from batch - but NextBatch was not called!?");
 	}
-	lstate.current_index = batch_index;
 
 	table.GetStorage().VerifyAppendConstraints(table, context.client, lstate.insert_chunk);
 

package/src/duckdb/src/execution/physical_operator.cpp

@@ -124,6 +124,22 @@ idx_t PhysicalOperator::GetMaxThreadMemory(ClientContext &context) {
 	return (max_memory / num_threads) / 4;
 }
 
+bool PhysicalOperator::OperatorCachingAllowed(ExecutionContext &context) {
+	if (!context.client.config.enable_caching_operators) {
+		return false;
+	} else if (!context.pipeline) {
+		return false;
+	} else if (!context.pipeline->GetSink()) {
+		return false;
+	} else if (context.pipeline->GetSink()->RequiresBatchIndex()) {
+		return false;
+	} else if (context.pipeline->IsOrderDependent()) {
+		return false;
+	}
+
+	return true;
+}
+
 //===--------------------------------------------------------------------===//
 // Pipeline Construction
 //===--------------------------------------------------------------------===//
@@ -239,20 +255,7 @@ OperatorResultType CachingPhysicalOperator::Execute(ExecutionContext &context, D
 #if STANDARD_VECTOR_SIZE >= 128
 	if (!state.initialized) {
 		state.initialized = true;
-		state.can_cache_chunk = true;
-
-		if (!context.client.config.enable_caching_operators) {
-			state.can_cache_chunk = false;
-		} else if (!context.pipeline || !caching_supported) {
-			state.can_cache_chunk = false;
-		} else if (!context.pipeline->GetSink()) {
-			// Disabling for pipelines without Sink, i.e. when pulling
-			state.can_cache_chunk = false;
-		} else if (context.pipeline->GetSink()->RequiresBatchIndex()) {
-			state.can_cache_chunk = false;
-		} else if (context.pipeline->IsOrderDependent()) {
-			state.can_cache_chunk = false;
-		}
+		state.can_cache_chunk = caching_supported && PhysicalOperator::OperatorCachingAllowed(context);
 	}
 	if (!state.can_cache_chunk) {
 		return child_result;

package/src/duckdb/src/function/table/system/test_all_types.cpp

@@ -17,7 +17,7 @@ struct TestAllTypesData : public GlobalTableFunctionState {
 	idx_t offset;
 };
 
-vector<TestType> TestAllTypesFun::GetTestTypes() {
+vector<TestType> TestAllTypesFun::GetTestTypes(bool use_large_enum) {
 	vector<TestType> result;
 	// scalar types/numerics
 	result.emplace_back(LogicalType::BOOLEAN, "bool");
@@ -79,13 +79,21 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 	}
 	result.emplace_back(LogicalType::ENUM("medium_enum", medium_enum, 300), "medium_enum");
 
-	// this is a big one... not sure if we should push this one here, but it's required for completeness
-	Vector large_enum(LogicalType::VARCHAR, 70000);
-	auto large_enum_ptr = FlatVector::GetData<string_t>(large_enum);
-	for (idx_t i = 0; i < 70000; i++) {
-		large_enum_ptr[i] = StringVector::AddStringOrBlob(large_enum, string("enum_") + to_string(i));
+	if (use_large_enum) {
+		// this is a big one... not sure if we should push this one here, but it's required for completeness
+		Vector large_enum(LogicalType::VARCHAR, 70000);
+		auto large_enum_ptr = FlatVector::GetData<string_t>(large_enum);
+		for (idx_t i = 0; i < 70000; i++) {
+			large_enum_ptr[i] = StringVector::AddStringOrBlob(large_enum, string("enum_") + to_string(i));
+		}
+		result.emplace_back(LogicalType::ENUM("large_enum", large_enum, 70000), "large_enum");
+	} else {
+		Vector large_enum(LogicalType::VARCHAR, 2);
+		auto large_enum_ptr = FlatVector::GetData<string_t>(large_enum);
+		large_enum_ptr[0] = StringVector::AddStringOrBlob(large_enum, string("enum_") + to_string(0));
+		large_enum_ptr[1] = StringVector::AddStringOrBlob(large_enum, string("enum_") + to_string(69999));
+		result.emplace_back(LogicalType::ENUM("large_enum", large_enum, 2), "large_enum");
 	}
-	result.emplace_back(LogicalType::ENUM("large_enum", large_enum, 70000), "large_enum");
 
 	// arrays
 	auto int_list_type = LogicalType::LIST(LogicalType::INTEGER);
@@ -199,26 +207,36 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 	return result;
 }
 
+struct TestAllTypesBindData : public TableFunctionData {
+	vector<TestType> test_types;
+};
+
 static unique_ptr<FunctionData> TestAllTypesBind(ClientContext &context, TableFunctionBindInput &input,
                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	auto test_types = TestAllTypesFun::GetTestTypes();
-	for (auto &test_type : test_types) {
-		return_types.push_back(std::move(test_type.type));
-		names.push_back(std::move(test_type.name));
+	auto result = make_uniq<TestAllTypesBindData>();
+	bool use_large_enum = false;
+	auto entry = input.named_parameters.find("use_large_enum");
+	if (entry != input.named_parameters.end()) {
+		use_large_enum = BooleanValue::Get(entry->second);
 	}
-	return nullptr;
+	result->test_types = TestAllTypesFun::GetTestTypes(use_large_enum);
+	for (auto &test_type : result->test_types) {
+		return_types.push_back(test_type.type);
+		names.push_back(test_type.name);
+	}
+	return std::move(result);
 }
 
 unique_ptr<GlobalTableFunctionState> TestAllTypesInit(ClientContext &context, TableFunctionInitInput &input) {
+	auto &bind_data = input.bind_data->Cast<TestAllTypesBindData>();
 	auto result = make_uniq<TestAllTypesData>();
-	auto test_types = TestAllTypesFun::GetTestTypes();
 	// 3 rows: min, max and NULL
 	result->entries.resize(3);
 	// initialize the values
-	for (auto &test_type : test_types) {
-		result->entries[0].push_back(std::move(test_type.min_value));
-		result->entries[1].push_back(std::move(test_type.max_value));
-		result->entries[2].emplace_back(std::move(test_type.type));
+	for (auto &test_type : bind_data.test_types) {
+		result->entries[0].push_back(test_type.min_value);
+		result->entries[1].push_back(test_type.max_value);
+		result->entries[2].emplace_back(test_type.type);
 	}
 	return std::move(result);
 }
@@ -243,7 +261,9 @@ void TestAllTypesFunction(ClientContext &context, TableFunctionInput &data_p, Da
 }
 
 void TestAllTypesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("test_all_types", {}, TestAllTypesFunction, TestAllTypesBind, TestAllTypesInit));
+	TableFunction test_all_types("test_all_types", {}, TestAllTypesFunction, TestAllTypesBind, TestAllTypesInit);
+	test_all_types.named_parameters["use_large_enum"] = LogicalType::BOOLEAN;
+	set.AddFunction(test_all_types);
 }
 
 } // namespace duckdb

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev15"
+#define DUCKDB_VERSION "0.8.2-dev157"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "e2406ff98e"
+#define DUCKDB_SOURCE_ID "e49cf8132d"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/execution/physical_operator.hpp

@@ -156,6 +156,9 @@ public:
 	//! The maximum amount of memory the operator should use per thread.
 	static idx_t GetMaxThreadMemory(ClientContext &context);
 
+	//! Whether operator caching is allowed in the current execution context
+	static bool OperatorCachingAllowed(ExecutionContext &context);
+
 	virtual bool IsSink() const {
 		return false;
 	}

package/src/duckdb/src/include/duckdb/function/table/system_functions.hpp

@@ -118,7 +118,7 @@ struct TestType {
 
 struct TestAllTypesFun {
 	static void RegisterFunction(BuiltinFunctions &set);
-	static vector<TestType> GetTestTypes();
+	static vector<TestType> GetTestTypes(bool large_enum = false);
 };
 
 struct TestVectorTypesFun {

package/src/duckdb/src/parallel/pipeline_executor.cpp

@@ -17,11 +17,10 @@ PipelineExecutor::PipelineExecutor(ClientContext &context_p, Pipeline &pipeline_
 		requires_batch_index = pipeline.sink->RequiresBatchIndex() && pipeline.source->SupportsBatchIndex();
 		if (requires_batch_index) {
 			auto &partition_info = local_sink_state->partition_info;
-			if (!partition_info.batch_index.IsValid()) {
-				// batch index is not set yet - initialize before fetching anything
-				partition_info.batch_index = pipeline.RegisterNewBatchIndex();
-				partition_info.min_batch_index = partition_info.batch_index;
-			}
+			D_ASSERT(!partition_info.batch_index.IsValid());
+			// batch index is not set yet - initialize before fetching anything
+			partition_info.batch_index = pipeline.RegisterNewBatchIndex();
+			partition_info.min_batch_index = partition_info.batch_index;
 		}
 	}
 	local_source_state = pipeline.source->GetLocalSourceState(context, *pipeline.source_state);
@@ -79,6 +78,7 @@ bool PipelineExecutor::TryFlushCachingOperators() {
 		OperatorResultType push_result;
 
 		if (in_process_operators.empty()) {
+			curr_chunk.Reset();
 			StartOperator(current_operator);
 			finalize_result = current_operator.FinalExecute(context, curr_chunk, *current_operator.op_state,
 			                                                *intermediate_states[flushing_idx]);
@@ -477,7 +477,8 @@ SourceResultType PipelineExecutor::FetchFromSource(DataChunk &result) {
 		} else {
 			next_batch_index =
 			    pipeline.source->GetBatchIndex(context, result, *pipeline.source_state, *local_source_state);
-			next_batch_index += pipeline.base_batch_index;
+			// we start with the base_batch_index as a valid starting value. Make sure that next batch is called below
+			next_batch_index += pipeline.base_batch_index + 1;
 		}
 		auto &partition_info = local_sink_state->partition_info;
 		if (next_batch_index != partition_info.batch_index.GetIndex()) {

package/src/duckdb/src/planner/binder/tableref/bind_pivot.cpp

@@ -315,7 +315,6 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 		}
 		ExtractPivotExpressions(*aggr, handled_columns);
 	}
-	value_set_t pivots;
 
 	// first add all pivots to the set of handled columns, and check for duplicates
 	idx_t total_pivots = 1;

package/src/duckdb/src/storage/storage_manager.cpp

@@ -94,8 +94,13 @@ void SingleFileStorageManager::LoadDatabase() {
 		table_io_manager = make_uniq<SingleFileTableIOManager>(*block_manager);
 		return;
 	}
-
-	string wal_path = path + ".wal";
+	std::size_t question_mark_pos = path.find('?');
+	auto wal_path = path;
+	if (question_mark_pos != std::string::npos) {
+		wal_path.insert(question_mark_pos, ".wal");
+	} else {
+		wal_path += ".wal";
+	}
 	auto &fs = FileSystem::Get(db);
 	auto &config = DBConfig::Get(db);
 	bool truncate_wal = false;

package/src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp

@@ -348,17 +348,17 @@
 
 #include "extension/icu/third_party/icu/i18n/wintzimpl.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-fast-dtoa.cpp"
-
 #include "extension/icu/third_party/icu/i18n/double-conversion-double-to-string.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-strtod.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-string-to-double.cpp"
 
 #include "extension/icu/third_party/icu/i18n/double-conversion-cached-powers.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-string-to-double.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-fast-dtoa.cpp"
+
+#include "extension/icu/third_party/icu/i18n/double-conversion-bignum.cpp"
 
 #include "extension/icu/third_party/icu/i18n/double-conversion-bignum-dtoa.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-bignum.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-strtod.cpp"
 

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);
+  });
+});