duckdb 0.7.2-dev16.0 → 0.7.2-dev225.0

package/src/duckdb/src/function/scalar/bit/bitstring.cpp

@@ -0,0 +1,99 @@
+#include "duckdb/common/types/bit.hpp"
+#include "duckdb/function/scalar/bit_functions.hpp"
+#include "duckdb/common/types/cast_helpers.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// BitStringFunction
+//===--------------------------------------------------------------------===//
+
+static void BitStringFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	BinaryExecutor::Execute<string_t, int32_t, string_t>(
+	    args.data[0], args.data[1], result, args.size(), [&](string_t input, int32_t n) {
+		    if (n < 0) {
+			    throw InvalidInputException("The bitstring length cannot be negative");
+		    }
+		    if ((idx_t)n < input.GetSize()) {
+			    throw InvalidInputException("Length must be equal or larger than input string");
+		    }
+		    idx_t len;
+		    Bit::TryGetBitStringSize(input, len, nullptr); // string verification
+
+		    len = Bit::ComputeBitstringLen(n);
+		    string_t target = StringVector::EmptyString(result, len);
+
+		    Bit::BitString(input, n, target);
+		    return target;
+	    });
+}
+
+void BitStringFun::RegisterFunction(BuiltinFunctions &set) {
+	// bitstring creates a new bitstring from varchar with a fixed-length
+	set.AddFunction(
+	    ScalarFunction("bitstring", {LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::BIT, BitStringFunction));
+}
+
+//===--------------------------------------------------------------------===//
+// get_bit
+//===--------------------------------------------------------------------===//
+struct GetBitOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA input, TB n) {
+		if (n < 0 || (idx_t)n > Bit::BitLength(input) - 1) {
+			throw OutOfRangeException("bit index %s out of valid range (0..%s)", NumericHelper::ToString(n),
+			                          NumericHelper::ToString(Bit::BitLength(input) - 1));
+		}
+		return Bit::GetBit(input, n);
+	}
+};
+
+void GetBitFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("get_bit", {LogicalType::BIT, LogicalType::INTEGER}, LogicalType::INTEGER,
+	                               ScalarFunction::BinaryFunction<string_t, int32_t, int32_t, GetBitOperator>));
+}
+
+//===--------------------------------------------------------------------===//
+// set_bit
+//===--------------------------------------------------------------------===//
+static void SetBitOperation(DataChunk &args, ExpressionState &state, Vector &result) {
+	TernaryExecutor::Execute<string_t, int32_t, int32_t, string_t>(
+	    args.data[0], args.data[1], args.data[2], result, args.size(),
+	    [&](string_t input, int32_t n, int32_t new_value) {
+		    if (new_value != 0 && new_value != 1) {
+			    throw InvalidInputException("The new bit must be 1 or 0");
+		    }
+		    if (n < 0 || (idx_t)n > Bit::BitLength(input) - 1) {
+			    throw OutOfRangeException("bit index %s out of valid range (0..%s)", NumericHelper::ToString(n),
+			                              NumericHelper::ToString(Bit::BitLength(input) - 1));
+		    }
+		    string_t target = StringVector::EmptyString(result, input.GetSize());
+		    Bit::SetBit(input, n, new_value, target);
+		    return target;
+	    });
+}
+
+void SetBitFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("set_bit", {LogicalType::BIT, LogicalType::INTEGER, LogicalType::INTEGER},
+	                               LogicalType::BIT, SetBitOperation));
+}
+
+//===--------------------------------------------------------------------===//
+// bit_position
+//===--------------------------------------------------------------------===//
+struct BitPositionOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA substring, TB input) {
+		if (substring.GetSize() > input.GetSize()) {
+			return 0;
+		}
+		return Bit::BitPosition(substring, input);
+	}
+};
+
+void BitPositionFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("bit_position", {LogicalType::BIT, LogicalType::BIT}, LogicalType::INTEGER,
+	                               ScalarFunction::BinaryFunction<string_t, string_t, int32_t, BitPositionOperator>));
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/map/map_entries.cpp

@@ -0,0 +1,61 @@
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/parser/expression/bound_expression.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/common/pair.hpp"
+
+namespace duckdb {
+
+// Reverse of map_from_entries
+static void MapEntriesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	idx_t count = args.size();
+
+	result.Reinterpret(args.data[0]);
+
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+	result.Verify(count);
+}
+
+static unique_ptr<FunctionData> MapEntriesBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
+	child_list_t<LogicalType> child_types;
+
+	if (arguments.size() != 1) {
+		throw InvalidInputException("Too many arguments provided, only expecting a single map");
+	}
+	auto &map = arguments[0]->return_type;
+
+	if (map.id() == LogicalTypeId::UNKNOWN) {
+		// Prepared statement
+		bound_function.arguments.emplace_back(LogicalTypeId::UNKNOWN);
+		bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
+		return nullptr;
+	}
+
+	if (map.id() != LogicalTypeId::MAP) {
+		throw InvalidInputException("The provided argument is not a map");
+	}
+	auto &key_type = MapType::KeyType(map);
+	auto &value_type = MapType::ValueType(map);
+
+	child_types.push_back(make_pair("k", key_type));
+	child_types.push_back(make_pair("v", value_type));
+
+	auto row_type = LogicalType::STRUCT(std::move(child_types));
+
+	bound_function.return_type = LogicalType::LIST(row_type);
+	return make_unique<VariableReturnBindData>(bound_function.return_type);
+}
+
+void MapEntriesFun::RegisterFunction(BuiltinFunctions &set) {
+	//! the arguments and return types are actually set in the binder function
+	ScalarFunction fun("map_entries", {}, LogicalTypeId::LIST, MapEntriesFunction, MapEntriesBind);
+	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
+	fun.varargs = LogicalType::ANY;
+	set.AddFunction(fun);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/map/map_keys_values.cpp

@@ -0,0 +1,97 @@
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/parser/expression/bound_expression.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/common/pair.hpp"
+
+namespace duckdb {
+
+static void MapKeyValueFunction(DataChunk &args, ExpressionState &state, Vector &result,
+                                Vector &(*get_child_vector)(Vector &)) {
+	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
+	auto count = args.size();
+
+	auto &map = args.data[0];
+	D_ASSERT(map.GetType().id() == LogicalTypeId::MAP);
+	auto child = get_child_vector(map);
+
+	auto &entries = ListVector::GetEntry(result);
+	entries.Reference(child);
+
+	UnifiedVectorFormat map_data;
+	map.ToUnifiedFormat(count, map_data);
+
+	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
+	FlatVector::SetData(result, map_data.data);
+	FlatVector::SetValidity(result, map_data.validity);
+	auto list_size = ListVector::GetListSize(map);
+	ListVector::SetListSize(result, list_size);
+	if (map.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
+		result.Slice(*map_data.sel, count);
+	}
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+	result.Verify(count);
+}
+
+static void MapKeysFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	MapKeyValueFunction(args, state, result, MapVector::GetKeys);
+}
+
+static void MapValuesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	MapKeyValueFunction(args, state, result, MapVector::GetValues);
+}
+
+static unique_ptr<FunctionData> MapKeyValueBind(ClientContext &context, ScalarFunction &bound_function,
+                                                vector<unique_ptr<Expression>> &arguments,
+                                                const LogicalType &(*type_func)(const LogicalType &)) {
+	if (arguments.size() != 1) {
+		throw InvalidInputException("Too many arguments provided, only expecting a single map");
+	}
+	auto &map = arguments[0]->return_type;
+
+	if (map.id() == LogicalTypeId::UNKNOWN) {
+		// Prepared statement
+		bound_function.arguments.emplace_back(LogicalTypeId::UNKNOWN);
+		bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
+		return nullptr;
+	}
+
+	if (map.id() != LogicalTypeId::MAP) {
+		throw InvalidInputException("The provided argument is not a map");
+	}
+
+	auto &type = type_func(map);
+
+	bound_function.return_type = LogicalType::LIST(type);
+	return make_unique<VariableReturnBindData>(bound_function.return_type);
+}
+
+static unique_ptr<FunctionData> MapKeysBind(ClientContext &context, ScalarFunction &bound_function,
+                                            vector<unique_ptr<Expression>> &arguments) {
+	return MapKeyValueBind(context, bound_function, arguments, MapType::KeyType);
+}
+
+static unique_ptr<FunctionData> MapValuesBind(ClientContext &context, ScalarFunction &bound_function,
+                                              vector<unique_ptr<Expression>> &arguments) {
+	return MapKeyValueBind(context, bound_function, arguments, MapType::ValueType);
+}
+
+void MapKeysFun::RegisterFunction(BuiltinFunctions &set) {
+	//! the arguments and return types are actually set in the binder function
+	ScalarFunction fun("map_keys", {}, LogicalTypeId::LIST, MapKeysFunction, MapKeysBind);
+	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
+	fun.varargs = LogicalType::ANY;
+	set.AddFunction(fun);
+}
+
+void MapValuesFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunction fun("map_values", {}, LogicalTypeId::LIST, MapValuesFunction, MapValuesBind);
+	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
+	fun.varargs = LogicalType::ANY;
+	set.AddFunction(fun);
+}
+
+} // namespace duckdb

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

@@ -22,6 +22,9 @@ void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<ListFlattenFun>();
 	Register<MapFun>();
 	Register<MapFromEntriesFun>();
+	Register<MapEntriesFun>();
+	Register<MapValuesFun>();
+	Register<MapKeysFun>();
 	Register<MapExtractFun>();
 	Register<UnionValueFun>();
 	Register<UnionExtractFun>();

package/src/duckdb/src/function/scalar/operators/add.cpp

@@ -7,9 +7,6 @@
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/types/hugeint.hpp"
-#include "duckdb/common/windows_undefs.hpp"
-
-#include <limits>
 
 namespace duckdb {
 
@@ -19,18 +16,12 @@ namespace duckdb {
 template <>
 float AddOperator::Operation(float left, float right) {
 	auto result = left + right;
-	if (!Value::FloatIsFinite(result)) {
-		throw OutOfRangeException("Overflow in addition of float!");
-	}
 	return result;
 }
 
 template <>
 double AddOperator::Operation(double left, double right) {
 	auto result = left + right;
-	if (!Value::DoubleIsFinite(result)) {
-		throw OutOfRangeException("Overflow in addition of double!");
-	}
 	return result;
 }
 

package/src/duckdb/src/function/scalar/operators/arithmetic.cpp

@@ -431,12 +431,12 @@ struct NegateOperator {
 
 template <>
 bool NegateOperator::CanNegate(float input) {
-	return Value::FloatIsFinite(input);
+	return true;
 }
 
 template <>
 bool NegateOperator::CanNegate(double input) {
-	return Value::DoubleIsFinite(input);
+	return true;
 }
 
 template <>
@@ -803,18 +803,12 @@ void MultiplyFun::RegisterFunction(BuiltinFunctions &set) {
 template <>
 float DivideOperator::Operation(float left, float right) {
 	auto result = left / right;
-	if (!Value::FloatIsFinite(result)) {
-		throw OutOfRangeException("Overflow in division of float!");
-	}
 	return result;
 }
 
 template <>
 double DivideOperator::Operation(double left, double right) {
 	auto result = left / right;
-	if (!Value::DoubleIsFinite(result)) {
-		throw OutOfRangeException("Overflow in division of double!");
-	}
 	return result;
 }
 
@@ -946,9 +940,6 @@ template <>
 float ModuloOperator::Operation(float left, float right) {
 	D_ASSERT(right != 0);
 	auto result = std::fmod(left, right);
-	if (!Value::FloatIsFinite(result)) {
-		throw OutOfRangeException("Overflow in modulo of float!");
-	}
 	return result;
 }
 
@@ -956,9 +947,6 @@ template <>
 double ModuloOperator::Operation(double left, double right) {
 	D_ASSERT(right != 0);
 	auto result = std::fmod(left, right);
-	if (!Value::DoubleIsFinite(result)) {
-		throw OutOfRangeException("Overflow in modulo of double!");
-	}
 	return result;
 }
 

package/src/duckdb/src/function/scalar/operators/bitwise.cpp

@@ -107,7 +107,6 @@ void BitwiseAndFun::RegisterFunction(BuiltinFunctions &set) {
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseANDOperator>(type)));
 	}
 	functions.AddFunction(ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::BIT, BitwiseANDOperation));
-
 	set.AddFunction(functions);
 }
 
@@ -306,66 +305,4 @@ void RightShiftFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(functions);
 }
 
-//===--------------------------------------------------------------------===//
-// get_bit
-//===--------------------------------------------------------------------===//
-struct GetBitOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA input, TB n) {
-		if (n < 0 || (idx_t)n > Bit::BitLength(input) - 1) {
-			throw OutOfRangeException("bit index %s out of valid range (0..%s)", NumericHelper::ToString(n),
-			                          NumericHelper::ToString(Bit::BitLength(input) - 1));
-		}
-		return Bit::GetBit(input, n);
-	}
-};
-
-void GetBitFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("get_bit", {LogicalType::BIT, LogicalType::INTEGER}, LogicalType::INTEGER,
-	                               ScalarFunction::BinaryFunction<string_t, int32_t, int32_t, GetBitOperator>));
-}
-
-//===--------------------------------------------------------------------===//
-// set_bit
-//===--------------------------------------------------------------------===//
-static void SetBitOperation(DataChunk &args, ExpressionState &state, Vector &result) {
-	TernaryExecutor::Execute<string_t, int32_t, int32_t, string_t>(
-	    args.data[0], args.data[1], args.data[2], result, args.size(),
-	    [&](string_t input, int32_t n, int32_t new_value) {
-		    if (new_value != 0 && new_value != 1) {
-			    throw InvalidInputException("The new bit must be 1 or 0");
-		    }
-		    if (n < 0 || (idx_t)n > Bit::BitLength(input) - 1) {
-			    throw OutOfRangeException("bit index %s out of valid range (0..%s)", NumericHelper::ToString(n),
-			                              NumericHelper::ToString(Bit::BitLength(input) - 1));
-		    }
-		    string_t target = StringVector::EmptyString(result, input.GetSize());
-		    Bit::SetBit(input, n, new_value, target);
-		    return target;
-	    });
-}
-
-void SetBitFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("set_bit", {LogicalType::BIT, LogicalType::INTEGER, LogicalType::INTEGER},
-	                               LogicalType::BIT, SetBitOperation));
-}
-
-//===--------------------------------------------------------------------===//
-// bit_position
-//===--------------------------------------------------------------------===//
-struct BitPositionOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA substring, TB input) {
-		if (substring.GetSize() > input.GetSize()) {
-			return 0;
-		}
-		return Bit::BitPosition(substring, input);
-	}
-};
-
-void BitPositionFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(ScalarFunction("bit_position", {LogicalType::BIT, LogicalType::BIT}, LogicalType::INTEGER,
-	                               ScalarFunction::BinaryFunction<string_t, string_t, int32_t, BitPositionOperator>));
-}
-
 } // namespace duckdb

package/src/duckdb/src/function/scalar/operators/multiply.cpp

@@ -16,18 +16,12 @@ namespace duckdb {
 template <>
 float MultiplyOperator::Operation(float left, float right) {
 	auto result = left * right;
-	if (!Value::FloatIsFinite(result)) {
-		throw OutOfRangeException("Overflow in multiplication of float!");
-	}
 	return result;
 }
 
 template <>
 double MultiplyOperator::Operation(double left, double right) {
 	auto result = left * right;
-	if (!Value::DoubleIsFinite(result)) {
-		throw OutOfRangeException("Overflow in multiplication of double!");
-	}
 	return result;
 }
 

package/src/duckdb/src/function/scalar/operators/subtract.cpp

@@ -15,18 +15,12 @@ namespace duckdb {
 template <>
 float SubtractOperator::Operation(float left, float right) {
 	auto result = left - right;
-	if (!Value::FloatIsFinite(result)) {
-		throw OutOfRangeException("Overflow in subtraction of float!");
-	}
 	return result;
 }
 
 template <>
 double SubtractOperator::Operation(double left, double right) {
 	auto result = left - right;
-	if (!Value::DoubleIsFinite(result)) {
-		throw OutOfRangeException("Overflow in subtraction of double!");
-	}
 	return result;
 }
 

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

@@ -50,6 +50,7 @@ void BuiltinFunctions::RegisterStringFunctions() {
 	Register<GetBitFun>();
 	Register<SetBitFun>();
 	Register<BitPositionFun>();
+	Register<BitStringFun>();
 
 	// uuid functions
 	Register<UUIDFun>();

package/src/duckdb/src/function/table/read_csv.cpp

@@ -31,6 +31,9 @@ void ReadCSVData::InitializeFiles(ClientContext &context, const vector<string> &
 		auto found_files = fs.GlobFiles(file_pattern, context);
 		files.insert(files.end(), found_files.begin(), found_files.end());
 	}
+	if (files.empty()) {
+		throw IOException("CSV reader needs at least one file to read");
+	}
 }
 
 void ReadCSVData::FinalizeRead(ClientContext &context) {
@@ -61,9 +64,15 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 	auto &options = result->options;
 
 	vector<string> patterns;
+	if (input.inputs[0].IsNull()) {
+		throw ParserException("CSV reader cannot take NULL as parameter");
+	}
 	if (input.inputs[0].type().id() == LogicalTypeId::LIST) {
 		// list of globs
 		for (auto &val : ListValue::GetChildren(input.inputs[0])) {
+			if (val.IsNull()) {
+				throw ParserException("CSV reader cannot take NULL input as parameter");
+			}
 			patterns.push_back(StringValue::Get(val));
 		}
 	} else {

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev16"
+#define DUCKDB_VERSION "0.7.2-dev225"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "7813eea926"
+#define DUCKDB_SOURCE_ID "96a1cada02"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/function/table_function.cpp

@@ -35,4 +35,23 @@ TableFunction::TableFunction()
       filter_pushdown(false), filter_prune(false) {
 }
 
+bool TableFunction::Equal(const TableFunction &rhs) const {
+	// number of types
+	if (this->arguments.size() != rhs.arguments.size()) {
+		return false;
+	}
+	// argument types
+	for (idx_t i = 0; i < this->arguments.size(); ++i) {
+		if (this->arguments[i] != rhs.arguments[i]) {
+			return false;
+		}
+	}
+	// varargs
+	if (this->varargs != rhs.varargs) {
+		return false;
+	}
+
+	return true; // they are equal
+}
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp

@@ -9,17 +9,12 @@
 #pragma once
 
 #include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/function/function_set.hpp"
+#include "duckdb/catalog/catalog_set.hpp"
+#include "duckdb/function/function.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 
 namespace duckdb {
 
-class Catalog;
-class Constraint;
-
-struct CreateTableFunctionInfo;
-
 //! A table function in the catalog
 class TableFunctionCatalogEntry : public StandardEntry {
 public:
@@ -31,5 +26,8 @@ public:
 
 	//! The table function
 	TableFunctionSet functions;
+
+public:
+	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
 };
 } // namespace duckdb

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

@@ -15,25 +15,6 @@
 
 namespace duckdb {
 
-// API versions
-// if no explicit API version is defined, the latest API version is used
-// Note that using older API versions (i.e. not using DUCKDB_API_LATEST) is deprecated.
-// These will not be supported long-term, and will be removed in future versions.
-
-#ifndef DUCKDB_API_0_3_1
-#define DUCKDB_API_0_3_1 1
-#endif
-#ifndef DUCKDB_API_0_3_2
-#define DUCKDB_API_0_3_2 2
-#endif
-#ifndef DUCKDB_API_LATEST
-#define DUCKDB_API_LATEST DUCKDB_API_0_3_2
-#endif
-
-#ifndef DUCKDB_API_VERSION
-#define DUCKDB_API_VERSION DUCKDB_API_LATEST
-#endif
-
 //! inline std directives that we use frequently
 #ifndef DUCKDB_DEBUG_MOVE
 using std::move;

package/src/duckdb/src/include/duckdb/common/enums/statement_type.hpp

@@ -44,7 +44,8 @@ enum class StatementType : uint8_t {
 	EXTENSION_STATEMENT,
 	LOGICAL_PLAN_STATEMENT,
 	ATTACH_STATEMENT,
-	DETACH_STATEMENT
+	DETACH_STATEMENT,
+	MULTI_STATEMENT
 
 };
 

package/src/duckdb/src/include/duckdb/common/enums/tableref_type.hpp

@@ -23,7 +23,8 @@ enum class TableReferenceType : uint8_t {
 	TABLE_FUNCTION = 5,  // table producing function
 	EXPRESSION_LIST = 6, // expression list
 	CTE = 7,             // Recursive CTE
-	EMPTY = 8            // placeholder for empty FROM
+	EMPTY = 8,           // placeholder for empty FROM
+	PIVOT = 9            // pivot statement
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/bit.hpp

@@ -26,6 +26,7 @@ public:
 	DUCKDB_API static idx_t GetBit(string_t bit_string, idx_t n);
 	//! Sets the nth bit in bit string to newvalue; the first (leftmost) bit is indexed 0
 	DUCKDB_API static void SetBit(const string_t &bit_string, idx_t n, idx_t new_value, string_t &result);
+	DUCKDB_API static void SetBit(string_t &bit_string, idx_t n, idx_t new_value);
 	//! Returns first starting index of the specified substring within bits, or zero if it's not present.
 	DUCKDB_API static idx_t BitPosition(string_t substring, string_t bits);
 	//! Converts bits to a string, writing the output to the designated output string.
@@ -38,7 +39,11 @@ public:
 	//! perform data validation.
 	DUCKDB_API static void ToBit(string_t str, data_ptr_t output);
 	DUCKDB_API static string ToBit(string_t str);
+	//! Creates a new bitstring of determined length
+	DUCKDB_API static void BitString(const string_t &input, const idx_t &len, string_t &result);
 	DUCKDB_API static void SetEmptyBitString(string_t &target, string_t &input);
+	DUCKDB_API static void SetEmptyBitString(string_t &target, idx_t len);
+	DUCKDB_API static idx_t ComputeBitstringLen(idx_t len);
 
 	DUCKDB_API static void RightShift(const string_t &bit_string, const idx_t &shif, string_t &result);
 	DUCKDB_API static void LeftShift(const string_t &bit_string, const idx_t &shift, string_t &result);
@@ -52,6 +57,5 @@ private:
 	//! the bitstring.
 	DUCKDB_API static idx_t GetPadding(const string_t &bit_string);
 	DUCKDB_API static idx_t GetBitSize(string_t str);
-	DUCKDB_API static void SetBit(string_t &bit_string, idx_t n, idx_t new_value);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/value.hpp

@@ -23,6 +23,7 @@ class CastFunctionSet;
 class Deserializer;
 class Serializer;
 struct GetCastFunctionInput;
+struct ExtraValueInfo;
 
 //! The Value object holds a single arbitrary value of any type that can be
 //! stored in the database.
@@ -279,9 +280,6 @@ private:
 	//! The logical of the value
 	LogicalType type_;
 
-#if DUCKDB_API_VERSION < DUCKDB_API_0_3_2
-public:
-#endif
 	//! Whether or not the value is NULL
 	bool is_null;
 
@@ -307,11 +305,7 @@ public:
 		interval_t interval;
 	} value_;
 
-	//! The value of the object, if it is of a variable size type
-	string str_value;
-
-	vector<Value> struct_value;
-	vector<Value> list_value;
+	shared_ptr<ExtraValueInfo> value_info_;
 
 private:
 	template <class T>