duckdb 0.8.1-dev111.0 → 0.8.1-dev125.0

package/package.json

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

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

@@ -690,15 +690,16 @@ bool Catalog::TypeExists(ClientContext &context, const string &catalog_name, con
 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

@@ -214,6 +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_search_path.cpp

@@ -126,37 +126,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() {

package/src/duckdb/src/common/exception.cpp

@@ -73,8 +73,11 @@ string Exception::ConstructMessageRecursive(const string &msg, std::vector<Excep
 		parameter_count++;
 	}
 	if (parameter_count != values.size()) {
-		throw InternalException("Expected %d parameters, received %d", parameter_count, values.size());
+		throw InternalException("Primary exception: %s\nSecondary exception in ConstructMessageRecursive: Expected %d "
+		                        "parameters, received %d",
+		                        msg.c_str(), parameter_count, values.size());
 	}
+
 #endif
 	return ExceptionFormatValue::Format(msg, values);
 }

package/src/duckdb/src/common/exception_format_value.cpp

@@ -68,22 +68,27 @@ ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(hugeint_t value) {
 }
 
 string ExceptionFormatValue::Format(const string &msg, std::vector<ExceptionFormatValue> &values) {
-	std::vector<duckdb_fmt::basic_format_arg<duckdb_fmt::printf_context>> format_args;
-	for (auto &val : values) {
-		switch (val.type) {
-		case ExceptionFormatValueType::FORMAT_VALUE_TYPE_DOUBLE:
-			format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.dbl_val));
-			break;
-		case ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER:
-			format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.int_val));
-			break;
-		case ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING:
-			format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.str_val));
-			break;
+	try {
+		std::vector<duckdb_fmt::basic_format_arg<duckdb_fmt::printf_context>> format_args;
+		for (auto &val : values) {
+			switch (val.type) {
+			case ExceptionFormatValueType::FORMAT_VALUE_TYPE_DOUBLE:
+				format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.dbl_val));
+				break;
+			case ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER:
+				format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.int_val));
+				break;
+			case ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING:
+				format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.str_val));
+				break;
+			}
 		}
+		return duckdb_fmt::vsprintf(msg, duckdb_fmt::basic_format_args<duckdb_fmt::printf_context>(
+		                                     format_args.data(), static_cast<int>(format_args.size())));
+	} catch (std::exception &ex) {
+		throw InternalException(std::string("Primary exception: ") + msg +
+		                        "\nSecondary exception in ExceptionFormatValue: " + ex.what());
 	}
-	return duckdb_fmt::vsprintf(msg, duckdb_fmt::basic_format_args<duckdb_fmt::printf_context>(
-	                                     format_args.data(), static_cast<int>(format_args.size())));
 }
 
 } // namespace duckdb

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.1-dev111"
+#define DUCKDB_VERSION "0.8.1-dev125"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "662c10cb21"
+#define DUCKDB_SOURCE_ID "09486d2b9d"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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_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();
@@ -59,6 +61,8 @@ public:
 private:
 	void SetPaths(vector<CatalogSearchEntry> new_paths);
 
+	string GetSetName(CatalogSetPathType set_type);
+
 private:
 	ClientContext &context;
 	vector<CatalogSearchEntry> paths;

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

@@ -105,6 +105,9 @@ public:
 
 	template <typename... Args>
 	static string ConstructMessage(const string &msg, Args... params) {
+		const std::size_t num_args = sizeof...(Args);
+		if (num_args == 0)
+			return msg;
 		std::vector<ExceptionFormatValue> values;
 		return ConstructMessageRecursive(msg, values, params...);
 	}

package/src/duckdb/src/main/settings/settings.cpp

@@ -988,7 +988,7 @@ void SchemaSetting::ResetLocal(ClientContext &context) {
 void SchemaSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = input.ToString();
 	auto &client_data = ClientData::Get(context);
-	client_data.catalog_search_path->Set(CatalogSearchEntry::Parse(parameter), true);
+	client_data.catalog_search_path->Set(CatalogSearchEntry::Parse(parameter), CatalogSetPathType::SET_SCHEMA);
 }
 
 Value SchemaSetting::GetSetting(ClientContext &context) {
@@ -1008,7 +1008,7 @@ void SearchPathSetting::ResetLocal(ClientContext &context) {
 void SearchPathSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = input.ToString();
 	auto &client_data = ClientData::Get(context);
-	client_data.catalog_search_path->Set(CatalogSearchEntry::ParseList(parameter), false);
+	client_data.catalog_search_path->Set(CatalogSearchEntry::ParseList(parameter), CatalogSetPathType::SET_SCHEMAS);
 }
 
 Value SearchPathSetting::GetSetting(ClientContext &context) {

package/src/duckdb/src/planner/binder/statement/bind_update.cpp

@@ -20,119 +20,6 @@
 
 namespace duckdb {
 
-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;
-	}
-}
-
-static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, LogicalProjection &proj,
-                                  LogicalUpdate &update) {
-	if (!table.IsDuckTable()) {
-		return;
-	}
-	// 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 : table.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(table, get, proj, update, check.bound_columns);
-		}
-	}
-	auto &storage = table.GetStorage();
-	if (update.return_chunk) {
-		physical_index_set_t all_columns;
-		for (idx_t i = 0; i < storage.column_definitions.size(); i++) {
-			all_columns.insert(PhysicalIndex(i));
-		}
-		BindExtraColumns(table, 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;
-	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 = table.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 < storage.column_definitions.size(); i++) {
-			all_columns.insert(PhysicalIndex(i));
-		}
-		BindExtraColumns(table, get, proj, update, all_columns);
-	}
-}
-
 // This creates a LogicalProjection and moves 'root' into it as a child
 // unless there are no expressions to project, in which case it just returns 'root'
 unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator &op, unique_ptr<LogicalOperator> root,
@@ -239,7 +126,8 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	auto proj = unique_ptr_cast<LogicalOperator, LogicalProjection>(std::move(proj_tmp));
 
 	// bind any extra columns necessary for CHECK constraints or indexes
-	BindUpdateConstraints(table, *get, *proj, *update);
+	table.BindUpdateConstraints(*get, *proj, *update);
+
 	// finally add the row id column to the projection list
 	proj->expressions.push_back(make_uniq<BoundColumnRefExpression>(
 	    LogicalType::ROW_TYPE, ColumnBinding(get->table_index, get->column_ids.size())));