duckdb 0.7.2-dev16.0 → 0.7.2-dev314.0

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/caseconvert.cpp

@@ -4,7 +4,7 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
+
 #include "utf8proc.hpp"
 
 #include <string.h>
@@ -153,11 +153,7 @@ static unique_ptr<BaseStatistics> CaseConvertPropagateStats(ClientContext &conte
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 1);
 	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &sstats = (StringStatistics &)*child_stats[0];
-	if (!sstats.has_unicode) {
+	if (!StringStats::CanContainUnicode(child_stats[0])) {
 		expr.function.function = CaseConvertFunctionASCII<IS_UPPER>;
 	}
 	return nullptr;

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

@@ -3,7 +3,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
+
 #include "utf8proc.hpp"
 
 namespace duckdb {
@@ -42,12 +42,8 @@ static unique_ptr<BaseStatistics> InStrPropagateStats(ClientContext &context, Fu
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 2);
 	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
 	// for strpos, we only care if the FIRST string has unicode or not
-	auto &sstats = (StringStatistics &)*child_stats[0];
-	if (!sstats.has_unicode) {
+	if (!StringStats::CanContainUnicode(child_stats[0])) {
 		expr.function.function = ScalarFunction::BinaryFunction<string_t, string_t, int64_t, InstrAsciiOperator>;
 	}
 	return nullptr;

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

@@ -4,7 +4,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
+
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "utf8proc.hpp"
 
@@ -78,11 +78,7 @@ static unique_ptr<BaseStatistics> LengthPropagateStats(ClientContext &context, F
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 1);
 	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &sstats = (StringStatistics &)*child_stats[0];
-	if (!sstats.has_unicode) {
+	if (!StringStats::CanContainUnicode(child_stats[0])) {
 		expr.function.function = ScalarFunction::UnaryFunction<string_t, int64_t, StrLenOperator>;
 	}
 	return nullptr;

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

@@ -2,7 +2,7 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
+
 #include "duckdb/execution/expression_executor.hpp"
 
 namespace duckdb {
@@ -482,11 +482,7 @@ static unique_ptr<BaseStatistics> ILikePropagateStats(ClientContext &context, Fu
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() >= 1);
 	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &sstats = (StringStatistics &)*child_stats[0];
-	if (!sstats.has_unicode) {
+	if (!StringStats::CanContainUnicode(child_stats[0])) {
 		expr.function.function = ScalarFunction::BinaryFunction<string_t, string_t, bool, ASCII_OP>;
 	}
 	return nullptr;

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

@@ -4,7 +4,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/vector_operations/ternary_executor.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
+
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "utf8proc.hpp"
 #include "duckdb/common/types/blob.hpp"
@@ -307,12 +307,8 @@ static unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
 	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
 	// we only care about the stats of the first child (i.e. the string)
-	auto &sstats = (StringStatistics &)*child_stats[0];
-	if (!sstats.has_unicode) {
+	if (!StringStats::CanContainUnicode(child_stats[0])) {
 		expr.function.function = SubstringFunctionASCII;
 	}
 	return nullptr;

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/scalar/struct/struct_extract.cpp

@@ -3,7 +3,7 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/storage/statistics/struct_statistics.hpp"
+#include "duckdb/storage/statistics/struct_stats.hpp"
 
 namespace duckdb {
 
@@ -102,15 +102,10 @@ static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, Scalar
 static unique_ptr<BaseStatistics> PropagateStructExtractStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &bind_data = input.bind_data;
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &struct_stats = (StructStatistics &)*child_stats[0];
+
 	auto &info = (StructExtractBindData &)*bind_data;
-	if (info.index >= struct_stats.child_stats.size() || !struct_stats.child_stats[info.index]) {
-		return nullptr;
-	}
-	return struct_stats.child_stats[info.index]->Copy();
+	auto struct_child_stats = StructStats::GetChildStats(child_stats[0]);
+	return struct_child_stats[info.index].ToUnique();
 }
 
 ScalarFunction StructExtractFun::GetFunction() {

package/src/duckdb/src/function/scalar/struct/struct_insert.cpp

@@ -3,7 +3,7 @@
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/storage/statistics/struct_statistics.hpp"
+#include "duckdb/storage/statistics/struct_stats.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 
 namespace duckdb {
@@ -81,22 +81,19 @@ static unique_ptr<FunctionData> StructInsertBind(ClientContext &context, ScalarF
 unique_ptr<BaseStatistics> StructInsertStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
-	if (child_stats.empty() || !child_stats[0]) {
-		return nullptr;
-	}
-	auto &existing_struct_stats = (StructStatistics &)*child_stats[0];
-	auto new_struct_stats = make_unique<StructStatistics>(expr.return_type);
+	auto new_struct_stats = StructStats::CreateUnknown(expr.return_type);
 
-	for (idx_t i = 0; i < existing_struct_stats.child_stats.size(); i++) {
-		new_struct_stats->child_stats[i] =
-		    existing_struct_stats.child_stats[i] ? existing_struct_stats.child_stats[i]->Copy() : nullptr;
+	auto existing_count = StructType::GetChildCount(child_stats[0].GetType());
+	auto existing_stats = StructStats::GetChildStats(child_stats[0]);
+	for (idx_t i = 0; i < existing_count; i++) {
+		StructStats::SetChildStats(new_struct_stats, i, existing_stats[i]);
 	}
-
-	auto offset = new_struct_stats->child_stats.size() - child_stats.size();
+	auto new_count = StructType::GetChildCount(expr.return_type);
+	auto offset = new_count - child_stats.size();
 	for (idx_t i = 1; i < child_stats.size(); i++) {
-		new_struct_stats->child_stats[offset + i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
+		StructStats::SetChildStats(new_struct_stats, offset + i, child_stats[i]);
 	}
-	return std::move(new_struct_stats);
+	return new_struct_stats.ToUnique();
 }
 
 void StructInsertFun::RegisterFunction(BuiltinFunctions &set) {

package/src/duckdb/src/function/scalar/struct/struct_pack.cpp

@@ -3,7 +3,7 @@
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/storage/statistics/struct_statistics.hpp"
+#include "duckdb/storage/statistics/struct_stats.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 
 namespace duckdb {
@@ -61,12 +61,11 @@ static unique_ptr<FunctionData> StructPackBind(ClientContext &context, ScalarFun
 unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
-	auto struct_stats = make_unique<StructStatistics>(expr.return_type);
-	D_ASSERT(child_stats.size() == struct_stats->child_stats.size());
-	for (idx_t i = 0; i < struct_stats->child_stats.size(); i++) {
-		struct_stats->child_stats[i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
+	auto struct_stats = StructStats::CreateUnknown(expr.return_type);
+	for (idx_t i = 0; i < child_stats.size(); i++) {
+		StructStats::SetChildStats(struct_stats, i, child_stats[i]);
 	}
-	return std::move(struct_stats);
+	return struct_stats.ToUnique();
 }
 
 void StructPackFun::RegisterFunction(BuiltinFunctions &set) {

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-dev314"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "7813eea926"
+#define DUCKDB_SOURCE_ID "7e05c8c034"
 #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>

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

@@ -261,7 +261,6 @@ enum class LogicalTypeId : uint8_t {
 
 	HUGEINT = 50,
 	POINTER = 51,
-	// HASH = 52, // deprecated, uses UBIGINT instead
 	VALIDITY = 53,
 	UUID = 54,
 
@@ -314,7 +313,7 @@ struct LogicalType {
 	inline LogicalType& operator=(LogicalType&& other) noexcept {
 		id_ = other.id_;
 		physical_type_ = other.physical_type_;
-		type_info_ = std::move(other.type_info_);
+		std::swap(type_info_, other.type_info_);
 		return *this;
 	}
 

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_perfecthash_aggregate.hpp

@@ -20,7 +20,7 @@ class PhysicalPerfectHashAggregate : public PhysicalOperator {
 public:
 	PhysicalPerfectHashAggregate(ClientContext &context, vector<LogicalType> types,
 	                             vector<unique_ptr<Expression>> aggregates, vector<unique_ptr<Expression>> groups,
-	                             vector<unique_ptr<BaseStatistics>> group_stats, vector<idx_t> required_bits,
+	                             const vector<unique_ptr<BaseStatistics>> &group_stats, vector<idx_t> required_bits,
 	                             idx_t estimated_cardinality);
 
 	//! The groups

package/src/duckdb/src/include/duckdb/function/aggregate/distributive_functions.hpp

@@ -27,6 +27,11 @@ struct BitXorFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct BitStringAggFun {
+	static void GetBitStringAggregate(const LogicalType &type, AggregateFunctionSet &bitstring_agg);
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct CountStarFun {
 	static AggregateFunction GetFunction();
 

package/src/duckdb/src/include/duckdb/function/aggregate_function.hpp

@@ -29,6 +29,17 @@ struct AggregateInputData {
 	Allocator &allocator;
 };
 
+struct AggregateStatisticsInput {
+	AggregateStatisticsInput(FunctionData *bind_data_p, vector<BaseStatistics> &child_stats_p,
+	                         NodeStatistics *node_stats_p)
+	    : bind_data(bind_data_p), child_stats(child_stats_p), node_stats(node_stats_p) {
+	}
+
+	FunctionData *bind_data;
+	vector<BaseStatistics> &child_stats;
+	NodeStatistics *node_stats;
+};
+
 //! The type used for sizing hashed aggregate function states
 typedef idx_t (*aggregate_size_t)();
 //! The type used for initializing hashed aggregate function states
@@ -43,9 +54,7 @@ typedef void (*aggregate_finalize_t)(Vector &state, AggregateInputData &aggr_inp
                                      idx_t offset);
 //! The type used for propagating statistics in aggregate functions (optional)
 typedef unique_ptr<BaseStatistics> (*aggregate_statistics_t)(ClientContext &context, BoundAggregateExpression &expr,
-                                                             FunctionData *bind_data,
-                                                             vector<unique_ptr<BaseStatistics>> &child_stats,
-                                                             NodeStatistics *node_stats);
+                                                             AggregateStatisticsInput &input);
 //! Binds the scalar function and creates the function data
 typedef unique_ptr<FunctionData> (*bind_aggregate_function_t)(ClientContext &context, AggregateFunction &function,
                                                               vector<unique_ptr<Expression>> &arguments);

package/src/duckdb/src/include/duckdb/function/scalar/bit_functions.hpp

@@ -25,4 +25,8 @@ struct BitPositionFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct BitStringFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/scalar/nested_functions.hpp

@@ -80,6 +80,18 @@ struct MapFromEntriesFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct MapEntriesFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct MapValuesFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct MapKeysFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct MapExtractFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };

package/src/duckdb/src/include/duckdb/function/scalar_function.hpp

@@ -29,13 +29,13 @@ class ScalarFunctionCatalogEntry;
 
 struct FunctionStatisticsInput {
 	FunctionStatisticsInput(BoundFunctionExpression &expr_p, FunctionData *bind_data_p,
-	                        vector<unique_ptr<BaseStatistics>> &child_stats_p, unique_ptr<Expression> *expr_ptr_p)
+	                        vector<BaseStatistics> &child_stats_p, unique_ptr<Expression> *expr_ptr_p)
 	    : expr(expr_p), bind_data(bind_data_p), child_stats(child_stats_p), expr_ptr(expr_ptr_p) {
 	}
 
 	BoundFunctionExpression &expr;
 	FunctionData *bind_data;
-	vector<unique_ptr<BaseStatistics>> &child_stats;
+	vector<BaseStatistics> &child_stats;
 	unique_ptr<Expression> *expr_ptr;
 };