duckdb 0.3.3-dev117.0 → 0.3.3-dev153.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.3-dev117.0",
+  "version": "0.3.3-dev153.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -42519,12 +42519,18 @@ void VectorOperations::Copy(const Vector &source, Vector &target, idx_t source_c
 namespace duckdb {
 
 struct HashOp {
+	static const hash_t NULL_HASH = 0xbf58476d1ce4e5b9;
+
 	template <class T>
 	static inline hash_t Operation(T input, bool is_null) {
-		return duckdb::Hash<T>(is_null ? duckdb::NullValue<T>() : input);
+		return is_null ? NULL_HASH : duckdb::Hash<T>(input);
 	}
 };
 
+static inline hash_t CombineHashScalar(hash_t a, hash_t b) {
+	return (a * UINT64_C(0xbf58476d1ce4e5b9)) ^ b;
+}
+
 template <bool HAS_RSEL, class T>
 static inline void TightLoopHash(T *__restrict ldata, hash_t *__restrict result_data, const SelectionVector *rsel,
                                  idx_t count, const SelectionVector *__restrict sel_vector, ValidityMask &mask) {
@@ -42566,7 +42572,7 @@ template <bool HAS_RSEL, bool FIRST_HASH>
 static inline void StructLoopHash(Vector &input, Vector &hashes, const SelectionVector *rsel, idx_t count) {
 	auto &children = StructVector::GetEntries(input);
 
-	D_ASSERT(children.size() > 0);
+	D_ASSERT(!children.empty());
 	idx_t col_no = 0;
 	if (HAS_RSEL) {
 		if (FIRST_HASH) {
@@ -42596,14 +42602,81 @@ static inline void ListLoopHash(Vector &input, Vector &hashes, const SelectionVe
 	VectorData idata;
 	input.Orrify(count, idata);
 	const auto ldata = (const list_entry_t *)idata.data;
-	for (idx_t i = 0; i < count; i++) {
+
+	// Hash the children into a temporary
+	auto &child = ListVector::GetEntry(input);
+	const auto child_count = ListVector::GetListSize(input);
+
+	Vector child_hashes(LogicalType::HASH, child_count);
+	VectorOperations::Hash(child, child_hashes, child_count);
+	auto chdata = FlatVector::GetData<hash_t>(child_hashes);
+
+	// Reduce the number of entries to check to the non-empty ones
+	SelectionVector unprocessed(count);
+	SelectionVector cursor(HAS_RSEL ? STANDARD_VECTOR_SIZE : count);
+	idx_t remaining = 0;
+	for (idx_t i = 0; i < count; ++i) {
 		const idx_t ridx = HAS_RSEL ? rsel->get_index(i) : i;
 		const auto lidx = idata.sel->get_index(ridx);
 		const auto &entry = ldata[lidx];
-		if (idata.validity.RowIsValid(lidx)) {
-			hdata[ridx] = duckdb::Hash(entry.length);
-		} else {
-			hdata[ridx] = 0;
+		if (idata.validity.RowIsValid(lidx) && entry.length > 0) {
+			unprocessed.set_index(remaining++, ridx);
+			cursor.set_index(ridx, entry.offset);
+		} else if (FIRST_HASH) {
+			hdata[ridx] = HashOp::NULL_HASH;
+		}
+		// Empty or NULL non-first elements have no effect.
+	}
+
+	count = remaining;
+	if (count == 0) {
+		return;
+	}
+
+	// Merge the first position hash into the main hash
+	idx_t position = 1;
+	if (FIRST_HASH) {
+		remaining = 0;
+		for (idx_t i = 0; i < count; ++i) {
+			const auto ridx = unprocessed.get_index(i);
+			const auto cidx = cursor.get_index(ridx);
+			hdata[ridx] = chdata[cidx];
+
+			const auto lidx = idata.sel->get_index(ridx);
+			const auto &entry = ldata[lidx];
+			if (entry.length > position) {
+				// Entry still has values to hash
+				unprocessed.set_index(remaining++, ridx);
+				cursor.set_index(ridx, cidx + 1);
+			}
+		}
+		count = remaining;
+		if (count == 0) {
+			return;
+		}
+		++position;
+	}
+
+	// Combine the hashes for the remaining positions until there are none left
+	for (;; ++position) {
+		remaining = 0;
+		for (idx_t i = 0; i < count; ++i) {
+			const auto ridx = unprocessed.get_index(i);
+			const auto cidx = cursor.get_index(ridx);
+			hdata[ridx] = CombineHashScalar(hdata[ridx], chdata[cidx]);
+
+			const auto lidx = idata.sel->get_index(ridx);
+			const auto &entry = ldata[lidx];
+			if (entry.length > position) {
+				// Entry still has values to hash
+				unprocessed.set_index(remaining++, ridx);
+				cursor.set_index(ridx, cidx + 1);
+			}
+		}
+
+		count = remaining;
+		if (count == 0) {
+			break;
 		}
 	}
 }
@@ -42672,10 +42745,6 @@ void VectorOperations::Hash(Vector &input, Vector &result, const SelectionVector
 	HashTypeSwitch<true>(input, result, &sel, count);
 }
 
-static inline hash_t CombineHashScalar(hash_t a, hash_t b) {
-	return (a * UINT64_C(0xbf58476d1ce4e5b9)) ^ b;
-}
-
 template <bool HAS_RSEL, class T>
 static inline void TightLoopCombineHashConstant(T *__restrict ldata, hash_t constant_hash, hash_t *__restrict hash_data,
                                                 const SelectionVector *rsel, idx_t count,
@@ -80230,6 +80299,10 @@ struct AliasFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct HashFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct LeastFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -80431,6 +80504,21 @@ void CurrentSettingFun::RegisterFunction(BuiltinFunctions &set) {
 } // namespace duckdb
 
 
+namespace duckdb {
+
+static void HashFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	args.Hash(result);
+}
+
+void HashFun::RegisterFunction(BuiltinFunctions &set) {
+	auto hash_fun = ScalarFunction("hash", {LogicalType::ANY}, LogicalType::HASH, HashFunction);
+	hash_fun.varargs = LogicalType::ANY;
+	set.AddFunction(hash_fun);
+}
+
+} // namespace duckdb
+
+
 
 namespace duckdb {
 
@@ -80631,6 +80719,7 @@ namespace duckdb {
 
 void BuiltinFunctions::RegisterGenericFunctions() {
 	Register<AliasFun>();
+	Register<HashFun>();
 	Register<LeastFun>();
 	Register<GreatestFun>();
 	Register<StatsFun>();
@@ -81085,59 +81174,48 @@ void ListExtractTemplate(idx_t count, VectorData &list_data, VectorData &offsets
 static void ExecuteListExtractInternal(const idx_t count, VectorData &list, VectorData &offsets, Vector &child_vector,
                                        idx_t list_size, Vector &result) {
 	D_ASSERT(child_vector.GetType() == result.GetType());
-	switch (result.GetType().id()) {
-	case LogicalTypeId::UTINYINT:
-		ListExtractTemplate<uint8_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case LogicalTypeId::TINYINT:
+	switch (result.GetType().InternalType()) {
+	case PhysicalType::BOOL:
+	case PhysicalType::INT8:
 		ListExtractTemplate<int8_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::USMALLINT:
-		ListExtractTemplate<uint16_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case LogicalTypeId::SMALLINT:
+	case PhysicalType::INT16:
 		ListExtractTemplate<int16_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::UINTEGER:
-		ListExtractTemplate<uint32_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case LogicalTypeId::INTEGER:
+	case PhysicalType::INT32:
 		ListExtractTemplate<int32_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::UBIGINT:
-		ListExtractTemplate<uint64_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case LogicalTypeId::BIGINT:
+	case PhysicalType::INT64:
 		ListExtractTemplate<int64_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::HUGEINT:
+	case PhysicalType::INT128:
 		ListExtractTemplate<hugeint_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::FLOAT:
-		ListExtractTemplate<float>(count, list, offsets, child_vector, list_size, result);
+	case PhysicalType::UINT8:
+		ListExtractTemplate<uint8_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::DOUBLE:
-		ListExtractTemplate<double>(count, list, offsets, child_vector, list_size, result);
+	case PhysicalType::UINT16:
+		ListExtractTemplate<uint16_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::DATE:
-		ListExtractTemplate<date_t>(count, list, offsets, child_vector, list_size, result);
+	case PhysicalType::UINT32:
+		ListExtractTemplate<uint32_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
-		ListExtractTemplate<dtime_t>(count, list, offsets, child_vector, list_size, result);
+	case PhysicalType::UINT64:
+		ListExtractTemplate<uint64_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-		ListExtractTemplate<timestamp_t>(count, list, offsets, child_vector, list_size, result);
+	case PhysicalType::FLOAT:
+		ListExtractTemplate<float>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::VARCHAR:
+	case PhysicalType::DOUBLE:
+		ListExtractTemplate<double>(count, list, offsets, child_vector, list_size, result);
+		break;
+	case PhysicalType::VARCHAR:
 		ListExtractTemplate<string_t, true>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::SQLNULL:
-		result.Reference(Value());
+	case PhysicalType::INTERVAL:
+		ListExtractTemplate<interval_t>(count, list, offsets, child_vector, list_size, result);
 		break;
-	case LogicalTypeId::STRUCT: {
+	case PhysicalType::STRUCT: {
 		auto &entries = StructVector::GetEntries(child_vector);
 		auto &result_entries = StructVector::GetEntries(result);
 		D_ASSERT(entries.size() == result_entries.size());
@@ -81149,7 +81227,7 @@ static void ExecuteListExtractInternal(const idx_t count, VectorData &list, Vect
 		ListExtractTemplate<bool, false, true>(count, list, offsets, child_vector, list_size, result);
 		break;
 	}
-	case LogicalTypeId::LIST: {
+	case PhysicalType::LIST: {
 		// nested list: we have to reference the child
 		auto &child_child_list = ListVector::GetEntry(child_vector);
 
@@ -101749,35 +101827,35 @@ void DuckDB::SetExtensionLoaded(const std::string &name) {
 
 
 
-#ifdef BUILD_ICU_EXTENSION
+#if defined(BUILD_ICU_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 #include "icu-extension.hpp"
 #endif
 
-#ifdef BUILD_PARQUET_EXTENSION
+#if defined(BUILD_PARQUET_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 #include "parquet-extension.hpp"
 #endif
 
-#ifdef BUILD_TPCH_EXTENSION
+#if defined(BUILD_TPCH_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 #include "tpch-extension.hpp"
 #endif
 
-#ifdef BUILD_TPCDS_EXTENSION
+#if defined(BUILD_TPCDS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 #include "tpcds-extension.hpp"
 #endif
 
-#ifdef BUILD_FTS_EXTENSION
+#if defined(BUILD_FTS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 #include "fts-extension.hpp"
 #endif
 
-#ifdef BUILD_HTTPFS_EXTENSION
+#if defined(BUILD_HTTPFS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 #include "httpfs-extension.hpp"
 #endif
 
-#ifdef BUILD_VISUALIZER_EXTENSION
+#if defined(BUILD_VISUALIZER_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 #include "visualizer-extension.hpp"
 #endif
 
-#ifdef BUILD_EXCEL_EXTENSION
+#if defined(BUILD_EXCEL_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 #include "excel-extension.hpp"
 #endif
 
@@ -101816,55 +101894,55 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 	}
 #endif
 	if (extension == "parquet") {
-#ifdef BUILD_PARQUET_EXTENSION
+#if defined(BUILD_PARQUET_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 		db.LoadExtension<ParquetExtension>();
 #else
 		// parquet extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "icu") {
-#ifdef BUILD_ICU_EXTENSION
+#if defined(BUILD_ICU_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 		db.LoadExtension<ICUExtension>();
 #else
 		// icu extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "tpch") {
-#ifdef BUILD_TPCH_EXTENSION
+#if defined(BUILD_TPCH_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 		db.LoadExtension<TPCHExtension>();
 #else
 		// icu extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "tpcds") {
-#ifdef BUILD_TPCDS_EXTENSION
+#if defined(BUILD_TPCDS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 		db.LoadExtension<TPCDSExtension>();
 #else
 		// icu extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "fts") {
-#ifdef BUILD_FTS_EXTENSION
+#if defined(BUILD_FTS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 		db.LoadExtension<FTSExtension>();
 #else
 		// fts extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "httpfs") {
-#ifdef BUILD_HTTPFS_EXTENSION
+#if defined(BUILD_HTTPFS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 		db.LoadExtension<HTTPFsExtension>();
 #else
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "visualizer") {
-#ifdef BUILD_VISUALIZER_EXTENSION
+#if defined(BUILD_VISUALIZER_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 		db.LoadExtension<VisualizerExtension>();
 #else
 		// visualizer extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "excel") {
-#ifdef BUILD_EXCEL_EXTENSION
+#if defined(BUILD_EXCEL_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
 		db.LoadExtension<EXCELExtension>();
 #else
 		// excel extension required but not build: skip this test

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "e0d6747f8"
-#define DUCKDB_VERSION "v0.3.3-dev117"
+#define DUCKDB_SOURCE_ID "16069e3be"
+#define DUCKDB_VERSION "v0.3.3-dev153"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //