duckdb 0.8.1-dev2.0 → 0.8.1-dev219.0

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

@@ -58,7 +58,7 @@ static shared_ptr<ParquetFileMetadataCache> LoadMetadata(Allocator &allocator, F
 	auto current_time = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
 
 	auto proto = CreateThriftProtocol(allocator, file_handle, false);
-	auto &transport = ((ThriftFileTransport &)*proto->getTransport());
+	auto &transport = reinterpret_cast<ThriftFileTransport &>(*proto->getTransport());
 	auto file_size = transport.GetSize();
 	if (file_size < 12) {
 		throw InvalidInputException("File '%s' too small to be a Parquet file", file_handle.path);
@@ -71,11 +71,11 @@ static shared_ptr<ParquetFileMetadataCache> LoadMetadata(Allocator &allocator, F
 	transport.SetLocation(file_size - 8);
 	transport.read((uint8_t *)buf.ptr, 8);
 
-	if (strncmp(buf.ptr + 4, "PAR1", 4) != 0) {
+	if (memcmp(buf.ptr + 4, "PAR1", 4) != 0) {
 		throw InvalidInputException("No magic bytes found at end of file '%s'", file_handle.path);
 	}
 	// read four-byte footer length from just before the end magic bytes
-	auto footer_len = *(uint32_t *)buf.ptr;
+	auto footer_len = *reinterpret_cast<uint32_t *>(buf.ptr);
 	if (footer_len <= 0 || file_size < 12 + footer_len) {
 		throw InvalidInputException("Footer length error in file '%s'", file_handle.path);
 	}
@@ -484,7 +484,7 @@ unique_ptr<BaseStatistics> ParquetReader::ReadStatistics(const string &name) {
 	unique_ptr<BaseStatistics> column_stats;
 	auto file_meta_data = GetFileMetadata();
 	auto root_reader = CreateReader();
-	auto column_reader = ((StructColumnReader *)root_reader.get())->GetChildReader(file_col_idx);
+	auto column_reader = root_reader->Cast<StructColumnReader>().GetChildReader(file_col_idx);
 
 	for (idx_t row_group_idx = 0; row_group_idx < file_meta_data->row_groups.size(); row_group_idx++) {
 		auto &row_group = file_meta_data->row_groups[row_group_idx];
@@ -573,7 +573,7 @@ idx_t ParquetReader::GetGroupOffset(ParquetReaderScanState &state) {
 void ParquetReader::PrepareRowGroupBuffer(ParquetReaderScanState &state, idx_t col_idx) {
 	auto &group = GetGroup(state);
 	auto column_id = reader_data.column_ids[col_idx];
-	auto column_reader = ((StructColumnReader *)state.root_reader.get())->GetChildReader(column_id);
+	auto column_reader = state.root_reader->Cast<StructColumnReader>().GetChildReader(column_id);
 
 	// TODO move this to columnreader too
 	if (reader_data.filters) {
@@ -760,14 +760,14 @@ static void FilterOperationSwitch(Vector &v, Value &constant, parquet_filter_t &
 static void ApplyFilter(Vector &v, TableFilter &filter, parquet_filter_t &filter_mask, idx_t count) {
 	switch (filter.filter_type) {
 	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction = (ConjunctionAndFilter &)filter;
+		auto &conjunction = filter.Cast<ConjunctionAndFilter>();
 		for (auto &child_filter : conjunction.child_filters) {
 			ApplyFilter(v, *child_filter, filter_mask, count);
 		}
 		break;
 	}
 	case TableFilterType::CONJUNCTION_OR: {
-		auto &conjunction = (ConjunctionOrFilter &)filter;
+		auto &conjunction = filter.Cast<ConjunctionOrFilter>();
 		parquet_filter_t or_mask;
 		for (auto &child_filter : conjunction.child_filters) {
 			parquet_filter_t child_mask = filter_mask;
@@ -778,7 +778,7 @@ static void ApplyFilter(Vector &v, TableFilter &filter, parquet_filter_t &filter
 		break;
 	}
 	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = (ConstantFilter &)filter;
+		auto &constant_filter = filter.Cast<ConstantFilter>();
 		switch (constant_filter.comparison_type) {
 		case ExpressionType::COMPARE_EQUAL:
 			FilterOperationSwitch<Equals>(v, constant_filter.constant, filter_mask, count);
@@ -831,7 +831,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 		state.current_group++;
 		state.group_offset = 0;
 
-		auto &trans = (ThriftFileTransport &)*state.thrift_file_proto->getTransport();
+		auto &trans = reinterpret_cast<ThriftFileTransport &>(*state.thrift_file_proto->getTransport());
 		trans.ClearPrefetch();
 		state.current_group_prefetched = false;
 
@@ -846,8 +846,8 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 
 			auto file_col_idx = reader_data.column_ids[col_idx];
 
-			auto root_reader = ((StructColumnReader *)state.root_reader.get());
-			to_scan_compressed_bytes += root_reader->GetChildReader(file_col_idx)->TotalCompressedSize();
+			auto &root_reader = state.root_reader->Cast<StructColumnReader>();
+			to_scan_compressed_bytes += root_reader.GetChildReader(file_col_idx)->TotalCompressedSize();
 		}
 
 		auto &group = GetGroup(state);
@@ -880,14 +880,14 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 				// Prefetch column-wise
 				for (idx_t col_idx = 0; col_idx < reader_data.column_ids.size(); col_idx++) {
 					auto file_col_idx = reader_data.column_ids[col_idx];
-					auto root_reader = ((StructColumnReader *)state.root_reader.get());
+					auto &root_reader = state.root_reader->Cast<StructColumnReader>();
 
 					bool has_filter = false;
 					if (reader_data.filters) {
 						auto entry = reader_data.filters->filters.find(reader_data.column_mapping[col_idx]);
 						has_filter = entry != reader_data.filters->filters.end();
 					}
-					root_reader->GetChildReader(file_col_idx)->RegisterPrefetch(trans, !(lazy_fetch && !has_filter));
+					root_reader.GetChildReader(file_col_idx)->RegisterPrefetch(trans, !(lazy_fetch && !has_filter));
 				}
 
 				trans.FinalizeRegistration();
@@ -924,7 +924,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 	auto define_ptr = (uint8_t *)state.define_buf.ptr;
 	auto repeat_ptr = (uint8_t *)state.repeat_buf.ptr;
 
-	auto root_reader = ((StructColumnReader *)state.root_reader.get());
+	auto &root_reader = state.root_reader->Cast<StructColumnReader>();
 
 	if (reader_data.filters) {
 		vector<bool> need_to_read(reader_data.column_ids.size(), true);
@@ -947,7 +947,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 				auto result_idx = reader_data.column_mapping[id];
 
 				auto &result_vector = result.data[result_idx];
-				auto child_reader = root_reader->GetChildReader(file_col_idx);
+				auto child_reader = root_reader.GetChildReader(file_col_idx);
 				child_reader->Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
 				need_to_read[id] = false;
 
@@ -962,11 +962,11 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 			}
 			auto file_col_idx = reader_data.column_ids[col_idx];
 			if (filter_mask.none()) {
-				root_reader->GetChildReader(file_col_idx)->Skip(result.size());
+				root_reader.GetChildReader(file_col_idx)->Skip(result.size());
 				continue;
 			}
 			auto &result_vector = result.data[reader_data.column_mapping[col_idx]];
-			auto child_reader = root_reader->GetChildReader(file_col_idx);
+			auto child_reader = root_reader.GetChildReader(file_col_idx);
 			child_reader->Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
 		}
 
@@ -982,7 +982,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 		for (idx_t col_idx = 0; col_idx < reader_data.column_ids.size(); col_idx++) {
 			auto file_col_idx = reader_data.column_ids[col_idx];
 			auto &result_vector = result.data[reader_data.column_mapping[col_idx]];
-			auto child_reader = root_reader->GetChildReader(file_col_idx);
+			auto child_reader = root_reader.GetChildReader(file_col_idx);
 			auto rows_read = child_reader->Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
 			if (rows_read != result.size()) {
 				throw InvalidInputException("Mismatch in parquet read for column %llu, expected %llu rows, got %llu",

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

@@ -48,12 +48,13 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 	if (stats.empty()) {
 		return Value();
 	}
+	auto stats_data = const_data_ptr_cast(stats.c_str());
 	switch (type.id()) {
 	case LogicalTypeId::BOOLEAN: {
 		if (stats.size() != sizeof(bool)) {
 			throw InternalException("Incorrect stats size for type BOOLEAN");
 		}
-		return Value::BOOLEAN(Load<bool>((data_ptr_t)stats.c_str()));
+		return Value::BOOLEAN(Load<bool>(stats_data));
 	}
 	case LogicalTypeId::UTINYINT:
 	case LogicalTypeId::USMALLINT:
@@ -61,29 +62,29 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 		if (stats.size() != sizeof(uint32_t)) {
 			throw InternalException("Incorrect stats size for type UINTEGER");
 		}
-		return Value::UINTEGER(Load<uint32_t>((data_ptr_t)stats.c_str()));
+		return Value::UINTEGER(Load<uint32_t>(stats_data));
 	case LogicalTypeId::UBIGINT:
 		if (stats.size() != sizeof(uint64_t)) {
 			throw InternalException("Incorrect stats size for type UBIGINT");
 		}
-		return Value::UBIGINT(Load<uint64_t>((data_ptr_t)stats.c_str()));
+		return Value::UBIGINT(Load<uint64_t>(stats_data));
 	case LogicalTypeId::TINYINT:
 	case LogicalTypeId::SMALLINT:
 	case LogicalTypeId::INTEGER:
 		if (stats.size() != sizeof(int32_t)) {
 			throw InternalException("Incorrect stats size for type INTEGER");
 		}
-		return Value::INTEGER(Load<int32_t>((data_ptr_t)stats.c_str()));
+		return Value::INTEGER(Load<int32_t>(stats_data));
 	case LogicalTypeId::BIGINT:
 		if (stats.size() != sizeof(int64_t)) {
 			throw InternalException("Incorrect stats size for type BIGINT");
 		}
-		return Value::BIGINT(Load<int64_t>((data_ptr_t)stats.c_str()));
+		return Value::BIGINT(Load<int64_t>(stats_data));
 	case LogicalTypeId::FLOAT: {
 		if (stats.size() != sizeof(float)) {
 			throw InternalException("Incorrect stats size for type FLOAT");
 		}
-		auto val = Load<float>((data_ptr_t)stats.c_str());
+		auto val = Load<float>(stats_data);
 		if (!Value::FloatIsFinite(val)) {
 			return Value();
 		}
@@ -93,7 +94,7 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 		if (stats.size() != sizeof(double)) {
 			throw InternalException("Incorrect stats size for type DOUBLE");
 		}
-		auto val = Load<double>((data_ptr_t)stats.c_str());
+		auto val = Load<double>(stats_data);
 		if (!Value::DoubleIsFinite(val)) {
 			return Value();
 		}
@@ -107,13 +108,13 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 			if (stats.size() != sizeof(int32_t)) {
 				throw InternalException("Incorrect stats size for type %s", type.ToString());
 			}
-			return Value::DECIMAL(Load<int32_t>((data_ptr_t)stats.c_str()), width, scale);
+			return Value::DECIMAL(Load<int32_t>(stats_data), width, scale);
 		}
 		case Type::INT64: {
 			if (stats.size() != sizeof(int64_t)) {
 				throw InternalException("Incorrect stats size for type %s", type.ToString());
 			}
-			return Value::DECIMAL(Load<int64_t>((data_ptr_t)stats.c_str()), width, scale);
+			return Value::DECIMAL(Load<int64_t>(stats_data), width, scale);
 		}
 		case Type::BYTE_ARRAY:
 		case Type::FIXED_LEN_BYTE_ARRAY:
@@ -122,21 +123,17 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 			}
 			switch (type.InternalType()) {
 			case PhysicalType::INT16:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<int16_t>((const_data_ptr_t)stats.c_str(), stats.size()),
-				    width, scale);
+				return Value::DECIMAL(ParquetDecimalUtils::ReadDecimalValue<int16_t>(stats_data, stats.size()), width,
+				                      scale);
 			case PhysicalType::INT32:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<int32_t>((const_data_ptr_t)stats.c_str(), stats.size()),
-				    width, scale);
+				return Value::DECIMAL(ParquetDecimalUtils::ReadDecimalValue<int32_t>(stats_data, stats.size()), width,
+				                      scale);
 			case PhysicalType::INT64:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<int64_t>((const_data_ptr_t)stats.c_str(), stats.size()),
-				    width, scale);
+				return Value::DECIMAL(ParquetDecimalUtils::ReadDecimalValue<int64_t>(stats_data, stats.size()), width,
+				                      scale);
 			case PhysicalType::INT128:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<hugeint_t>((const_data_ptr_t)stats.c_str(), stats.size()),
-				    width, scale);
+				return Value::DECIMAL(ParquetDecimalUtils::ReadDecimalValue<hugeint_t>(stats_data, stats.size()), width,
+				                      scale);
 			default:
 				throw InternalException("Unsupported internal type for decimal");
 			}
@@ -155,14 +152,14 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 		if (stats.size() != sizeof(int32_t)) {
 			throw InternalException("Incorrect stats size for type DATE");
 		}
-		return Value::DATE(date_t(Load<int32_t>((data_ptr_t)stats.c_str())));
+		return Value::DATE(date_t(Load<int32_t>(stats_data)));
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIME_TZ: {
 		int64_t val;
 		if (stats.size() == sizeof(int32_t)) {
-			val = Load<int32_t>((data_ptr_t)stats.c_str());
+			val = Load<int32_t>(stats_data);
 		} else if (stats.size() == sizeof(int64_t)) {
-			val = Load<int64_t>((data_ptr_t)stats.c_str());
+			val = Load<int64_t>(stats_data);
 		} else {
 			throw InternalException("Incorrect stats size for type TIME");
 		}
@@ -190,13 +187,13 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 			if (stats.size() != sizeof(Int96)) {
 				throw InternalException("Incorrect stats size for type TIMESTAMP");
 			}
-			return Value::TIMESTAMP(ImpalaTimestampToTimestamp(Load<Int96>((data_ptr_t)stats.c_str())));
+			return Value::TIMESTAMP(ImpalaTimestampToTimestamp(Load<Int96>(stats_data)));
 		} else {
 			D_ASSERT(schema_ele.type == Type::INT64);
 			if (stats.size() != sizeof(int64_t)) {
 				throw InternalException("Incorrect stats size for type TIMESTAMP");
 			}
-			auto val = Load<int64_t>((data_ptr_t)stats.c_str());
+			auto val = Load<int64_t>(stats_data);
 			if (schema_ele.__isset.logicalType && schema_ele.logicalType.__isset.TIMESTAMP) {
 				// logical type
 				if (schema_ele.logicalType.TIMESTAMP.unit.__isset.MILLIS) {

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

@@ -17,7 +17,7 @@ static constexpr int64_t NANOSECONDS_PER_MICRO = 1000LL;
 
 static int64_t ImpalaTimestampToMicroseconds(const Int96 &impala_timestamp) {
 	int64_t days_since_epoch = impala_timestamp.value[2] - JULIAN_TO_UNIX_EPOCH_DAYS;
-	auto nanoseconds = Load<int64_t>((data_ptr_t)impala_timestamp.value);
+	auto nanoseconds = Load<int64_t>(const_data_ptr_cast(impala_timestamp.value));
 	auto microseconds = nanoseconds / NANOSECONDS_PER_MICRO;
 	return days_since_epoch * MICROSECONDS_PER_DAY + microseconds;
 }
@@ -35,7 +35,7 @@ Int96 TimestampToImpalaTimestamp(timestamp_t &ts) {
 	// first two uint32 in Int96 are nanoseconds since midnights
 	// last uint32 is number of days since year 4713 BC ("Julian date")
 	Int96 impala_ts;
-	Store<uint64_t>(ms_since_midnight * 1000000, (data_ptr_t)impala_ts.value);
+	Store<uint64_t>(ms_since_midnight * 1000000, data_ptr_cast(impala_ts.value));
 	impala_ts.value[2] = days_since_epoch + JULIAN_TO_UNIX_EPOCH_DAYS;
 	return impala_ts;
 }

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

@@ -45,7 +45,7 @@ public:
 	}
 
 	void write_virt(const uint8_t *buf, uint32_t len) override {
-		serializer.WriteData((const_data_ptr_t)buf, len);
+		serializer.WriteData(const_data_ptr_cast(buf), len);
 	}
 
 private:
@@ -232,7 +232,7 @@ ParquetWriter::ParquetWriter(FileSystem &fs, string file_name_p, vector<LogicalT
 	writer = make_uniq<BufferedFileWriter>(fs, file_name.c_str(),
 	                                       FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW);
 	// parquet files start with the string "PAR1"
-	writer->WriteData((const_data_ptr_t) "PAR1", 4);
+	writer->WriteData(const_data_ptr_cast("PAR1"), 4);
 	TCompactProtocolFactoryT<MyTransport> tproto_factory;
 	protocol = tproto_factory.getProtocol(make_shared<MyTransport>(*writer));
 
@@ -327,7 +327,7 @@ void ParquetWriter::Finalize() {
 	writer->Write<uint32_t>(writer->GetTotalWritten() - start_offset);
 
 	// parquet files also end with the string "PAR1"
-	writer->WriteData((const_data_ptr_t) "PAR1", 4);
+	writer->WriteData(const_data_ptr_cast("PAR1"), 4);
 
 	// flush to disk
 	writer->Sync();

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

@@ -61,9 +61,9 @@ bool ZstdStreamWrapper::Read(StreamData &sd) {
 		throw IOException(duckdb_zstd::ZSTD_getErrorName(res));
 	}
 
-	sd.in_buff_start = (data_ptr_t)in_buffer.src + in_buffer.pos;
-	sd.in_buff_end = (data_ptr_t)in_buffer.src + in_buffer.size;
-	sd.out_buff_end = (data_ptr_t)out_buffer.dst + out_buffer.pos;
+	sd.in_buff_start = (data_ptr_t)in_buffer.src + in_buffer.pos;  // NOLINT
+	sd.in_buff_end = (data_ptr_t)in_buffer.src + in_buffer.size;   // NOLINT
+	sd.out_buff_end = (data_ptr_t)out_buffer.dst + out_buffer.pos; // NOLINT
 	return false;
 }
 

package/src/duckdb/src/catalog/catalog.cpp

@@ -532,10 +532,6 @@ CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type
 	reference_set_t<SchemaCatalogEntry> schemas;
 	if (IsInvalidSchema(schema)) {
 		// try all schemas for this catalog
-		auto catalog_name = GetName();
-		if (catalog_name == DatabaseManager::GetDefaultDatabase(context)) {
-			catalog_name = INVALID_CATALOG;
-		}
 		auto entries = GetCatalogEntries(context, GetName(), INVALID_SCHEMA);
 		for (auto &entry : entries) {
 			auto &candidate_schema = entry.schema;
@@ -678,31 +674,19 @@ vector<reference<SchemaCatalogEntry>> Catalog::GetSchemas(ClientContext &context
 	return schemas;
 }
 
-bool Catalog::TypeExists(ClientContext &context, const string &catalog_name, const string &schema, const string &name) {
-	optional_ptr<CatalogEntry> entry;
-	entry = GetEntry(context, CatalogType::TYPE_ENTRY, catalog_name, schema, name, OnEntryNotFound::RETURN_NULL);
-	if (!entry) {
-		// look in the system catalog
-		entry = GetEntry(context, CatalogType::TYPE_ENTRY, SYSTEM_CATALOG, schema, name, OnEntryNotFound::RETURN_NULL);
-		if (!entry) {
-			return false;
-		}
-	}
-	return true;
-}
-
 vector<reference<SchemaCatalogEntry>> Catalog::GetSchemas(ClientContext &context, const string &catalog_name) {
 	vector<reference<Catalog>> catalogs;
 	if (IsInvalidCatalog(catalog_name)) {
-		unordered_set<string> name;
+		reference_set_t<Catalog> inserted_catalogs;
 
 		auto &search_path = *context.client_data->catalog_search_path;
 		for (auto &entry : search_path.Get()) {
-			if (name.find(entry.catalog) != name.end()) {
+			auto &catalog = Catalog::GetCatalog(context, entry.catalog);
+			if (inserted_catalogs.find(catalog) != inserted_catalogs.end()) {
 				continue;
 			}
-			name.insert(entry.catalog);
-			catalogs.push_back(Catalog::GetCatalog(context, entry.catalog));
+			inserted_catalogs.insert(catalog);
+			catalogs.push_back(catalog);
 		}
 	} else {
 		catalogs.push_back(Catalog::GetCatalog(context, catalog_name));

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

@@ -16,6 +16,9 @@
 #include "duckdb/parser/constraints/list.hpp"
 #include "duckdb/function/table/table_scan.hpp"
 #include "duckdb/storage/table_storage_info.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
+#include "duckdb/planner/operator/logical_update.hpp"
 
 namespace duckdb {
 
@@ -730,4 +733,114 @@ TableStorageInfo DuckTableEntry::GetStorageInfo(ClientContext &context) {
 	return result;
 }
 
+static void BindExtraColumns(TableCatalogEntry &table, LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update,
+                             physical_index_set_t &bound_columns) {
+	if (bound_columns.size() <= 1) {
+		return;
+	}
+	idx_t found_column_count = 0;
+	physical_index_set_t found_columns;
+	for (idx_t i = 0; i < update.columns.size(); i++) {
+		if (bound_columns.find(update.columns[i]) != bound_columns.end()) {
+			// this column is referenced in the CHECK constraint
+			found_column_count++;
+			found_columns.insert(update.columns[i]);
+		}
+	}
+	if (found_column_count > 0 && found_column_count != bound_columns.size()) {
+		// columns in this CHECK constraint were referenced, but not all were part of the UPDATE
+		// add them to the scan and update set
+		for (auto &check_column_id : bound_columns) {
+			if (found_columns.find(check_column_id) != found_columns.end()) {
+				// column is already projected
+				continue;
+			}
+			// column is not projected yet: project it by adding the clause "i=i" to the set of updated columns
+			auto &column = table.GetColumns().GetColumn(check_column_id);
+			update.expressions.push_back(make_uniq<BoundColumnRefExpression>(
+			    column.Type(), ColumnBinding(proj.table_index, proj.expressions.size())));
+			proj.expressions.push_back(make_uniq<BoundColumnRefExpression>(
+			    column.Type(), ColumnBinding(get.table_index, get.column_ids.size())));
+			get.column_ids.push_back(check_column_id.index);
+			update.columns.push_back(check_column_id);
+		}
+	}
+}
+
+static bool TypeSupportsRegularUpdate(const LogicalType &type) {
+	switch (type.id()) {
+	case LogicalTypeId::LIST:
+	case LogicalTypeId::MAP:
+	case LogicalTypeId::UNION:
+		// lists and maps and unions don't support updates directly
+		return false;
+	case LogicalTypeId::STRUCT: {
+		auto &child_types = StructType::GetChildTypes(type);
+		for (auto &entry : child_types) {
+			if (!TypeSupportsRegularUpdate(entry.second)) {
+				return false;
+			}
+		}
+		return true;
+	}
+	default:
+		return true;
+	}
+}
+
+void DuckTableEntry::BindUpdateConstraints(LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update) {
+	TableCatalogEntry::BindUpdateConstraints(get, proj, update);
+	// check the constraints and indexes of the table to see if we need to project any additional columns
+	// we do this for indexes with multiple columns and CHECK constraints in the UPDATE clause
+	// suppose we have a constraint CHECK(i + j < 10); now we need both i and j to check the constraint
+	// if we are only updating one of the two columns we add the other one to the UPDATE set
+	// with a "useless" update (i.e. i=i) so we can verify that the CHECK constraint is not violated
+	for (auto &constraint : GetBoundConstraints()) {
+		if (constraint->type == ConstraintType::CHECK) {
+			auto &check = constraint->Cast<BoundCheckConstraint>();
+			// check constraint! check if we need to add any extra columns to the UPDATE clause
+			BindExtraColumns(*this, get, proj, update, check.bound_columns);
+		}
+	}
+	auto &table_storage = GetStorage();
+	if (update.return_chunk) {
+		physical_index_set_t all_columns;
+		for (idx_t i = 0; i < table_storage.column_definitions.size(); i++) {
+			all_columns.insert(PhysicalIndex(i));
+		}
+		BindExtraColumns(*this, get, proj, update, all_columns);
+	}
+	// for index updates we always turn any update into an insert and a delete
+	// we thus need all the columns to be available, hence we check if the update touches any index columns
+	// If the returning keyword is used, we need access to the whole row in case the user requests it.
+	// Therefore switch the update to a delete and insert.
+	update.update_is_del_and_insert = false;
+	table_storage.info->indexes.Scan([&](Index &index) {
+		if (index.IndexIsUpdated(update.columns)) {
+			update.update_is_del_and_insert = true;
+			return true;
+		}
+		return false;
+	});
+
+	// we also convert any updates on LIST columns into delete + insert
+	for (auto &col_index : update.columns) {
+		auto &column = GetColumns().GetColumn(col_index);
+		if (!TypeSupportsRegularUpdate(column.Type())) {
+			update.update_is_del_and_insert = true;
+			break;
+		}
+	}
+
+	if (update.update_is_del_and_insert) {
+		// the update updates a column required by an index or requires returning the updated rows,
+		// push projections for all columns
+		physical_index_set_t all_columns;
+		for (idx_t i = 0; i < table_storage.column_definitions.size(); i++) {
+			all_columns.insert(PhysicalIndex(i));
+		}
+		BindExtraColumns(*this, get, proj, update, all_columns);
+	}
+}
+
 } // namespace duckdb

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

@@ -206,6 +206,7 @@ const vector<unique_ptr<Constraint>> &TableCatalogEntry::GetConstraints() {
 	return constraints;
 }
 
+// LCOV_EXCL_START
 DataTable &TableCatalogEntry::GetStorage() {
 	throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DuckTableEntry");
 }
@@ -213,4 +214,10 @@ DataTable &TableCatalogEntry::GetStorage() {
 const vector<unique_ptr<BoundConstraint>> &TableCatalogEntry::GetBoundConstraints() {
 	throw InternalException("Calling GetBoundConstraints on a TableCatalogEntry that is not a DuckTableEntry");
 }
+
+// LCOV_EXCL_STOP
+
+void TableCatalogEntry::BindUpdateConstraints(LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update) {
+}
+
 } // namespace duckdb

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

@@ -34,10 +34,6 @@ unique_ptr<CatalogEntry> CatalogEntry::Copy(ClientContext &context) const {
 string CatalogEntry::ToSQL() const {
 	throw InternalException("Unsupported catalog type for ToSQL()");
 }
-// LCOV_EXCL_STOP
-
-void CatalogEntry::Verify(Catalog &catalog_p) {
-}
 
 Catalog &CatalogEntry::ParentCatalog() {
 	throw InternalException("CatalogEntry::ParentCatalog called on catalog entry without catalog");
@@ -46,6 +42,10 @@ Catalog &CatalogEntry::ParentCatalog() {
 SchemaCatalogEntry &CatalogEntry::ParentSchema() {
 	throw InternalException("CatalogEntry::ParentSchema called on catalog entry without schema");
 }
+// LCOV_EXCL_STOP
+
+void CatalogEntry::Verify(Catalog &catalog_p) {
+}
 
 InCatalogEntry::InCatalogEntry(CatalogType type, Catalog &catalog, string name)
     : CatalogEntry(type, catalog, std::move(name)), catalog(catalog) {

package/src/duckdb/src/catalog/catalog_search_path.cpp

@@ -5,6 +5,7 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/main/database_manager.hpp"
 
 namespace duckdb {
 
@@ -126,37 +127,57 @@ void CatalogSearchPath::Reset() {
 	SetPaths(empty);
 }
 
-void CatalogSearchPath::Set(vector<CatalogSearchEntry> new_paths, bool is_set_schema) {
-	if (is_set_schema && new_paths.size() != 1) {
-		throw CatalogException("SET schema can set only 1 schema. This has %d", new_paths.size());
+string CatalogSearchPath::GetSetName(CatalogSetPathType set_type) {
+	switch (set_type) {
+	case CatalogSetPathType::SET_SCHEMA:
+		return "SET schema";
+	case CatalogSetPathType::SET_SCHEMAS:
+		return "SET search_path";
+	default:
+		throw InternalException("Unrecognized CatalogSetPathType");
+	}
+}
+
+void CatalogSearchPath::Set(vector<CatalogSearchEntry> new_paths, CatalogSetPathType set_type) {
+	if (set_type != CatalogSetPathType::SET_SCHEMAS && new_paths.size() != 1) {
+		throw CatalogException("%s can set only 1 schema. This has %d", GetSetName(set_type), new_paths.size());
 	}
 	for (auto &path : new_paths) {
-		if (!Catalog::GetSchema(context, path.catalog, path.schema, OnEntryNotFound::RETURN_NULL)) {
+		auto schema_entry = Catalog::GetSchema(context, path.catalog, path.schema, OnEntryNotFound::RETURN_NULL);
+		if (schema_entry) {
+			// we are setting a schema - update the catalog and schema
 			if (path.catalog.empty()) {
-				// only schema supplied - check if this is a database instead
-				auto schema = Catalog::GetSchema(context, path.schema, DEFAULT_SCHEMA, OnEntryNotFound::RETURN_NULL);
+				path.catalog = GetDefault().catalog;
+			}
+			continue;
+		}
+		// only schema supplied - check if this is a catalog instead
+		if (path.catalog.empty()) {
+			auto catalog = Catalog::GetCatalogEntry(context, path.schema);
+			if (catalog) {
+				auto schema = catalog->GetSchema(context, DEFAULT_SCHEMA, OnEntryNotFound::RETURN_NULL);
 				if (schema) {
 					path.catalog = std::move(path.schema);
 					path.schema = schema->name;
 					continue;
 				}
 			}
-			throw CatalogException("SET %s: No catalog + schema named %s found.",
-			                       is_set_schema ? "schema" : "search_path", path.ToString());
 		}
+		throw CatalogException("%s: No catalog + schema named \"%s\" found.", GetSetName(set_type), path.ToString());
 	}
-	if (is_set_schema) {
+	if (set_type == CatalogSetPathType::SET_SCHEMA) {
 		if (new_paths[0].catalog == TEMP_CATALOG || new_paths[0].catalog == SYSTEM_CATALOG) {
-			throw CatalogException("SET schema cannot be set to internal schema \"%s\"", new_paths[0].catalog);
+			throw CatalogException("%s cannot be set to internal schema \"%s\"", GetSetName(set_type),
+			                       new_paths[0].catalog);
 		}
 	}
 	this->set_paths = std::move(new_paths);
 	SetPaths(set_paths);
 }
 
-void CatalogSearchPath::Set(CatalogSearchEntry new_value, bool is_set_schema) {
+void CatalogSearchPath::Set(CatalogSearchEntry new_value, CatalogSetPathType set_type) {
 	vector<CatalogSearchEntry> new_paths {std::move(new_value)};
-	Set(std::move(new_paths), is_set_schema);
+	Set(std::move(new_paths), set_type);
 }
 
 const vector<CatalogSearchEntry> &CatalogSearchPath::Get() {
@@ -225,4 +246,20 @@ void CatalogSearchPath::SetPaths(vector<CatalogSearchEntry> new_paths) {
 	paths.emplace_back(SYSTEM_CATALOG, "pg_catalog");
 }
 
+bool CatalogSearchPath::SchemaInSearchPath(ClientContext &context, const string &catalog_name,
+                                           const string &schema_name) {
+	for (auto &path : paths) {
+		if (path.schema != schema_name) {
+			continue;
+		}
+		if (path.catalog == catalog_name) {
+			return true;
+		}
+		if (IsInvalidCatalog(path.catalog) && catalog_name == DatabaseManager::GetDefaultDatabase(context)) {
+			return true;
+		}
+	}
+	return false;
+}
+
 } // namespace duckdb

package/src/duckdb/src/catalog/catalog_set.cpp

@@ -42,7 +42,7 @@ private:
 };
 
 CatalogSet::CatalogSet(Catalog &catalog_p, unique_ptr<DefaultGenerator> defaults)
-    : catalog((DuckCatalog &)catalog_p), defaults(std::move(defaults)) {
+    : catalog(catalog_p.Cast<DuckCatalog>()), defaults(std::move(defaults)) {
 	D_ASSERT(catalog_p.IsDuckCatalog());
 }
 CatalogSet::~CatalogSet() {