duckdb 0.7.2-dev1684.0 → 0.7.2-dev1803.0

package/src/duckdb/src/function/scalar/math/numeric.cpp

@@ -443,6 +443,63 @@ void FloorFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(floor);
 }
 
+//===--------------------------------------------------------------------===//
+// trunc
+//===--------------------------------------------------------------------===//
+struct TruncOperator {
+	// Integer truncation is a NOP
+	template <class TA, class TR>
+	static inline TR Operation(TA left) {
+		return std::trunc(left);
+	}
+};
+
+struct TruncDecimalOperator {
+	template <class T, class POWERS_OF_TEN_CLASS>
+	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
+		T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale];
+		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
+			//	Always floor
+			return (input / power_of_ten);
+		});
+	}
+};
+
+void TruncFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet floor("trunc");
+	for (auto &type : LogicalType::Numeric()) {
+		scalar_function_t func = nullptr;
+		bind_scalar_function_t bind_func = nullptr;
+		//	Truncation of integers gets generated by some tools (e.g., Tableau/JDBC:Postgres)
+		switch (type.id()) {
+		case LogicalTypeId::FLOAT:
+			func = ScalarFunction::UnaryFunction<float, float, TruncOperator>;
+			break;
+		case LogicalTypeId::DOUBLE:
+			func = ScalarFunction::UnaryFunction<double, double, TruncOperator>;
+			break;
+		case LogicalTypeId::DECIMAL:
+			bind_func = BindGenericRoundFunctionDecimal<TruncDecimalOperator>;
+			break;
+		case LogicalTypeId::TINYINT:
+		case LogicalTypeId::SMALLINT:
+		case LogicalTypeId::INTEGER:
+		case LogicalTypeId::BIGINT:
+		case LogicalTypeId::HUGEINT:
+		case LogicalTypeId::UTINYINT:
+		case LogicalTypeId::USMALLINT:
+		case LogicalTypeId::UINTEGER:
+		case LogicalTypeId::UBIGINT:
+			func = ScalarFunction::NopFunction;
+			break;
+		default:
+			throw InternalException("Unimplemented numeric type for function \"trunc\"");
+		}
+		floor.AddFunction(ScalarFunction({type}, type, func, bind_func));
+	}
+	set.AddFunction(floor);
+}
+
 //===--------------------------------------------------------------------===//
 // round
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/function/scalar/math_functions.cpp

@@ -10,6 +10,7 @@ void BuiltinFunctions::RegisterMathFunctions() {
 	Register<CeilFun>();
 	Register<FloorFun>();
 	Register<RoundFun>();
+	Register<TruncFun>();
 
 	Register<DegreesFun>();
 	Register<RadiansFun>();

package/src/duckdb/src/function/scalar/string/hex.cpp

@@ -1,3 +1,4 @@
+#include "duckdb/common/bit_utils.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/blob.hpp"
@@ -7,6 +8,58 @@
 
 namespace duckdb {
 
+static void WriteHexBytes(uint64_t x, char *&output, idx_t buffer_size) {
+	idx_t offset = buffer_size * 4;
+
+	for (; offset >= 4; offset -= 4) {
+		uint8_t byte = (x >> (offset - 4)) & 0x0F;
+		*output = Blob::HEX_TABLE[byte];
+		output++;
+	}
+}
+
+static void WriteHugeIntHexBytes(hugeint_t x, char *&output, idx_t buffer_size) {
+	idx_t offset = buffer_size * 4;
+	auto upper = x.upper;
+	auto lower = x.lower;
+
+	for (; offset >= 68; offset -= 4) {
+		uint8_t byte = (upper >> (offset - 68)) & 0x0F;
+		*output = Blob::HEX_TABLE[byte];
+		output++;
+	}
+
+	for (; offset >= 4; offset -= 4) {
+		uint8_t byte = (lower >> (offset - 4)) & 0x0F;
+		*output = Blob::HEX_TABLE[byte];
+		output++;
+	}
+}
+
+static void WriteBinBytes(uint64_t x, char *&output, idx_t buffer_size) {
+	idx_t offset = buffer_size;
+	for (; offset >= 1; offset -= 1) {
+		*output = ((x >> (offset - 1)) & 0x01) + '0';
+		output++;
+	}
+}
+
+static void WriteHugeIntBinBytes(hugeint_t x, char *&output, idx_t buffer_size) {
+	auto upper = x.upper;
+	auto lower = x.lower;
+	idx_t offset = buffer_size;
+
+	for (; offset >= 65; offset -= 1) {
+		*output = ((upper >> (offset - 65)) & 0x01) + '0';
+		output++;
+	}
+
+	for (; offset >= 1; offset -= 1) {
+		*output = ((lower >> (offset - 1)) & 0x01) + '0';
+		output++;
+	}
+}
+
 struct HexStrOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
@@ -29,6 +82,149 @@ struct HexStrOperator {
 	}
 };
 
+struct HexIntegralOperator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
+
+		idx_t num_leading_zero = CountZeros<uint64_t>::Leading(input);
+		idx_t num_bits_to_check = 64 - num_leading_zero;
+		D_ASSERT(num_bits_to_check <= sizeof(INPUT_TYPE) * 8);
+
+		idx_t buffer_size = (num_bits_to_check + 3) / 4;
+
+		// Special case: All bits are zero
+		if (buffer_size == 0) {
+			auto target = StringVector::EmptyString(result, 1);
+			auto output = target.GetDataWriteable();
+			*output = '0';
+			target.Finalize();
+			return target;
+		}
+
+		D_ASSERT(buffer_size > 0);
+		auto target = StringVector::EmptyString(result, buffer_size);
+		auto output = target.GetDataWriteable();
+
+		WriteHexBytes(input, output, buffer_size);
+
+		target.Finalize();
+		return target;
+	}
+};
+
+struct HexHugeIntOperator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
+
+		idx_t num_leading_zero = CountZeros<hugeint_t>::Leading(input);
+		idx_t buffer_size = sizeof(INPUT_TYPE) * 2 - (num_leading_zero / 4);
+
+		// Special case: All bits are zero
+		if (buffer_size == 0) {
+			auto target = StringVector::EmptyString(result, 1);
+			auto output = target.GetDataWriteable();
+			*output = '0';
+			target.Finalize();
+			return target;
+		}
+
+		D_ASSERT(buffer_size > 0);
+		auto target = StringVector::EmptyString(result, buffer_size);
+		auto output = target.GetDataWriteable();
+
+		WriteHugeIntHexBytes(input, output, buffer_size);
+
+		target.Finalize();
+		return target;
+	}
+};
+
+template <class INPUT, class OP>
+static void ToHexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.ColumnCount() == 1);
+	auto &input = args.data[0];
+	idx_t count = args.size();
+	UnaryExecutor::ExecuteString<INPUT, string_t, OP>(input, result, count);
+}
+
+struct BinaryStrOperator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
+		auto data = input.GetDataUnsafe();
+		auto size = input.GetSize();
+
+		// Allocate empty space
+		auto target = StringVector::EmptyString(result, size * 8);
+		auto output = target.GetDataWriteable();
+
+		for (idx_t i = 0; i < size; ++i) {
+			uint8_t byte = data[i];
+			for (idx_t i = 8; i >= 1; --i) {
+				*output = ((byte >> (i - 1)) & 0x01) + '0';
+				output++;
+			}
+		}
+
+		target.Finalize();
+		return target;
+	}
+};
+
+struct BinaryIntegralOperator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
+
+		idx_t num_leading_zero = CountZeros<uint64_t>::Leading(input);
+		idx_t num_bits_to_check = 64 - num_leading_zero;
+		D_ASSERT(num_bits_to_check <= sizeof(INPUT_TYPE) * 8);
+
+		idx_t buffer_size = num_bits_to_check;
+
+		// Special case: All bits are zero
+		if (buffer_size == 0) {
+			auto target = StringVector::EmptyString(result, 1);
+			auto output = target.GetDataWriteable();
+			*output = '0';
+			target.Finalize();
+			return target;
+		}
+
+		D_ASSERT(buffer_size > 0);
+		auto target = StringVector::EmptyString(result, buffer_size);
+		auto output = target.GetDataWriteable();
+
+		WriteBinBytes(input, output, buffer_size);
+
+		target.Finalize();
+		return target;
+	}
+};
+
+struct BinaryHugeIntOperator {
+	template <class INPUT_TYPE, class RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
+		idx_t num_leading_zero = CountZeros<hugeint_t>::Leading(input);
+		idx_t buffer_size = sizeof(INPUT_TYPE) * 8 - num_leading_zero;
+
+		// Special case: All bits are zero
+		if (buffer_size == 0) {
+			auto target = StringVector::EmptyString(result, 1);
+			auto output = target.GetDataWriteable();
+			*output = '0';
+			target.Finalize();
+			return target;
+		}
+
+		auto target = StringVector::EmptyString(result, buffer_size);
+		auto output = target.GetDataWriteable();
+
+		WriteHugeIntBinBytes(input, output, buffer_size);
+
+		target.Finalize();
+		return target;
+	}
+};
+
 struct FromHexOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
@@ -66,103 +262,65 @@ struct FromHexOperator {
 	}
 };
 
-struct HexIntegralOperator {
+struct FromBinaryOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		// Sufficient space for maximum length
-		char buffer[sizeof(INPUT_TYPE) * 2];
-		char *ptr = buffer;
-		idx_t buffer_size = 0;
-
-		bool seen_non_zero = false;
-		for (idx_t offset = sizeof(INPUT_TYPE) * 8; offset >= 4; offset -= 4) {
-			uint8_t byte = (input >> (offset - 4)) & 0x0F;
-			if (byte == 0 && !seen_non_zero && offset > 4) {
-				continue;
-			}
-			seen_non_zero = true;
-			*ptr = Blob::HEX_TABLE[byte];
-			ptr++;
-			buffer_size++;
+		auto data = input.GetDataUnsafe();
+		auto size = input.GetSize();
+
+		if (size > NumericLimits<uint32_t>::Maximum()) {
+			throw InvalidInputException("Binary input length larger than 2^32 are not supported");
 		}
 
+		D_ASSERT(size <= NumericLimits<uint32_t>::Maximum());
+		auto buffer_size = (size + 7) / 8;
+
 		// Allocate empty space
 		auto target = StringVector::EmptyString(result, buffer_size);
 		auto output = target.GetDataWriteable();
-		memcpy(output, buffer, buffer_size);
-
-		target.Finalize();
-		return target;
-	}
-};
 
-struct HexHugeIntOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		char buffer[sizeof(INPUT_TYPE) * 2];
-		char *ptr = buffer;
-		idx_t buffer_size = 0;
-
-		uint64_t lower = input.lower;
-		int64_t upper = input.upper;
-
-		bool seen_non_zero = false;
-		for (idx_t offset = 64; offset >= 4; offset -= 4) {
-			uint8_t byte = (upper >> (offset - 4)) & 0x0F;
-
-			if (byte == 0 && !seen_non_zero) {
-				continue;
+		// Treated as a single byte
+		idx_t i = 0;
+		if (size % 8 != 0) {
+			uint8_t byte = 0;
+			for (idx_t j = size % 8; j > 0; --j) {
+				byte |= StringUtil::GetBinaryValue(data[i]) << (j - 1);
+				i++;
 			}
-			seen_non_zero = true;
-			*ptr = Blob::HEX_TABLE[byte];
-			ptr++;
-			buffer_size++;
+			*output = byte;
+			output++;
 		}
 
-		for (idx_t offset = 64; offset >= 4; offset -= 4) {
-			uint8_t byte = (lower >> (offset - 4)) & 0x0F;
-
-			// at least one byte space
-			if (byte == 0 && !seen_non_zero && offset > 4) {
-				continue;
+		while (i < size) {
+			uint8_t byte = 0;
+			for (idx_t j = 8; j > 0; --j) {
+				byte |= StringUtil::GetBinaryValue(data[i]) << (j - 1);
+				i++;
 			}
-			seen_non_zero = true;
-			*ptr = Blob::HEX_TABLE[byte];
-			ptr++;
-			buffer_size++;
+			*output = byte;
+			output++;
 		}
 
-		// Allocate empty space
-		auto target = StringVector::EmptyString(result, buffer_size);
-		auto output = target.GetDataWriteable();
-		memcpy(output, buffer, buffer_size);
-
 		target.Finalize();
 		return target;
 	}
 };
 
-static void ToHexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+template <class INPUT, class OP>
+static void ToBinaryFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 1);
 	auto &input = args.data[0];
 	idx_t count = args.size();
+	UnaryExecutor::ExecuteString<INPUT, string_t, OP>(input, result, count);
+}
 
-	switch (input.GetType().InternalType()) {
-	case PhysicalType::VARCHAR:
-		UnaryExecutor::ExecuteString<string_t, string_t, HexStrOperator>(input, result, count);
-		break;
-	case PhysicalType::INT64:
-		UnaryExecutor::ExecuteString<int64_t, string_t, HexIntegralOperator>(input, result, count);
-		break;
-	case PhysicalType::INT128:
-		UnaryExecutor::ExecuteString<hugeint_t, string_t, HexHugeIntOperator>(input, result, count);
-		break;
-	case PhysicalType::UINT64:
-		UnaryExecutor::ExecuteString<uint64_t, string_t, HexIntegralOperator>(input, result, count);
-		break;
-	default:
-		throw NotImplementedException("Specifier type not implemented");
-	}
+static void FromBinaryFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.ColumnCount() == 1);
+	D_ASSERT(args.data[0].GetType().InternalType() == PhysicalType::VARCHAR);
+	auto &input = args.data[0];
+	idx_t count = args.size();
+
+	UnaryExecutor::ExecuteString<string_t, string_t, FromBinaryOperator>(input, result, count);
 }
 
 static void FromHexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -178,13 +336,17 @@ void HexFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet to_hex("to_hex");
 	ScalarFunctionSet from_hex("from_hex");
 
-	to_hex.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToHexFunction));
+	to_hex.AddFunction(
+	    ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToHexFunction<string_t, HexStrOperator>));
 
-	to_hex.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, ToHexFunction));
+	to_hex.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, ToHexFunction<int64_t, HexIntegralOperator>));
 
-	to_hex.AddFunction(ScalarFunction({LogicalType::UBIGINT}, LogicalType::VARCHAR, ToHexFunction));
+	to_hex.AddFunction(
+	    ScalarFunction({LogicalType::UBIGINT}, LogicalType::VARCHAR, ToHexFunction<uint64_t, HexIntegralOperator>));
 
-	to_hex.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::VARCHAR, ToHexFunction));
+	to_hex.AddFunction(
+	    ScalarFunction({LogicalType::HUGEINT}, LogicalType::VARCHAR, ToHexFunction<hugeint_t, HexHugeIntOperator>));
 
 	from_hex.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, FromHexFunction));
 
@@ -196,6 +358,27 @@ void HexFun::RegisterFunction(BuiltinFunctions &set) {
 	from_hex.name = "unhex";
 	set.AddFunction(to_hex);
 	set.AddFunction(from_hex);
+
+	ScalarFunctionSet to_binary("to_binary");
+	ScalarFunctionSet from_binary("from_binary");
+	to_binary.AddFunction(
+	    ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, ToBinaryFunction<string_t, BinaryStrOperator>));
+	to_binary.AddFunction(ScalarFunction({LogicalType::UBIGINT}, LogicalType::VARCHAR,
+	                                     ToBinaryFunction<uint64_t, BinaryIntegralOperator>));
+	to_binary.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, ToBinaryFunction<int64_t, BinaryIntegralOperator>));
+	to_binary.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::VARCHAR,
+	                                     ToBinaryFunction<hugeint_t, BinaryHugeIntOperator>));
+
+	from_binary.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, FromBinaryFunction));
+
+	set.AddFunction(to_binary);
+	set.AddFunction(from_binary);
+
+	to_binary.name = "bin";
+	from_binary.name = "unbin";
+	set.AddFunction(to_binary);
+	set.AddFunction(from_binary);
 }
 
 } // namespace duckdb

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

@@ -75,7 +75,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 		}
 		installed_extensions[info.name] = std::move(info);
 	}
-
+#ifndef WASM_LOADABLE_EXTENSIONS
 	// scan the install directory for installed extensions
 	auto ext_directory = ExtensionHelper::ExtensionDirectory(context);
 	fs.ListFiles(ext_directory, [&](const string &path, bool is_directory) {
@@ -96,7 +96,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 			entry->second.installed = true;
 		}
 	});
-
+#endif
 	// now check the list of currently loaded extensions
 	auto &loaded_extensions = db.LoadedExtensions();
 	for (auto &ext_name : loaded_extensions) {

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev1684"
+#define DUCKDB_VERSION "0.7.2-dev1803"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "754ff32005"
+#define DUCKDB_SOURCE_ID "cc6160599b"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/bit_utils.hpp

@@ -0,0 +1,147 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/bit_utils.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/hugeint.hpp"
+
+#ifdef _MSC_VER
+#define __restrict__
+#define __BYTE_ORDER__          __ORDER_LITTLE_ENDIAN__
+#define __ORDER_LITTLE_ENDIAN__ 2
+#include <intrin.h>
+static inline int __builtin_ctzll(unsigned long long x) {
+#ifdef _WIN64
+	unsigned long ret;
+	_BitScanForward64(&ret, x);
+	return (int)ret;
+#else
+	unsigned long low, high;
+	bool low_set = _BitScanForward(&low, (unsigned __int32)(x)) != 0;
+	_BitScanForward(&high, (unsigned __int32)(x >> 32));
+	high += 32;
+	return low_set ? low : high;
+#endif
+}
+static inline int __builtin_clzll(unsigned long long mask) {
+	unsigned long where;
+// BitScanReverse scans from MSB to LSB for first set bit.
+// Returns 0 if no set bit is found.
+#if defined(_WIN64)
+	if (_BitScanReverse64(&where, mask))
+		return static_cast<int>(63 - where);
+#elif defined(_WIN32)
+	// Scan the high 32 bits.
+	if (_BitScanReverse(&where, static_cast<unsigned long>(mask >> 32)))
+		return static_cast<int>(63 - (where + 32)); // Create a bit offset from the MSB.
+	// Scan the low 32 bits.
+	if (_BitScanReverse(&where, static_cast<unsigned long>(mask)))
+		return static_cast<int>(63 - where);
+#else
+#error "Implementation of __builtin_clzll required"
+#endif
+	return 64; // Undefined Behavior.
+}
+
+static inline int __builtin_ctz(unsigned int value) {
+	unsigned long trailing_zero = 0;
+
+	if (_BitScanForward(&trailing_zero, value)) {
+		return trailing_zero;
+	} else {
+		// This is undefined, I better choose 32 than 0
+		return 32;
+	}
+}
+
+static inline int __builtin_clz(unsigned int value) {
+	unsigned long leading_zero = 0;
+
+	if (_BitScanReverse(&leading_zero, value)) {
+		return 31 - leading_zero;
+	} else {
+		// Same remarks as above
+		return 32;
+	}
+}
+
+#endif
+
+namespace duckdb {
+
+template <class T>
+struct CountZeros {};
+
+template <>
+struct CountZeros<uint32_t> {
+	inline static int Leading(uint32_t value) {
+		if (!value) {
+			return 32;
+		}
+		return __builtin_clz(value);
+	}
+	inline static int Trailing(uint32_t value) {
+		if (!value) {
+			return 32;
+		}
+		return __builtin_ctz(value);
+	}
+};
+
+template <>
+struct CountZeros<uint64_t> {
+	inline static int Leading(uint64_t value) {
+		if (!value) {
+			return 64;
+		}
+		return __builtin_clzll(value);
+	}
+	inline static int Trailing(uint64_t value) {
+		if (!value) {
+			return 64;
+		}
+		return __builtin_ctzll(value);
+	}
+};
+
+template <>
+struct CountZeros<hugeint_t> {
+	inline static int Leading(hugeint_t value) {
+		if (value == 0) {
+			return 128;
+		}
+
+		uint64_t upper = (uint64_t)value.upper;
+		uint64_t lower = value.lower;
+
+		int res = __builtin_clzll(upper);
+		if (res == 64) {
+			res += __builtin_clzll(lower);
+		}
+
+		return res;
+	}
+
+	inline static int Trailing(hugeint_t value) {
+		if (value == 0) {
+			return 128;
+		}
+
+		uint64_t upper = (uint64_t)value.upper;
+		uint64_t lower = value.lower;
+
+		int res = __builtin_ctzll(lower);
+		if (res == 64) {
+			res += __builtin_ctzll(upper);
+		}
+
+		return res;
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/hugeint.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "duckdb/common/winapi.hpp"
+#include "duckdb/common/string.hpp"
 #include <stdint.h>
 
 namespace duckdb {