duckdb 0.8.1-dev31.0 → 0.8.1-dev327.0

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

@@ -62,7 +62,7 @@ unique_ptr<GlobalTableFunctionState> PragmaLastProfilingOutputInit(ClientContext
 
 static void PragmaLastProfilingOutputFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &state = data_p.global_state->Cast<PragmaLastProfilingOutputOperatorData>();
-	auto &data = (PragmaLastProfilingOutputData &)*data_p.bind_data;
+	auto &data = data_p.bind_data->CastNoConst<PragmaLastProfilingOutputData>();
 	if (!state.initialized) {
 		// create a ColumnDataCollection
 		auto collection = make_uniq<ColumnDataCollection>(context, data.types);

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

@@ -18,7 +18,7 @@ struct RangeFunctionBindData : public TableFunctionData {
 
 public:
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const RangeFunctionBindData &)other_p;
+		auto &other = other_p.Cast<RangeFunctionBindData>();
 		return other.start == start && other.end == end && other.increment == increment;
 	}
 };
@@ -92,7 +92,7 @@ static unique_ptr<GlobalTableFunctionState> RangeFunctionInit(ClientContext &con
 
 static void RangeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = data_p.bind_data->Cast<RangeFunctionBindData>();
-	auto &state = (RangeFunctionState &)*data_p.global_state;
+	auto &state = data_p.global_state->Cast<RangeFunctionState>();
 
 	auto increment = bind_data.increment;
 	auto end = bind_data.end;
@@ -129,7 +129,7 @@ struct RangeDateTimeBindData : public TableFunctionData {
 
 public:
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const RangeDateTimeBindData &)other_p;
+		auto &other = other_p.Cast<RangeDateTimeBindData>();
 		return other.start == start && other.end == end && other.increment == increment &&
 		       other.inclusive_bound == inclusive_bound && other.greater_than_check == greater_than_check;
 	}
@@ -213,7 +213,7 @@ static unique_ptr<GlobalTableFunctionState> RangeDateTimeInit(ClientContext &con
 
 static void RangeDateTimeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = data_p.bind_data->Cast<RangeDateTimeBindData>();
-	auto &state = (RangeDateTimeState &)*data_p.global_state;
+	auto &state = data_p.global_state->Cast<RangeDateTimeState>();
 	if (state.finished) {
 		return;
 	}

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

@@ -378,8 +378,8 @@ private:
 	//! Current File Number
 	idx_t file_number = 0;
 	idx_t max_tuple_end = 0;
-	//! the vector stores positions where threads ended the last line they read in the CSV File, and the set stores
-	//! positions where they started reading the first line.
+	//! The vector stores positions where threads ended the last line they read in the CSV File, and the set stores
+	//! Positions where they started reading the first line.
 	vector<vector<idx_t>> tuple_end;
 	vector<set<idx_t>> tuple_start;
 	//! Tuple end to batch
@@ -559,15 +559,13 @@ bool ParallelCSVGlobalState::Next(ClientContext &context, const ReadCSVData &bin
 }
 void ParallelCSVGlobalState::UpdateVerification(VerificationPositions positions, idx_t file_number_p, idx_t batch_idx) {
 	lock_guard<mutex> parallel_lock(main_mutex);
-	if (positions.beginning_of_first_line < positions.end_of_last_line) {
-		if (positions.end_of_last_line > max_tuple_end) {
-			max_tuple_end = positions.end_of_last_line;
-		}
-		tuple_end_to_batch[file_number_p][positions.end_of_last_line] = batch_idx;
-		batch_to_tuple_end[file_number_p][batch_idx] = tuple_end[file_number_p].size();
-		tuple_start[file_number_p].insert(positions.beginning_of_first_line);
-		tuple_end[file_number_p].push_back(positions.end_of_last_line);
+	if (positions.end_of_last_line > max_tuple_end) {
+		max_tuple_end = positions.end_of_last_line;
 	}
+	tuple_end_to_batch[file_number_p][positions.end_of_last_line] = batch_idx;
+	batch_to_tuple_end[file_number_p][batch_idx] = tuple_end[file_number_p].size();
+	tuple_start[file_number_p].insert(positions.beginning_of_first_line);
+	tuple_end[file_number_p].push_back(positions.end_of_last_line);
 }
 
 void ParallelCSVGlobalState::UpdateLinesRead(CSVBufferRead &buffer_read, idx_t file_idx) {
@@ -690,17 +688,14 @@ static void ParallelReadCSVFunction(ClientContext &context, TableFunctionInput &
 		}
 		if (csv_local_state.csv_reader->finished) {
 			auto verification_updates = csv_local_state.csv_reader->GetVerificationPositions();
-			if (verification_updates.beginning_of_first_line != verification_updates.end_of_last_line) {
-				csv_global_state.UpdateVerification(verification_updates,
-				                                    csv_local_state.csv_reader->buffer->buffer->GetFileNumber(),
-				                                    csv_local_state.csv_reader->buffer->local_batch_index);
-			}
+			csv_global_state.UpdateVerification(verification_updates,
+			                                    csv_local_state.csv_reader->buffer->buffer->GetFileNumber(),
+			                                    csv_local_state.csv_reader->buffer->local_batch_index);
 			csv_global_state.UpdateLinesRead(*csv_local_state.csv_reader->buffer, csv_local_state.csv_reader->file_idx);
 			auto has_next = csv_global_state.Next(context, bind_data, csv_local_state.csv_reader);
 			if (csv_local_state.csv_reader) {
 				csv_local_state.csv_reader->linenr = 0;
 			}
-
 			if (!has_next) {
 				csv_global_state.DecrementThread();
 				break;
@@ -861,16 +856,16 @@ static unique_ptr<GlobalTableFunctionState> SingleThreadedCSVInit(ClientContext
 unique_ptr<LocalTableFunctionState> SingleThreadedReadCSVInitLocal(ExecutionContext &context,
                                                                    TableFunctionInitInput &input,
                                                                    GlobalTableFunctionState *global_state_p) {
-	auto &bind_data = (ReadCSVData &)*input.bind_data;
-	auto &data = (SingleThreadedCSVState &)*global_state_p;
+	auto &bind_data = input.bind_data->CastNoConst<ReadCSVData>();
+	auto &data = global_state_p->Cast<SingleThreadedCSVState>();
 	auto result = make_uniq<SingleThreadedCSVLocalState>();
 	result->csv_reader = data.GetCSVReader(context.client, bind_data, result->file_index, result->total_size);
 	return std::move(result);
 }
 
 static void SingleThreadedCSVFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (ReadCSVData &)*data_p.bind_data;
-	auto &data = (SingleThreadedCSVState &)*data_p.global_state;
+	auto &bind_data = data_p.bind_data->CastNoConst<ReadCSVData>();
+	auto &data = data_p.global_state->Cast<SingleThreadedCSVState>();
 	auto &lstate = data_p.local_state->Cast<SingleThreadedCSVLocalState>();
 	if (!lstate.csv_reader) {
 		// no csv_reader was set, this can happen when a filename-based filter has filtered out all possible files
@@ -1117,6 +1112,7 @@ void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
 
 static void CSVReaderSerialize(FieldWriter &writer, const FunctionData *bind_data_p, const TableFunction &function) {
 	auto &bind_data = bind_data_p->Cast<ReadCSVData>();
+	writer.WriteString(function.extra_info);
 	writer.WriteList<string>(bind_data.files);
 	writer.WriteRegularSerializableList<LogicalType>(bind_data.csv_types);
 	writer.WriteList<string>(bind_data.csv_names);
@@ -1135,6 +1131,7 @@ static void CSVReaderSerialize(FieldWriter &writer, const FunctionData *bind_dat
 
 static unique_ptr<FunctionData> CSVReaderDeserialize(ClientContext &context, FieldReader &reader,
                                                      TableFunction &function) {
+	function.extra_info = reader.ReadRequired<string>();
 	auto result_data = make_uniq<ReadCSVData>();
 	result_data->files = reader.ReadRequiredList<string>();
 	result_data->csv_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();

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

@@ -23,6 +23,9 @@ static unique_ptr<FunctionData> RepeatBind(ClientContext &context, TableFunction
 	auto &inputs = input.inputs;
 	return_types.push_back(inputs[0].type());
 	names.push_back(inputs[0].ToString());
+	if (inputs[1].IsNull()) {
+		throw BinderException("Repeat second parameter cannot be NULL");
+	}
 	return make_uniq<RepeatFunctionData>(inputs[0], inputs[1].GetValue<int64_t>());
 }
 
@@ -31,7 +34,7 @@ static unique_ptr<GlobalTableFunctionState> RepeatInit(ClientContext &context, T
 }
 
 static void RepeatFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (const RepeatFunctionData &)*data_p.bind_data;
+	auto &bind_data = data_p.bind_data->Cast<RepeatFunctionData>();
 	auto &state = data_p.global_state->Cast<RepeatOperatorData>();
 
 	idx_t remaining = MinValue<idx_t>(bind_data.target_count - state.current_count, STANDARD_VECTOR_SIZE);
@@ -41,7 +44,7 @@ static void RepeatFunction(ClientContext &context, TableFunctionInput &data_p, D
 }
 
 static unique_ptr<NodeStatistics> RepeatCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (const RepeatFunctionData &)*bind_data_p;
+	auto &bind_data = bind_data_p->Cast<RepeatFunctionData>();
 	return make_uniq<NodeStatistics>(bind_data.target_count, bind_data.target_count);
 }
 

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

@@ -25,7 +25,14 @@ static unique_ptr<FunctionData> RepeatRowBind(ClientContext &context, TableFunct
 		return_types.push_back(inputs[input_idx].type());
 		names.push_back("column" + std::to_string(input_idx));
 	}
-	return make_uniq<RepeatRowFunctionData>(inputs, input.named_parameters["num_rows"].GetValue<int64_t>());
+	auto entry = input.named_parameters.find("num_rows");
+	if (entry == input.named_parameters.end()) {
+		throw BinderException("repeat_rows requires num_rows to be specified");
+	}
+	if (inputs.empty()) {
+		throw BinderException("repeat_rows requires at least one column to be specified");
+	}
+	return make_uniq<RepeatRowFunctionData>(inputs, entry->second.GetValue<int64_t>());
 }
 
 static unique_ptr<GlobalTableFunctionState> RepeatRowInit(ClientContext &context, TableFunctionInitInput &input) {
@@ -33,7 +40,7 @@ static unique_ptr<GlobalTableFunctionState> RepeatRowInit(ClientContext &context
 }
 
 static void RepeatRowFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (const RepeatRowFunctionData &)*data_p.bind_data;
+	auto &bind_data = data_p.bind_data->Cast<RepeatRowFunctionData>();
 	auto &state = data_p.global_state->Cast<RepeatRowOperatorData>();
 
 	idx_t remaining = MinValue<idx_t>(bind_data.target_count - state.current_count, STANDARD_VECTOR_SIZE);
@@ -45,7 +52,7 @@ static void RepeatRowFunction(ClientContext &context, TableFunctionInput &data_p
 }
 
 static unique_ptr<NodeStatistics> RepeatRowCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (const RepeatRowFunctionData &)*bind_data_p;
+	auto &bind_data = bind_data_p->Cast<RepeatRowFunctionData>();
 	return make_uniq<NodeStatistics>(bind_data.target_count, bind_data.target_count);
 }
 

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

@@ -456,7 +456,7 @@ bool ExtractFunctionData(FunctionEntry &entry, idx_t function_idx, DataChunk &ou
 }
 
 void DuckDBFunctionsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBFunctionsData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<DuckDBFunctionsData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;

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

@@ -6,8 +6,8 @@ namespace duckdb {
 
 // FLAT, CONSTANT, DICTIONARY, SEQUENCE
 struct TestVectorBindData : public TableFunctionData {
-	LogicalType type;
-	bool all_flat;
+	vector<LogicalType> types;
+	bool all_flat = false;
 };
 
 struct TestVectorTypesData : public GlobalTableFunctionState {
@@ -19,16 +19,41 @@ struct TestVectorTypesData : public GlobalTableFunctionState {
 };
 
 struct TestVectorInfo {
-	TestVectorInfo(const LogicalType &type, const map<LogicalTypeId, TestType> &test_type_map,
+	TestVectorInfo(const vector<LogicalType> &types, const map<LogicalTypeId, TestType> &test_type_map,
 	               vector<unique_ptr<DataChunk>> &entries)
-	    : type(type), test_type_map(test_type_map), entries(entries) {
+	    : types(types), test_type_map(test_type_map), entries(entries) {
 	}
 
-	const LogicalType &type;
+	const vector<LogicalType> &types;
 	const map<LogicalTypeId, TestType> &test_type_map;
 	vector<unique_ptr<DataChunk>> &entries;
 };
 
+struct TestGeneratedValues {
+public:
+	void AddColumn(vector<Value> values) {
+		if (!column_values.empty() && column_values[0].size() != values.size()) {
+			throw InternalException("Size mismatch when adding a column to TestGeneratedValues");
+		}
+		column_values.push_back(std::move(values));
+	}
+
+	const Value &GetValue(idx_t row, idx_t column) const {
+		return column_values[column][row];
+	}
+
+	idx_t Rows() const {
+		return column_values.empty() ? 0 : column_values[0].size();
+	}
+
+	idx_t Columns() const {
+		return column_values.size();
+	}
+
+private:
+	vector<vector<Value>> column_values;
+};
+
 struct TestVectorFlat {
 	static constexpr const idx_t TEST_VECTOR_CARDINALITY = 3;
 
@@ -75,14 +100,25 @@ struct TestVectorFlat {
 		return result;
 	}
 
+	static TestGeneratedValues GenerateValues(TestVectorInfo &info) {
+		// generate the values for each column
+		TestGeneratedValues generated_values;
+		for (auto &type : info.types) {
+			generated_values.AddColumn(GenerateValues(info, type));
+		}
+		return generated_values;
+	}
+
 	static void Generate(TestVectorInfo &info) {
-		vector<Value> result_values = GenerateValues(info, info.type);
-		for (idx_t cur_row = 0; cur_row < result_values.size(); cur_row += STANDARD_VECTOR_SIZE) {
+		auto result_values = GenerateValues(info);
+		for (idx_t cur_row = 0; cur_row < result_values.Rows(); cur_row += STANDARD_VECTOR_SIZE) {
 			auto result = make_uniq<DataChunk>();
-			result->Initialize(Allocator::DefaultAllocator(), {info.type});
-			auto cardinality = MinValue<idx_t>(STANDARD_VECTOR_SIZE, result_values.size() - cur_row);
-			for (idx_t i = 0; i < cardinality; i++) {
-				result->data[0].SetValue(i, result_values[cur_row + i]);
+			result->Initialize(Allocator::DefaultAllocator(), info.types);
+			auto cardinality = MinValue<idx_t>(STANDARD_VECTOR_SIZE, result_values.Rows() - cur_row);
+			for (idx_t c = 0; c < info.types.size(); c++) {
+				for (idx_t i = 0; i < cardinality; i++) {
+					result->data[c].SetValue(i, result_values.GetValue(cur_row + i, c));
+				}
 			}
 			result->SetCardinality(cardinality);
 			info.entries.push_back(std::move(result));
@@ -92,13 +128,15 @@ struct TestVectorFlat {
 
 struct TestVectorConstant {
 	static void Generate(TestVectorInfo &info) {
-		auto values = TestVectorFlat::GenerateValues(info, info.type);
+		auto values = TestVectorFlat::GenerateValues(info);
 		for (idx_t cur_row = 0; cur_row < TestVectorFlat::TEST_VECTOR_CARDINALITY; cur_row += STANDARD_VECTOR_SIZE) {
 			auto result = make_uniq<DataChunk>();
-			result->Initialize(Allocator::DefaultAllocator(), {info.type});
+			result->Initialize(Allocator::DefaultAllocator(), info.types);
 			auto cardinality = MinValue<idx_t>(STANDARD_VECTOR_SIZE, TestVectorFlat::TEST_VECTOR_CARDINALITY - cur_row);
-			result->data[0].SetValue(0, values[0]);
-			result->data[0].SetVectorType(VectorType::CONSTANT_VECTOR);
+			for (idx_t c = 0; c < info.types.size(); c++) {
+				result->data[c].SetValue(0, values.GetValue(0, c));
+				result->data[c].SetVectorType(VectorType::CONSTANT_VECTOR);
+			}
 			result->SetCardinality(cardinality);
 
 			info.entries.push_back(std::move(result));
@@ -160,9 +198,11 @@ struct TestVectorSequence {
 	static void Generate(TestVectorInfo &info) {
 #if STANDARD_VECTOR_SIZE > 2
 		auto result = make_uniq<DataChunk>();
-		result->Initialize(Allocator::DefaultAllocator(), {info.type});
+		result->Initialize(Allocator::DefaultAllocator(), info.types);
 
-		GenerateVector(info, info.type, result->data[0]);
+		for (idx_t c = 0; c < info.types.size(); c++) {
+			GenerateVector(info, info.types[c], result->data[c]);
+		}
 		result->SetCardinality(3);
 		info.entries.push_back(std::move(result));
 #endif
@@ -195,11 +235,23 @@ struct TestVectorDictionary {
 static unique_ptr<FunctionData> TestVectorTypesBind(ClientContext &context, TableFunctionBindInput &input,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
 	auto result = make_uniq<TestVectorBindData>();
-	result->type = input.inputs[0].type();
-	result->all_flat = BooleanValue::Get(input.inputs[1]);
-
-	return_types.push_back(result->type);
-	names.emplace_back("test_vector");
+	for (idx_t i = 0; i < input.inputs.size(); i++) {
+		string name = "test_vector";
+		if (i > 0) {
+			name += to_string(i + 1);
+		}
+		auto &input_val = input.inputs[i];
+		names.emplace_back(name);
+		return_types.push_back(input_val.type());
+		result->types.push_back(input_val.type());
+	}
+	for (auto &entry : input.named_parameters) {
+		if (entry.first == "all_flat") {
+			result->all_flat = BooleanValue::Get(entry.second);
+		} else {
+			throw InternalException("Unrecognized named parameter for test_vector_types");
+		}
+	}
 	return std::move(result);
 }
 
@@ -215,7 +267,7 @@ unique_ptr<GlobalTableFunctionState> TestVectorTypesInit(ClientContext &context,
 		test_type_map.insert(make_pair(test_type.type.id(), std::move(test_type)));
 	}
 
-	TestVectorInfo info(bind_data.type, test_type_map, result->entries);
+	TestVectorInfo info(bind_data.types, test_type_map, result->entries);
 	TestVectorFlat::Generate(info);
 	TestVectorConstant::Generate(info);
 	TestVectorDictionary::Generate(info);
@@ -233,7 +285,7 @@ unique_ptr<GlobalTableFunctionState> TestVectorTypesInit(ClientContext &context,
 }
 
 void TestVectorTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (TestVectorTypesData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<TestVectorTypesData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -243,8 +295,12 @@ void TestVectorTypesFunction(ClientContext &context, TableFunctionInput &data_p,
 }
 
 void TestVectorTypesFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("test_vector_types", {LogicalType::ANY, LogicalType::BOOLEAN},
-	                              TestVectorTypesFunction, TestVectorTypesBind, TestVectorTypesInit));
+	TableFunction test_vector_types("test_vector_types", {LogicalType::ANY}, TestVectorTypesFunction,
+	                                TestVectorTypesBind, TestVectorTypesInit);
+	test_vector_types.varargs = LogicalType::ANY;
+	test_vector_types.named_parameters["all_flat"] = LogicalType::BOOLEAN;
+
+	set.AddFunction(std::move(test_vector_types));
 }
 
 } // namespace duckdb

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

@@ -215,7 +215,7 @@ static unique_ptr<GlobalTableFunctionState> IndexScanInitGlobal(ClientContext &c
 	auto &bind_data = input.bind_data->Cast<TableScanBindData>();
 	data_ptr_t row_id_data = nullptr;
 	if (!bind_data.result_ids.empty()) {
-		row_id_data = (data_ptr_t)&bind_data.result_ids[0];
+		row_id_data = (data_ptr_t)&bind_data.result_ids[0]; // NOLINT - this is not pretty
 	}
 	auto result = make_uniq<IndexScanGlobalState>(row_id_data);
 	auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog);
@@ -350,7 +350,7 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 			} else if (expr.type == ExpressionType::COMPARE_BETWEEN) {
 				// BETWEEN expression
 				auto &between = expr.Cast<BoundBetweenExpression>();
-				if (!between.input->Equals(index_expression.get())) {
+				if (!between.input->Equals(*index_expression)) {
 					// expression doesn't match the current index expression
 					continue;
 				}

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

@@ -18,7 +18,7 @@ public:
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const UnnestBindData &)other_p;
+		auto &other = other_p.Cast<UnnestBindData>();
 		return input_type == other.input_type;
 	}
 };

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.1-dev31"
+#define DUCKDB_VERSION "0.8.1-dev327"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "8598919810"
+#define DUCKDB_SOURCE_ID "57912b60a6"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"
@@ -32,7 +32,7 @@ static unique_ptr<GlobalTableFunctionState> PragmaVersionInit(ClientContext &con
 }
 
 static void PragmaVersionFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (PragmaVersionData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<PragmaVersionData>();
 	if (data.finished) {
 		// finished returning values
 		return;

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

@@ -229,9 +229,6 @@ public:
 	DUCKDB_API static LogicalType GetType(ClientContext &context, const string &catalog_name, const string &schema,
 	                                      const string &name);
 
-	static bool TypeExists(ClientContext &context, const string &catalog_name, const string &schema,
-	                       const string &name);
-
 	template <class T>
 	optional_ptr<T> GetEntry(ClientContext &context, const string &schema_name, const string &name,
 	                         OnEntryNotFound if_not_found, QueryErrorContext error_context = QueryErrorContext()) {
@@ -333,13 +330,13 @@ public:
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 

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

@@ -45,6 +45,8 @@ public:
 		return true;
 	}
 
+	void BindUpdateConstraints(LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update) override;
+
 private:
 	unique_ptr<CatalogEntry> RenameColumn(ClientContext &context, RenameColumnInfo &info);
 	unique_ptr<CatalogEntry> AddColumn(ClientContext &context, AddColumnInfo &info);

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

@@ -40,6 +40,10 @@ class TableColumnInfo;
 class TableIndexInfo;
 class TableStorageInfo;
 
+class LogicalGet;
+class LogicalProjection;
+class LogicalUpdate;
+
 //! A table catalog entry
 class TableCatalogEntry : public StandardEntry {
 public:
@@ -102,6 +106,8 @@ public:
 	//! Returns the storage info of this table
 	virtual TableStorageInfo GetStorageInfo(ClientContext &context) = 0;
 
+	DUCKDB_API virtual void BindUpdateConstraints(LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update);
+
 protected:
 	// This is used to serialize the entry by #Serialize(Serializer& ). It is virtual to allow
 	// Custom catalog implementations to override the default implementation. We can not make

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

@@ -72,12 +72,12 @@ public:
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 

package/src/duckdb/src/include/duckdb/catalog/catalog_search_path.hpp

@@ -35,14 +35,16 @@ private:
 	static string WriteOptionallyQuoted(const string &input);
 };
 
+enum class CatalogSetPathType { SET_SCHEMA, SET_SCHEMAS };
+
 //! The schema search path, in order by which entries are searched if no schema entry is provided
 class CatalogSearchPath {
 public:
 	DUCKDB_API explicit CatalogSearchPath(ClientContext &client_p);
 	CatalogSearchPath(const CatalogSearchPath &other) = delete;
 
-	DUCKDB_API void Set(CatalogSearchEntry new_value, bool is_set_schema);
-	DUCKDB_API void Set(vector<CatalogSearchEntry> new_paths, bool is_set_schema = false);
+	DUCKDB_API void Set(CatalogSearchEntry new_value, CatalogSetPathType set_type);
+	DUCKDB_API void Set(vector<CatalogSearchEntry> new_paths, CatalogSetPathType set_type);
 	DUCKDB_API void Reset();
 
 	DUCKDB_API const vector<CatalogSearchEntry> &Get();
@@ -56,9 +58,13 @@ public:
 	DUCKDB_API vector<string> GetSchemasForCatalog(const string &catalog);
 	DUCKDB_API vector<string> GetCatalogsForSchema(const string &schema);
 
+	DUCKDB_API bool SchemaInSearchPath(ClientContext &context, const string &catalog_name, const string &schema_name);
+
 private:
 	void SetPaths(vector<CatalogSearchEntry> new_paths);
 
+	string GetSetName(CatalogSetPathType set_type);
+
 private:
 	ClientContext &context;
 	vector<CatalogSearchEntry> paths;

package/src/duckdb/src/include/duckdb/catalog/default/builtin_types/types.hpp

@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/default/builtin_types/types.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+// This file is generated by scripts/generate_builtin_types.py
+
+#pragma once
+
+#include "duckdb/common/types.hpp"
+#include "duckdb/common/array.hpp"
+
+namespace duckdb {
+
+struct DefaultType {
+	const char *name;
+	LogicalTypeId type;
+};
+
+using builtin_type_array = std::array<DefaultType, 70>;
+
+static constexpr const builtin_type_array BUILTIN_TYPES{{
+	{"decimal", LogicalTypeId::DECIMAL},
+	{"dec", LogicalTypeId::DECIMAL},
+	{"numeric", LogicalTypeId::DECIMAL},
+	{"time", LogicalTypeId::TIME},
+	{"date", LogicalTypeId::DATE},
+	{"timestamp", LogicalTypeId::TIMESTAMP},
+	{"datetime", LogicalTypeId::TIMESTAMP},
+	{"timestamp_us", LogicalTypeId::TIMESTAMP},
+	{"timestamp_ms", LogicalTypeId::TIMESTAMP_MS},
+	{"timestamp_ns", LogicalTypeId::TIMESTAMP_NS},
+	{"timestamp_s", LogicalTypeId::TIMESTAMP_SEC},
+	{"timestamptz", LogicalTypeId::TIMESTAMP_TZ},
+	{"timetz", LogicalTypeId::TIME_TZ},
+	{"interval", LogicalTypeId::INTERVAL},
+	{"varchar", LogicalTypeId::VARCHAR},
+	{"bpchar", LogicalTypeId::VARCHAR},
+	{"string", LogicalTypeId::VARCHAR},
+	{"char", LogicalTypeId::VARCHAR},
+	{"nvarchar", LogicalTypeId::VARCHAR},
+	{"text", LogicalTypeId::VARCHAR},
+	{"blob", LogicalTypeId::BLOB},
+	{"bytea", LogicalTypeId::BLOB},
+	{"varbinary", LogicalTypeId::BLOB},
+	{"binary", LogicalTypeId::BLOB},
+	{"hugeint", LogicalTypeId::HUGEINT},
+	{"int128", LogicalTypeId::HUGEINT},
+	{"bigint", LogicalTypeId::BIGINT},
+	{"oid", LogicalTypeId::BIGINT},
+	{"long", LogicalTypeId::BIGINT},
+	{"int8", LogicalTypeId::BIGINT},
+	{"int64", LogicalTypeId::BIGINT},
+	{"ubigint", LogicalTypeId::UBIGINT},
+	{"uint64", LogicalTypeId::UBIGINT},
+	{"integer", LogicalTypeId::INTEGER},
+	{"int", LogicalTypeId::INTEGER},
+	{"int4", LogicalTypeId::INTEGER},
+	{"signed", LogicalTypeId::INTEGER},
+	{"integral", LogicalTypeId::INTEGER},
+	{"int32", LogicalTypeId::INTEGER},
+	{"uinteger", LogicalTypeId::UINTEGER},
+	{"uint32", LogicalTypeId::UINTEGER},
+	{"smallint", LogicalTypeId::SMALLINT},
+	{"int2", LogicalTypeId::SMALLINT},
+	{"short", LogicalTypeId::SMALLINT},
+	{"int16", LogicalTypeId::SMALLINT},
+	{"usmallint", LogicalTypeId::USMALLINT},
+	{"uint16", LogicalTypeId::USMALLINT},
+	{"tinyint", LogicalTypeId::TINYINT},
+	{"int1", LogicalTypeId::TINYINT},
+	{"utinyint", LogicalTypeId::UTINYINT},
+	{"uint8", LogicalTypeId::UTINYINT},
+	{"struct", LogicalTypeId::STRUCT},
+	{"row", LogicalTypeId::STRUCT},
+	{"list", LogicalTypeId::LIST},
+	{"map", LogicalTypeId::MAP},
+	{"union", LogicalTypeId::UNION},
+	{"bit", LogicalTypeId::BIT},
+	{"bitstring", LogicalTypeId::BIT},
+	{"boolean", LogicalTypeId::BOOLEAN},
+	{"bool", LogicalTypeId::BOOLEAN},
+	{"logical", LogicalTypeId::BOOLEAN},
+	{"uuid", LogicalTypeId::UUID},
+	{"guid", LogicalTypeId::UUID},
+	{"enum", LogicalTypeId::ENUM},
+	{"null", LogicalTypeId::SQLNULL},
+	{"float", LogicalTypeId::FLOAT},
+	{"real", LogicalTypeId::FLOAT},
+	{"float4", LogicalTypeId::FLOAT},
+	{"double", LogicalTypeId::DOUBLE},
+	{"float8", LogicalTypeId::DOUBLE}
+}};
+
+} // namespace duckdb