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

package/binding.gyp

@@ -57,6 +57,7 @@
                 "src/duckdb/ub_src_function.cpp", 
                 "src/duckdb/ub_src_function_cast.cpp", 
                 "src/duckdb/ub_src_function_pragma.cpp", 
+                "src/duckdb/ub_src_function_scalar_bit.cpp", 
                 "src/duckdb/ub_src_function_scalar_blob.cpp", 
                 "src/duckdb/ub_src_function_scalar_date.cpp", 
                 "src/duckdb/ub_src_function_scalar.cpp", 
@@ -223,6 +224,7 @@
                 "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
                 "src/duckdb/extension/icu/./icu-dateadd.cpp", 
+                "src/duckdb/extension/icu/./icu-table-range.cpp", 
                 "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
                 "src/duckdb/extension/icu/./icu-strptime.cpp", 
                 "src/duckdb/extension/icu/./icu-datefunc.cpp", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev16.0",
+  "version": "0.7.2-dev314.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

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

@@ -13,6 +13,7 @@
 #include "include/icu-datesub.hpp"
 #include "include/icu-datetrunc.hpp"
 #include "include/icu-makedate.hpp"
+#include "include/icu-table-range.hpp"
 #include "include/icu-strptime.hpp"
 #include "include/icu-timebucket.hpp"
 #include "include/icu-timezone.hpp"
@@ -266,6 +267,7 @@ void ICUExtension::Load(DuckDB &db) {
 	RegisterICUDateSubFunctions(*con.context);
 	RegisterICUDateTruncFunctions(*con.context);
 	RegisterICUMakeDateFunctions(*con.context);
+	RegisterICUTableRangeFunctions(*con.context);
 	RegisterICUStrptimeFunctions(*con.context);
 	RegisterICUTimeBucketFunctions(*con.context);
 	RegisterICUTimeZoneFunctions(*con.context);

package/src/duckdb/extension/icu/icu-table-range.cpp

@@ -0,0 +1,194 @@
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/interval.hpp"
+#include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/function/table_function.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+#include "include/icu-datefunc.hpp"
+#include "unicode/calendar.h"
+
+namespace duckdb {
+
+struct ICUTableRange {
+	using CalendarPtr = unique_ptr<icu::Calendar>;
+
+	struct BindData : public TableFunctionData {
+		explicit BindData(const BindData &other)
+		    : tz_setting(other.tz_setting), cal_setting(other.cal_setting), calendar(other.calendar->clone()),
+		      start(other.start), end(other.end), increment(other.increment), inclusive_bound(other.inclusive_bound),
+		      greater_than_check(other.greater_than_check) {
+		}
+
+		BindData(ClientContext &context) {
+			Value tz_value;
+			if (context.TryGetCurrentSetting("TimeZone", tz_value)) {
+				tz_setting = tz_value.ToString();
+			}
+			auto tz = icu::TimeZone::createTimeZone(icu::UnicodeString::fromUTF8(icu::StringPiece(tz_setting)));
+
+			string cal_id("@calendar=");
+			Value cal_value;
+			if (context.TryGetCurrentSetting("Calendar", cal_value)) {
+				cal_setting = cal_value.ToString();
+				cal_id += cal_setting;
+			} else {
+				cal_id += "gregorian";
+			}
+
+			icu::Locale locale(cal_id.c_str());
+
+			UErrorCode success = U_ZERO_ERROR;
+			calendar.reset(icu::Calendar::createInstance(tz, locale, success));
+			if (U_FAILURE(success)) {
+				throw Exception("Unable to create ICU calendar.");
+			}
+		}
+
+		string tz_setting;
+		string cal_setting;
+		CalendarPtr calendar;
+
+		timestamp_t start;
+		timestamp_t end;
+		interval_t increment;
+		bool inclusive_bound;
+		bool greater_than_check;
+
+		bool Equals(const FunctionData &other_p) const {
+			auto &other = (const BindData &)other_p;
+			return other.start == start && other.end == end && other.increment == increment &&
+			       other.inclusive_bound == inclusive_bound && other.greater_than_check == greater_than_check &&
+			       *calendar == *other.calendar;
+		}
+
+		unique_ptr<FunctionData> Copy() const {
+			return make_unique<BindData>(*this);
+		}
+
+		bool Finished(timestamp_t current_value) {
+			if (greater_than_check) {
+				if (inclusive_bound) {
+					return current_value > end;
+				} else {
+					return current_value >= end;
+				}
+			} else {
+				if (inclusive_bound) {
+					return current_value < end;
+				} else {
+					return current_value <= end;
+				}
+			}
+		}
+	};
+
+	template <bool GENERATE_SERIES>
+	static unique_ptr<FunctionData> Bind(ClientContext &context, TableFunctionBindInput &input,
+	                                     vector<LogicalType> &return_types, vector<string> &names) {
+		auto result = make_unique<BindData>(context);
+
+		auto &inputs = input.inputs;
+		D_ASSERT(inputs.size() == 3);
+		result->start = inputs[0].GetValue<timestamp_t>();
+		result->end = inputs[1].GetValue<timestamp_t>();
+		result->increment = inputs[2].GetValue<interval_t>();
+
+		// Infinities either cause errors or infinite loops, so just ban them
+		if (!Timestamp::IsFinite(result->start) || !Timestamp::IsFinite(result->end)) {
+			throw BinderException("RANGE with infinite bounds is not supported");
+		}
+
+		if (result->increment.months == 0 && result->increment.days == 0 && result->increment.micros == 0) {
+			throw BinderException("interval cannot be 0!");
+		}
+		// all elements should point in the same direction
+		if (result->increment.months > 0 || result->increment.days > 0 || result->increment.micros > 0) {
+			if (result->increment.months < 0 || result->increment.days < 0 || result->increment.micros < 0) {
+				throw BinderException("RANGE with composite interval that has mixed signs is not supported");
+			}
+			result->greater_than_check = true;
+			if (result->start > result->end) {
+				throw BinderException(
+				    "start is bigger than end, but increment is positive: cannot generate infinite series");
+			}
+		} else {
+			result->greater_than_check = false;
+			if (result->start < result->end) {
+				throw BinderException(
+				    "start is smaller than end, but increment is negative: cannot generate infinite series");
+			}
+		}
+		return_types.push_back(inputs[0].type());
+		if (GENERATE_SERIES) {
+			// generate_series has inclusive bounds on the RHS
+			result->inclusive_bound = true;
+			names.emplace_back("generate_series");
+		} else {
+			result->inclusive_bound = false;
+			names.emplace_back("range");
+		}
+		return std::move(result);
+	}
+
+	struct State : public GlobalTableFunctionState {
+		explicit State(timestamp_t start_p) : current_state(start_p) {
+		}
+
+		timestamp_t current_state;
+		bool finished = false;
+	};
+
+	static unique_ptr<GlobalTableFunctionState> Init(ClientContext &context, TableFunctionInitInput &input) {
+		auto &bind_data = (BindData &)*input.bind_data;
+		return make_unique<State>(bind_data.start);
+	}
+
+	static void ICUTableRangeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+		auto &bind_data = (BindData &)*data_p.bind_data;
+		CalendarPtr calendar_ptr(bind_data.calendar->clone());
+		auto calendar = calendar_ptr.get();
+		auto &state = (State &)*data_p.global_state;
+		if (state.finished) {
+			return;
+		}
+
+		idx_t size = 0;
+		auto data = FlatVector::GetData<timestamp_t>(output.data[0]);
+		while (true) {
+			data[size++] = state.current_state;
+			state.current_state = ICUDateFunc::Add(calendar, state.current_state, bind_data.increment);
+			if (bind_data.Finished(state.current_state)) {
+				state.finished = true;
+				break;
+			}
+			if (size >= STANDARD_VECTOR_SIZE) {
+				break;
+			}
+		}
+		output.SetCardinality(size);
+	}
+
+	static void AddICUTableRangeFunction(ClientContext &context) {
+		auto &catalog = Catalog::GetSystemCatalog(context);
+
+		TableFunctionSet range("range");
+		range.AddFunction(TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                                ICUTableRangeFunction, Bind<false>, Init));
+		CreateTableFunctionInfo range_func_info(range);
+		catalog.AddFunction(context, &range_func_info);
+
+		// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
+		TableFunctionSet generate_series("generate_series");
+		generate_series.AddFunction(
+		    TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                  ICUTableRangeFunction, Bind<true>, Init));
+		CreateTableFunctionInfo generate_series_func_info(generate_series);
+		catalog.AddFunction(context, &generate_series_func_info);
+	}
+};
+
+void RegisterICUTableRangeFunctions(ClientContext &context) {
+	ICUTableRange::AddICUTableRangeFunction(context);
+}
+
+} // namespace duckdb

package/src/duckdb/extension/icu/include/icu-table-range.hpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// icu-table-range.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb.hpp"
+
+namespace duckdb {
+
+void RegisterICUTableRangeFunctions(ClientContext &context);
+
+} // namespace duckdb

package/src/duckdb/extension/parquet/column_reader.cpp

@@ -865,7 +865,7 @@ RowNumberColumnReader::RowNumberColumnReader(ParquetReader &reader, LogicalType
 
 unique_ptr<BaseStatistics> RowNumberColumnReader::Stats(idx_t row_group_idx_p,
                                                         const std::vector<ColumnChunk> &columns) {
-	auto stats = make_unique<NumericStatistics>(type, StatisticsType::LOCAL_STATS);
+	auto stats = NumericStats::CreateUnknown(type);
 	auto &row_groups = reader.GetFileMetadata()->row_groups;
 	D_ASSERT(row_group_idx_p < row_groups.size());
 	idx_t row_group_offset_min = 0;
@@ -873,11 +873,10 @@ unique_ptr<BaseStatistics> RowNumberColumnReader::Stats(idx_t row_group_idx_p,
 		row_group_offset_min += row_groups[i].num_rows;
 	}
 
-	stats->min = Value::BIGINT(row_group_offset_min);
-	stats->max = Value::BIGINT(row_group_offset_min + row_groups[row_group_idx_p].num_rows);
-
-	D_ASSERT(!stats->CanHaveNull() && stats->CanHaveNoNull());
-	return std::move(stats);
+	NumericStats::SetMin(stats, Value::BIGINT(row_group_offset_min));
+	NumericStats::SetMax(stats, Value::BIGINT(row_group_offset_min + row_groups[row_group_idx_p].num_rows));
+	stats.Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
+	return stats.ToUnique();
 }
 
 void RowNumberColumnReader::InitializeRead(idx_t row_group_idx_p, const std::vector<ColumnChunk> &columns,

package/src/duckdb/extension/parquet/column_writer.cpp

@@ -1994,7 +1994,6 @@ unique_ptr<ColumnWriter> ColumnWriter::CreateWriterRecursive(vector<duckdb_parqu
 			                                             max_define, can_have_nulls);
 		}
 	case LogicalTypeId::BLOB:
-	case LogicalTypeId::BIT:
 	case LogicalTypeId::VARCHAR:
 		return make_unique<StringColumnWriter>(writer, schema_idx, std::move(schema_path), max_repeat, max_define,
 		                                       can_have_nulls);

package/src/duckdb/extension/parquet/include/column_reader.hpp

@@ -18,8 +18,7 @@
 
 #include "duckdb.hpp"
 #ifndef DUCKDB_AMALGAMATION
-#include "duckdb/storage/statistics/string_statistics.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
+
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/types/chunk_collection.hpp"

package/src/duckdb/extension/parquet/include/generated_column_reader.hpp

@@ -29,17 +29,7 @@ public:
 	           Vector &result) override;
 
 	unique_ptr<BaseStatistics> Stats(idx_t row_group_idx_p, const std::vector<ColumnChunk> &columns) override {
-		switch (type.id()) {
-		case LogicalTypeId::VARCHAR: {
-			auto string_stats = make_unique<StringStatistics>(type, StatisticsType::LOCAL_STATS);
-			string string = constant.ToString();
-			string_stats->Update(string);
-			string_stats->max_string_length = string.length();
-			return std::move(string_stats);
-		}
-		default:
-			return nullptr;
-		}
+		return BaseStatistics::FromConstant(constant).ToUnique();
 	};
 
 	void InitializeRead(idx_t row_group_idx_p, const std::vector<ColumnChunk> &columns,

package/src/duckdb/extension/parquet/parquet-extension.cpp

@@ -368,7 +368,10 @@ public:
 		if (!config.options.enable_external_access) {
 			throw PermissionException("Scanning Parquet files is disabled through configuration");
 		}
-		auto file_name = input.inputs[0].GetValue<string>();
+		if (input.inputs[0].IsNull()) {
+			throw ParserException("Parquet reader cannot take NULL list as parameter");
+		}
+		auto file_name = StringValue::Get(input.inputs[0]);
 		ParquetOptions parquet_options(context);
 		for (auto &kv : input.named_parameters) {
 			auto loption = StringUtil::Lower(kv.first);
@@ -395,10 +398,16 @@ public:
 		if (!config.options.enable_external_access) {
 			throw PermissionException("Scanning Parquet files is disabled through configuration");
 		}
+		if (input.inputs[0].IsNull()) {
+			throw ParserException("Parquet reader cannot take NULL list as parameter");
+		}
 		FileSystem &fs = FileSystem::GetFileSystem(context);
 		vector<string> files;
 		for (auto &val : ListValue::GetChildren(input.inputs[0])) {
-			auto glob_files = ParquetGlob(fs, val.ToString(), context);
+			if (val.IsNull()) {
+				throw ParserException("Parquet reader cannot take NULL input as parameter");
+			}
+			auto glob_files = ParquetGlob(fs, StringValue::Get(val), context);
 			files.insert(files.end(), glob_files.begin(), glob_files.end());
 		}
 		if (files.empty()) {

package/src/duckdb/extension/parquet/parquet_statistics.cpp

@@ -6,8 +6,7 @@
 #ifndef DUCKDB_AMALGAMATION
 #include "duckdb/common/types/blob.hpp"
 #include "duckdb/common/types/value.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
+
 #endif
 
 namespace duckdb {
@@ -18,27 +17,29 @@ using duckdb_parquet::format::Type;
 static unique_ptr<BaseStatistics> CreateNumericStats(const LogicalType &type,
                                                      const duckdb_parquet::format::SchemaElement &schema_ele,
                                                      const duckdb_parquet::format::Statistics &parquet_stats) {
-	auto stats = make_unique<NumericStatistics>(type, StatisticsType::LOCAL_STATS);
+	auto stats = NumericStats::CreateUnknown(type);
 
 	// for reasons unknown to science, Parquet defines *both* `min` and `min_value` as well as `max` and
 	// `max_value`. All are optional. such elegance.
+	Value min;
+	Value max;
 	if (parquet_stats.__isset.min) {
-		stats->min = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min).DefaultCastAs(type);
+		min = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min).DefaultCastAs(type);
 	} else if (parquet_stats.__isset.min_value) {
-		stats->min =
-		    ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min_value).DefaultCastAs(type);
+		min = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min_value).DefaultCastAs(type);
 	} else {
-		stats->min = Value(type);
+		min = Value(type);
 	}
 	if (parquet_stats.__isset.max) {
-		stats->max = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max).DefaultCastAs(type);
+		max = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max).DefaultCastAs(type);
 	} else if (parquet_stats.__isset.max_value) {
-		stats->max =
-		    ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max_value).DefaultCastAs(type);
+		max = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max_value).DefaultCastAs(type);
 	} else {
-		stats->max = Value(type);
+		max = Value(type);
 	}
-	return std::move(stats);
+	NumericStats::SetMin(stats, min);
+	NumericStats::SetMax(stats, max);
+	return stats.ToUnique();
 }
 
 Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
@@ -228,24 +229,24 @@ unique_ptr<BaseStatistics> ParquetStatisticsUtils::TransformColumnStatistics(con
 		row_group_stats = CreateNumericStats(type, s_ele, parquet_stats);
 		break;
 	case LogicalTypeId::VARCHAR: {
-		auto string_stats = make_unique<StringStatistics>(type, StatisticsType::LOCAL_STATS);
+		auto string_stats = StringStats::CreateEmpty(type);
 		if (parquet_stats.__isset.min) {
-			string_stats->Update(parquet_stats.min);
+			StringStats::Update(string_stats, parquet_stats.min);
 		} else if (parquet_stats.__isset.min_value) {
-			string_stats->Update(parquet_stats.min_value);
+			StringStats::Update(string_stats, parquet_stats.min_value);
 		} else {
 			return nullptr;
 		}
 		if (parquet_stats.__isset.max) {
-			string_stats->Update(parquet_stats.max);
+			StringStats::Update(string_stats, parquet_stats.max);
 		} else if (parquet_stats.__isset.max_value) {
-			string_stats->Update(parquet_stats.max_value);
+			StringStats::Update(string_stats, parquet_stats.max_value);
 		} else {
 			return nullptr;
 		}
-		string_stats->has_unicode = true; // we dont know better
-		string_stats->max_string_length = NumericLimits<uint32_t>::Maximum();
-		row_group_stats = std::move(string_stats);
+		StringStats::SetContainsUnicode(string_stats);
+		StringStats::ResetMaxStringLength(string_stats);
+		row_group_stats = string_stats.ToUnique();
 		break;
 	}
 	default:
@@ -254,21 +255,14 @@ unique_ptr<BaseStatistics> ParquetStatisticsUtils::TransformColumnStatistics(con
 	} // end of type switch
 
 	// null count is generic
-	if (row_group_stats) {
-		if (column_chunk.meta_data.type == duckdb_parquet::format::Type::FLOAT ||
-		    column_chunk.meta_data.type == duckdb_parquet::format::Type::DOUBLE) {
-			// floats/doubles can have infinity, which can become NULL
-			row_group_stats->validity_stats = make_unique<ValidityStatistics>(true);
-		} else if (parquet_stats.__isset.null_count) {
-			row_group_stats->validity_stats = make_unique<ValidityStatistics>(parquet_stats.null_count != 0);
-		} else {
-			row_group_stats->validity_stats = make_unique<ValidityStatistics>(true);
-		}
-	} else {
+	if (!row_group_stats) {
 		// if stats are missing from any row group we know squat
 		return nullptr;
 	}
-
+	row_group_stats->Set(StatsInfo::CAN_HAVE_NULL_AND_VALID_VALUES);
+	if (parquet_stats.__isset.null_count && parquet_stats.null_count == 0) {
+		row_group_stats->Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
+	}
 	return row_group_stats;
 }
 

package/src/duckdb/src/catalog/catalog_entry/duck_schema_entry.cpp

@@ -145,6 +145,10 @@ CatalogEntry *DuckSchemaEntry::CreateFunction(CatalogTransaction transaction, Cr
 		function = make_unique_base<StandardEntry, ScalarFunctionCatalogEntry>(catalog, this,
 		                                                                       (CreateScalarFunctionInfo *)info);
 		break;
+	case CatalogType::TABLE_FUNCTION_ENTRY:
+		function =
+		    make_unique_base<StandardEntry, TableFunctionCatalogEntry>(catalog, this, (CreateTableFunctionInfo *)info);
+		break;
 	case CatalogType::MACRO_ENTRY:
 		// create a macro function
 		function = make_unique_base<StandardEntry, ScalarMacroCatalogEntry>(catalog, this, (CreateMacroInfo *)info);

package/src/duckdb/src/catalog/catalog_entry/scalar_function_catalog_entry.cpp

@@ -1,5 +1,5 @@
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/parser/parsed_data/alter_function_info.hpp"
+#include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp"
 
 namespace duckdb {
 
@@ -9,14 +9,15 @@ ScalarFunctionCatalogEntry::ScalarFunctionCatalogEntry(Catalog *catalog, SchemaC
 }
 
 unique_ptr<CatalogEntry> ScalarFunctionCatalogEntry::AlterEntry(ClientContext &context, AlterInfo *info) {
-	if (info->type != AlterType::ALTER_FUNCTION) {
+	if (info->type != AlterType::ALTER_SCALAR_FUNCTION) {
 		throw InternalException("Attempting to alter ScalarFunctionCatalogEntry with unsupported alter type");
 	}
-	auto &function_info = (AlterFunctionInfo &)*info;
-	if (function_info.alter_function_type != AlterFunctionType::ADD_FUNCTION_OVERLOADS) {
-		throw InternalException("Attempting to alter ScalarFunctionCatalogEntry with unsupported alter function type");
+	auto &function_info = (AlterScalarFunctionInfo &)*info;
+	if (function_info.alter_scalar_function_type != AlterScalarFunctionType::ADD_FUNCTION_OVERLOADS) {
+		throw InternalException(
+		    "Attempting to alter ScalarFunctionCatalogEntry with unsupported alter scalar function type");
 	}
-	auto &add_overloads = (AddFunctionOverloadInfo &)function_info;
+	auto &add_overloads = (AddScalarFunctionOverloadInfo &)function_info;
 
 	ScalarFunctionSet new_set = functions;
 	if (!new_set.MergeFunctionSet(add_overloads.new_overloads)) {

package/src/duckdb/src/catalog/catalog_entry/table_function_catalog_entry.cpp

@@ -1,5 +1,5 @@
 #include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+#include "duckdb/parser/parsed_data/alter_table_function_info.hpp"
 
 namespace duckdb {
 
@@ -10,4 +10,23 @@ TableFunctionCatalogEntry::TableFunctionCatalogEntry(Catalog *catalog, SchemaCat
 	D_ASSERT(this->functions.Size() > 0);
 }
 
+unique_ptr<CatalogEntry> TableFunctionCatalogEntry::AlterEntry(ClientContext &context, AlterInfo *info) {
+	if (info->type != AlterType::ALTER_TABLE_FUNCTION) {
+		throw InternalException("Attempting to alter TableFunctionCatalogEntry with unsupported alter type");
+	}
+	auto &function_info = (AlterTableFunctionInfo &)*info;
+	if (function_info.alter_table_function_type != AlterTableFunctionType::ADD_FUNCTION_OVERLOADS) {
+		throw InternalException(
+		    "Attempting to alter TableFunctionCatalogEntry with unsupported alter table function type");
+	}
+	auto &add_overloads = (AddTableFunctionOverloadInfo &)function_info;
+
+	TableFunctionSet new_set = functions;
+	if (!new_set.MergeFunctionSet(add_overloads.new_overloads)) {
+		throw BinderException("Failed to add new function overloads to function \"%s\": function already exists", name);
+	}
+	CreateTableFunctionInfo new_info(std::move(new_set));
+	return make_unique<TableFunctionCatalogEntry>(catalog, schema, &new_info);
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/enums/statement_type.cpp

@@ -59,6 +59,8 @@ string StatementTypeToString(StatementType type) {
 		return "ATTACH";
 	case StatementType::DETACH_STATEMENT:
 		return "DETACH";
+	case StatementType::MULTI_STATEMENT:
+		return "MULTI";
 	case StatementType::INVALID_STATEMENT:
 		break;
 	}

package/src/duckdb/src/common/sort/sort_state.cpp

@@ -3,7 +3,6 @@
 #include "duckdb/common/row_operations/row_operations.hpp"
 #include "duckdb/common/sort/sort.hpp"
 #include "duckdb/common/sort/sorted_block.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
 
 #include <algorithm>
 #include <numeric>
@@ -66,9 +65,8 @@ SortLayout::SortLayout(const vector<BoundOrderByNode> &orders)
 			prefix_lengths.back() = GetNestedSortingColSize(col_size, expr.return_type);
 		} else if (physical_type == PhysicalType::VARCHAR) {
 			idx_t size_before = col_size;
-			if (stats.back()) {
-				auto &str_stats = (StringStatistics &)*stats.back();
-				col_size += str_stats.max_string_length;
+			if (stats.back() && StringStats::HasMaxStringLength(*stats.back())) {
+				col_size += StringStats::MaxStringLength(*stats.back());
 				if (col_size > 12) {
 					col_size = 12;
 				} else {
@@ -95,9 +93,9 @@ SortLayout::SortLayout(const vector<BoundOrderByNode> &orders)
 			if (bytes_to_fill == 0) {
 				break;
 			}
-			if (logical_types[col_idx].InternalType() == PhysicalType::VARCHAR && stats[col_idx]) {
-				auto &str_stats = (StringStatistics &)*stats[col_idx];
-				idx_t diff = str_stats.max_string_length - prefix_lengths[col_idx];
+			if (logical_types[col_idx].InternalType() == PhysicalType::VARCHAR && stats[col_idx] &&
+			    StringStats::HasMaxStringLength(*stats[col_idx])) {
+				idx_t diff = StringStats::MaxStringLength(*stats[col_idx]) - prefix_lengths[col_idx];
 				if (diff > 0) {
 					// Increase all sizes accordingly
 					idx_t increase = MinValue(bytes_to_fill, diff);