duckdb 0.7.2-dev12.0 → 0.7.2-dev1244.0

package/src/duckdb/src/function/scalar/string/regexp/regexp_util.cpp

@@ -0,0 +1,79 @@
+#include "duckdb/function/scalar/regexp.hpp"
+#include "duckdb/execution/expression_executor.hpp"
+
+namespace duckdb {
+
+namespace regexp_util {
+
+bool TryParseConstantPattern(ClientContext &context, Expression &expr, string &constant_string) {
+	if (!expr.IsFoldable()) {
+		return false;
+	}
+	Value pattern_str = ExpressionExecutor::EvaluateScalar(context, expr);
+	if (!pattern_str.IsNull() && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
+		constant_string = StringValue::Get(pattern_str);
+		return true;
+	}
+	return false;
+}
+
+void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result, bool *global_replace) {
+	for (idx_t i = 0; i < options.size(); i++) {
+		switch (options[i]) {
+		case 'c':
+			// case-sensitive matching
+			result.set_case_sensitive(true);
+			break;
+		case 'i':
+			// case-insensitive matching
+			result.set_case_sensitive(false);
+			break;
+		case 'l':
+			// literal matching
+			result.set_literal(true);
+			break;
+		case 'm':
+		case 'n':
+		case 'p':
+			// newline-sensitive matching
+			result.set_dot_nl(false);
+			break;
+		case 's':
+			// non-newline-sensitive matching
+			result.set_dot_nl(true);
+			break;
+		case 'g':
+			// global replace, only available for regexp_replace
+			if (global_replace) {
+				*global_replace = true;
+			} else {
+				throw InvalidInputException("Option 'g' (global replace) is only valid for regexp_replace");
+			}
+			break;
+		case ' ':
+		case '\t':
+		case '\n':
+			// ignore whitespace
+			break;
+		default:
+			throw InvalidInputException("Unrecognized Regex option %c", options[i]);
+		}
+	}
+}
+
+void ParseRegexOptions(ClientContext &context, Expression &expr, RE2::Options &target, bool *global_replace) {
+	if (expr.HasParameter()) {
+		throw ParameterNotResolvedException();
+	}
+	if (!expr.IsFoldable()) {
+		throw InvalidInputException("Regex options field must be a constant");
+	}
+	Value options_str = ExpressionExecutor::EvaluateScalar(context, expr);
+	if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
+		ParseRegexOptions(StringValue::Get(options_str), target, global_replace);
+	}
+}
+
+} // namespace regexp_util
+
+} // namespace duckdb

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

@@ -12,6 +12,11 @@
 
 namespace duckdb {
 
+using regexp_util::CreateStringPiece;
+using regexp_util::Extract;
+using regexp_util::ParseRegexOptions;
+using regexp_util::TryParseConstantPattern;
+
 static bool RegexOptionsEquals(const duckdb_re2::RE2::Options &opt_a, const duckdb_re2::RE2::Options &opt_b) {
 	return opt_a.case_sensitive() == opt_b.case_sensitive();
 }
@@ -32,10 +37,6 @@ bool RegexpBaseBindData::Equals(const FunctionData &other_p) const {
 	       RegexOptionsEquals(options, other.options);
 }
 
-static inline duckdb_re2::StringPiece CreateStringPiece(string_t &input) {
-	return duckdb_re2::StringPiece(input.GetDataUnsafe(), input.GetSize());
-}
-
 unique_ptr<FunctionLocalState> RegexInitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
                                                    FunctionData *bind_data) {
 	auto &info = (RegexpBaseBindData &)*bind_data;
@@ -45,75 +46,6 @@ unique_ptr<FunctionLocalState> RegexInitLocalState(ExpressionState &state, const
 	return nullptr;
 }
 
-static void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result, bool *global_replace = nullptr) {
-	for (idx_t i = 0; i < options.size(); i++) {
-		switch (options[i]) {
-		case 'c':
-			// case-sensitive matching
-			result.set_case_sensitive(true);
-			break;
-		case 'i':
-			// case-insensitive matching
-			result.set_case_sensitive(false);
-			break;
-		case 'l':
-			// literal matching
-			result.set_literal(true);
-			break;
-		case 'm':
-		case 'n':
-		case 'p':
-			// newline-sensitive matching
-			result.set_dot_nl(false);
-			break;
-		case 's':
-			// non-newline-sensitive matching
-			result.set_dot_nl(true);
-			break;
-		case 'g':
-			// global replace, only available for regexp_replace
-			if (global_replace) {
-				*global_replace = true;
-			} else {
-				throw InvalidInputException("Option 'g' (global replace) is only valid for regexp_replace");
-			}
-			break;
-		case ' ':
-		case '\t':
-		case '\n':
-			// ignore whitespace
-			break;
-		default:
-			throw InvalidInputException("Unrecognized Regex option %c", options[i]);
-		}
-	}
-}
-
-void ParseRegexOptions(ClientContext &context, Expression &expr, RE2::Options &target, bool *global_replace = nullptr) {
-	if (expr.HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (!expr.IsFoldable()) {
-		throw InvalidInputException("Regex options field must be a constant");
-	}
-	Value options_str = ExpressionExecutor::EvaluateScalar(context, expr);
-	if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
-		ParseRegexOptions(StringValue::Get(options_str), target, global_replace);
-	}
-}
-
-static bool TryParseConstantPattern(ClientContext &context, Expression &expr, string &constant_string) {
-	if (!expr.IsFoldable()) {
-		return false;
-	}
-	Value pattern_str = ExpressionExecutor::EvaluateScalar(context, expr);
-	if (!pattern_str.IsNull() && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
-		constant_string = StringValue::Get(pattern_str);
-		return true;
-	}
-	return false;
-}
-
 //===--------------------------------------------------------------------===//
 // Regexp Matches
 //===--------------------------------------------------------------------===//
@@ -321,13 +253,6 @@ static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarF
 	                                          std::move(group_string));
 }
 
-inline static string_t Extract(const string_t &input, Vector &result, const RE2 &re,
-                               const duckdb_re2::StringPiece &rewrite) {
-	std::string extracted;
-	RE2::Extract(input.GetString(), re, rewrite, &extracted);
-	return StringVector::AddString(result, extracted.c_str(), extracted.size());
-}
-
 static void RegexExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = (BoundFunctionExpression &)state.expr;
 	const auto &info = (RegexpExtractBindData &)*func_expr.bind_info;
@@ -391,10 +316,26 @@ void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	    RegexExtractFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
 	    FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
 
+	ScalarFunctionSet regexp_extract_all("regexp_extract_all");
+	regexp_extract_all.AddFunction(ScalarFunction(
+	    {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::LIST(LogicalType::VARCHAR),
+	    RegexpExtractAll::Execute, RegexpExtractAll::Bind, nullptr, nullptr, RegexpExtractAll::InitLocalState,
+	    LogicalType::INVALID, FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	regexp_extract_all.AddFunction(ScalarFunction(
+	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::LIST(LogicalType::VARCHAR),
+	    RegexpExtractAll::Execute, RegexpExtractAll::Bind, nullptr, nullptr, RegexpExtractAll::InitLocalState,
+	    LogicalType::INVALID, FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	regexp_extract_all.AddFunction(
+	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR},
+	                   LogicalType::LIST(LogicalType::VARCHAR), RegexpExtractAll::Execute, RegexpExtractAll::Bind,
+	                   nullptr, nullptr, RegexpExtractAll::InitLocalState, LogicalType::INVALID,
+	                   FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+
 	set.AddFunction(regexp_full_match);
 	set.AddFunction(regexp_partial_match);
 	set.AddFunction(regexp_replace);
 	set.AddFunction(regexp_extract);
+	set.AddFunction(regexp_extract_all);
 }
 
 } // namespace duckdb

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

@@ -45,11 +45,13 @@ void BuiltinFunctions::RegisterStringFunctions() {
 	// blob functions
 	Register<Base64Fun>();
 	Register<EncodeFun>();
+	Register<HexFun>();
 
 	// bit functions
 	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 {
 
@@ -96,21 +96,16 @@ static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, Scalar
 	}
 
 	bound_function.return_type = return_type;
-	return make_unique<StructExtractBindData>(key, key_index, return_type);
+	return make_unique<StructExtractBindData>(std::move(key), key_index, std::move(return_type));
 }
 
 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 {
@@ -74,29 +74,26 @@ static unique_ptr<FunctionData> StructInsertBind(ClientContext &context, ScalarF
 	}
 
 	// this is more for completeness reasons
-	bound_function.return_type = LogicalType::STRUCT(std::move(new_struct_children));
+	bound_function.return_type = LogicalType::STRUCT(new_struct_children);
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
 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 {
@@ -54,19 +54,18 @@ static unique_ptr<FunctionData> StructPackBind(ClientContext &context, ScalarFun
 	}
 
 	// this is more for completeness reasons
-	bound_function.return_type = LogicalType::STRUCT(std::move(struct_children));
+	bound_function.return_type = LogicalType::STRUCT(struct_children);
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
 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/arrow.cpp

@@ -101,6 +101,9 @@ LogicalType ArrowTableFunction::GetArrowLogicalType(
 	} else if (format == "tiM") {
 		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MONTHS);
 		return LogicalType::INTERVAL;
+	} else if (format == "tin") {
+		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MONTH_DAY_NANO);
+		return LogicalType::INTERVAL;
 	} else if (format == "+l") {
 		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
 		auto child_type = GetArrowLogicalType(*schema.children[0], arrow_convert_data, col_idx);
@@ -114,14 +117,14 @@ LogicalType ArrowTableFunction::GetArrowLogicalType(
 		idx_t fixed_size = std::stoi(parameters);
 		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::FIXED_SIZE, fixed_size);
 		auto child_type = GetArrowLogicalType(*schema.children[0], arrow_convert_data, col_idx);
-		return LogicalType::LIST(std::move(child_type));
+		return LogicalType::LIST(child_type);
 	} else if (format == "+s") {
 		child_list_t<LogicalType> child_types;
 		for (idx_t type_idx = 0; type_idx < (idx_t)schema.n_children; type_idx++) {
 			auto child_type = GetArrowLogicalType(*schema.children[type_idx], arrow_convert_data, col_idx);
 			child_types.push_back({schema.children[type_idx]->name, child_type});
 		}
-		return LogicalType::STRUCT(std::move(child_types));
+		return LogicalType::STRUCT(child_types);
 
 	} else if (format == "+m") {
 		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);

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

@@ -20,7 +20,13 @@ void ShiftRight(unsigned char *ar, int size, int shift) {
 
 void GetValidityMask(ValidityMask &mask, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
                      int64_t nested_offset = -1, bool add_null = false) {
-	if (array.null_count != 0 && array.buffers[0]) {
+	// In certains we don't need to or cannot copy arrow's validity mask to duckdb.
+	//
+	// The conditions where we do want to copy arrow's mask to duckdb are:
+	// 1. nulls exist
+	// 2. n_buffers > 0, meaning the array's arrow type is not `null`
+	// 3. the validity buffer (the first buffer) is not a nullptr
+	if (array.null_count != 0 && array.n_buffers > 0 && array.buffers[0]) {
 		auto bit_offset = scan_state.chunk_offset + array.offset;
 		if (nested_offset != -1) {
 			bit_offset = nested_offset;
@@ -316,6 +322,20 @@ void IntervalConversionMonths(Vector &vector, ArrowArray &array, ArrowScanLocalS
 	}
 }
 
+void IntervalConversionMonthDayNanos(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state,
+                                     int64_t nested_offset, idx_t size) {
+	auto tgt_ptr = (interval_t *)FlatVector::GetData(vector);
+	auto src_ptr = (ArrowInterval *)array.buffers[1] + scan_state.chunk_offset + array.offset;
+	if (nested_offset != -1) {
+		src_ptr = (ArrowInterval *)array.buffers[1] + nested_offset + array.offset;
+	}
+	for (idx_t row = 0; row < size; row++) {
+		tgt_ptr[row].days = src_ptr[row].days;
+		tgt_ptr[row].micros = src_ptr[row].nanoseconds / Interval::NANOS_PER_MICRO;
+		tgt_ptr[row].months = src_ptr[row].months;
+	}
+}
+
 void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
                          std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
                          std::pair<idx_t, idx_t> &arrow_convert_idx, int64_t nested_offset, ValidityMask *parent_mask) {
@@ -509,6 +529,10 @@ void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState
 			IntervalConversionMonths(vector, array, scan_state, nested_offset, size);
 			break;
 		}
+		case ArrowDateTimeType::MONTH_DAY_NANO: {
+			IntervalConversionMonthDayNanos(vector, array, scan_state, nested_offset, size);
+			break;
+		}
 		default:
 			throw std::runtime_error("Unsupported precision for Interval/Duration Type ");
 		}

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

@@ -32,7 +32,11 @@ static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, TableFunc
 	AttachedDatabase *db;
 	auto &db_manager = DatabaseManager::Get(context);
 	if (!input.inputs.empty()) {
-		db = db_manager.GetDatabase(context, StringValue::Get(input.inputs[0]));
+		auto &db_name = StringValue::Get(input.inputs[0]);
+		db = db_manager.GetDatabase(context, db_name);
+		if (!db) {
+			throw BinderException("Database \"%s\" not found", db_name);
+		}
 	} else {
 		db = db_manager.GetDatabase(context, DatabaseManager::GetDefaultDatabase(context));
 	}

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) {
@@ -50,6 +53,25 @@ void ReadCSVData::FinalizeRead(ClientContext &context) {
 	}
 }
 
+uint8_t GetCandidateSpecificity(const LogicalType &candidate_type) {
+	//! Const ht with accepted auto_types and their weights in specificity
+	const duckdb::unordered_map<uint8_t, uint8_t> auto_type_candidates_specificity {
+	    {(uint8_t)LogicalTypeId::VARCHAR, 0},  {(uint8_t)LogicalTypeId::TIMESTAMP, 1},
+	    {(uint8_t)LogicalTypeId::DATE, 2},     {(uint8_t)LogicalTypeId::TIME, 3},
+	    {(uint8_t)LogicalTypeId::DOUBLE, 4},   {(uint8_t)LogicalTypeId::FLOAT, 5},
+	    {(uint8_t)LogicalTypeId::BIGINT, 6},   {(uint8_t)LogicalTypeId::INTEGER, 7},
+	    {(uint8_t)LogicalTypeId::SMALLINT, 8}, {(uint8_t)LogicalTypeId::TINYINT, 9},
+	    {(uint8_t)LogicalTypeId::BOOLEAN, 10}, {(uint8_t)LogicalTypeId::SQLNULL, 11}};
+
+	auto id = (uint8_t)candidate_type.id();
+	auto it = auto_type_candidates_specificity.find(id);
+	if (it == auto_type_candidates_specificity.end()) {
+		throw BinderException("Auto Type Candidate of type %s is not accepted as a valid input",
+		                      LogicalTypeIdToString(candidate_type.id()));
+	}
+	return it->second;
+}
+
 static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctionBindInput &input,
                                             vector<LogicalType> &return_types, vector<string> &names) {
 	auto &config = DBConfig::GetConfig(context);
@@ -61,9 +83,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 {
@@ -96,6 +124,32 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 			if (names.empty()) {
 				throw BinderException("read_csv requires at least a single column as input!");
 			}
+		} else if (loption == "auto_type_candidates") {
+			options.auto_type_candidates.clear();
+			map<uint8_t, LogicalType> candidate_types;
+			// We always have the extremes of Null and Varchar, so we can default to varchar if the
+			// sniffer is not able to confidently detect that column type
+			candidate_types[GetCandidateSpecificity(LogicalType::VARCHAR)] = LogicalType::VARCHAR;
+			candidate_types[GetCandidateSpecificity(LogicalType::SQLNULL)] = LogicalType::SQLNULL;
+
+			auto &child_type = kv.second.type();
+			if (child_type.id() != LogicalTypeId::LIST) {
+				throw BinderException("read_csv auto_types requires a list as input");
+			}
+			auto &list_children = ListValue::GetChildren(kv.second);
+			if (list_children.empty()) {
+				throw BinderException("auto_type_candidates requires at least one type");
+			}
+			for (auto &child : list_children) {
+				if (child.type().id() != LogicalTypeId::VARCHAR) {
+					throw BinderException("auto_type_candidates requires a type specification as string");
+				}
+				auto candidate_type = TransformStringToLogicalType(StringValue::Get(child), context);
+				candidate_types[GetCandidateSpecificity(candidate_type)] = candidate_type;
+			}
+			for (auto &candidate_type : candidate_types) {
+				options.auto_type_candidates.emplace_back(candidate_type.second);
+			}
 		} else if (loption == "column_names" || loption == "names") {
 			if (!options.name_list.empty()) {
 				throw BinderException("read_csv_auto column_names/names can only be supplied once");
@@ -786,6 +840,7 @@ static void ReadCSVAddNamedParameters(TableFunction &table_function) {
 	table_function.named_parameters["escape"] = LogicalType::VARCHAR;
 	table_function.named_parameters["nullstr"] = LogicalType::VARCHAR;
 	table_function.named_parameters["columns"] = LogicalType::ANY;
+	table_function.named_parameters["auto_type_candidates"] = LogicalType::ANY;
 	table_function.named_parameters["header"] = LogicalType::BOOLEAN;
 	table_function.named_parameters["auto_detect"] = LogicalType::BOOLEAN;
 	table_function.named_parameters["sample_size"] = LogicalType::BIGINT;
@@ -806,6 +861,7 @@ static void ReadCSVAddNamedParameters(TableFunction &table_function) {
 	table_function.named_parameters["buffer_size"] = LogicalType::UBIGINT;
 	table_function.named_parameters["decimal_separator"] = LogicalType::VARCHAR;
 	table_function.named_parameters["parallel"] = LogicalType::BOOLEAN;
+	table_function.named_parameters["null_padding"] = LogicalType::BOOLEAN;
 }
 
 double CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p,
@@ -873,6 +929,7 @@ void BufferedCSVReaderOptions::Serialize(FieldWriter &writer) const {
 	// read options
 	writer.WriteList<string>(names);
 	writer.WriteField<idx_t>(skip_rows);
+	writer.WriteField<bool>(skip_rows_set);
 	writer.WriteField<idx_t>(maximum_line_size);
 	writer.WriteField<bool>(normalize_names);
 	writer.WriteListNoReference<bool>(force_not_null);
@@ -884,6 +941,7 @@ void BufferedCSVReaderOptions::Serialize(FieldWriter &writer) const {
 	writer.WriteField<bool>(include_file_name);
 	writer.WriteField<bool>(include_parsed_hive_partitions);
 	writer.WriteString(decimal_separator);
+	writer.WriteField<bool>(null_padding);
 	// write options
 	writer.WriteListNoReference<bool>(force_quote);
 }
@@ -906,6 +964,7 @@ void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
 	// read options
 	names = reader.ReadRequiredList<string>();
 	skip_rows = reader.ReadRequired<idx_t>();
+	skip_rows_set = reader.ReadRequired<bool>();
 	maximum_line_size = reader.ReadRequired<idx_t>();
 	normalize_names = reader.ReadRequired<bool>();
 	force_not_null = reader.ReadRequiredList<bool>();
@@ -917,6 +976,7 @@ void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
 	include_file_name = reader.ReadRequired<bool>();
 	include_parsed_hive_partitions = reader.ReadRequired<bool>();
 	decimal_separator = reader.ReadRequired<string>();
+	null_padding = reader.ReadRequired<bool>();
 	// write options
 	force_quote = reader.ReadRequiredList<bool>();
 }

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

@@ -204,8 +204,8 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 					const auto &bound_foreign_key = (const BoundForeignKeyConstraint &)bound_constraint;
 					const auto &info = bound_foreign_key.info;
 					// find the other table
-					auto table_entry =
-					    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, info.schema, info.table, true);
+					auto table_entry = Catalog::GetEntry<TableCatalogEntry>(context, table.catalog->GetName(),
+					                                                        info.schema, info.table, true);
 					if (!table_entry) {
 						throw InternalException("dukdb_constraints: entry %s.%s referenced in foreign key not found",
 						                        info.schema, info.table);

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

@@ -138,7 +138,7 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 	child_list_t<LogicalType> struct_type_list;
 	struct_type_list.push_back(make_pair("a", LogicalType::INTEGER));
 	struct_type_list.push_back(make_pair("b", LogicalType::VARCHAR));
-	auto struct_type = LogicalType::STRUCT(std::move(struct_type_list));
+	auto struct_type = LogicalType::STRUCT(struct_type_list);
 
 	child_list_t<Value> min_struct_list;
 	min_struct_list.push_back(make_pair("a", Value(LogicalType::INTEGER)));
@@ -156,7 +156,7 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 	child_list_t<LogicalType> struct_list_type_list;
 	struct_list_type_list.push_back(make_pair("a", int_list_type));
 	struct_list_type_list.push_back(make_pair("b", varchar_list_type));
-	auto struct_list_type = LogicalType::STRUCT(std::move(struct_list_type_list));
+	auto struct_list_type = LogicalType::STRUCT(struct_list_type_list);
 
 	child_list_t<Value> min_struct_vl_list;
 	min_struct_vl_list.push_back(make_pair("a", Value(int_list_type)));