duckdb 0.3.3-dev1401.0 → 0.3.3-dev1409.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.3-dev1401.0",
+  "version": "0.3.3-dev1409.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -155796,6 +155796,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 SchemaCatalogEntry *Binder::BindSchema(CreateInfo &info) {
@@ -156010,10 +156011,18 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 				for (auto &keyname : fk.pk_columns) {
 					auto entry = pk_table_entry_ptr->name_map.find(keyname);
 					if (entry == pk_table_entry_ptr->name_map.end()) {
-						throw ParserException("column \"%s\" named in key does not exist", keyname);
+						throw BinderException("column \"%s\" named in key does not exist", keyname);
 					}
 					fk.info.pk_keys.push_back(entry->second);
 				}
+				auto index = pk_table_entry_ptr->storage->info->indexes.FindForeignKeyIndex(
+				    fk.info.pk_keys, ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE);
+				if (!index) {
+					auto fk_column_names = StringUtil::Join(fk.pk_columns, ",");
+					throw BinderException("Failed to create foreign key on %s(%s): no UNIQUE or PRIMARY KEY constraint "
+					                      "present on these columns",
+					                      pk_table_entry_ptr->name, fk_column_names);
+				}
 			}
 		}
 		// We first check if there are any user types, if yes we check to which custom types they refer.
@@ -156196,7 +156205,7 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 				for (auto &keyname : fk.pk_columns) {
 					auto entry = info.name_map.find(keyname);
 					if (entry == info.name_map.end()) {
-						throw ParserException("column \"%s\" named in key does not exist", keyname);
+						throw BinderException("column \"%s\" named in key does not exist", keyname);
 					}
 					fk.info.pk_keys.push_back(entry->second);
 				}
@@ -156205,7 +156214,7 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 				for (auto &keyname : fk.fk_columns) {
 					auto entry = info.name_map.find(keyname);
 					if (entry == info.name_map.end()) {
-						throw ParserException("column \"%s\" named in key does not exist", keyname);
+						throw BinderException("column \"%s\" named in key does not exist", keyname);
 					}
 					fk.info.fk_keys.push_back(entry->second);
 				}
@@ -161206,6 +161215,7 @@ string ExpressionBinder::Bind(unique_ptr<ParsedExpression> *expr, idx_t depth, b
 
 
 
+
 namespace duckdb {
 
 void ExpressionIterator::EnumerateChildren(const Expression &expr,
@@ -161367,10 +161377,13 @@ void ExpressionIterator::EnumerateTableRefChildren(BoundTableRef &ref,
 		EnumerateQueryNodeChildren(*bound_subquery.subquery, callback);
 		break;
 	}
-	default:
-		D_ASSERT(ref.type == TableReferenceType::TABLE_FUNCTION || ref.type == TableReferenceType::BASE_TABLE ||
-		         ref.type == TableReferenceType::EMPTY);
+	case TableReferenceType::TABLE_FUNCTION:
+	case TableReferenceType::EMPTY:
+	case TableReferenceType::BASE_TABLE:
+	case TableReferenceType::CTE:
 		break;
+	default:
+		throw NotImplementedException("Unimplemented table reference type in ExpressionIterator");
 	}
 }
 
@@ -161383,8 +161396,13 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 		EnumerateQueryNodeChildren(*bound_setop.right, callback);
 		break;
 	}
-	default:
-		D_ASSERT(node.type == QueryNodeType::SELECT_NODE);
+	case QueryNodeType::RECURSIVE_CTE_NODE: {
+		auto &cte_node = (BoundRecursiveCTENode &)node;
+		EnumerateQueryNodeChildren(*cte_node.left, callback);
+		EnumerateQueryNodeChildren(*cte_node.right, callback);
+		break;
+	}
+	case QueryNodeType::SELECT_NODE: {
 		auto &bound_select = (BoundSelectNode &)node;
 		for (idx_t i = 0; i < bound_select.select_list.size(); i++) {
 			EnumerateExpression(bound_select.select_list[i], callback);
@@ -161408,6 +161426,9 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 		}
 		break;
 	}
+	default:
+		throw NotImplementedException("Unimplemented query node in ExpressionIterator");
+	}
 	for (idx_t i = 0; i < node.modifiers.size(); i++) {
 		switch (node.modifiers[i]->type) {
 		case ResultModifierType::DISTINCT_MODIFIER:
@@ -170374,11 +170395,17 @@ static void VerifyCheckConstraint(TableCatalogEntry &table, Expression &expr, Da
 	}
 }
 
-static bool FindColumnIndex(const vector<idx_t> *keys_ptr, const vector<column_t> &index_column_ids) {
-	for (idx_t i = 0; i < keys_ptr->size(); i++) {
+static bool IsForeignKeyIndex(const vector<idx_t> &fk_keys, Index &index, ForeignKeyType fk_type) {
+	if (fk_type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE ? !index.IsUnique() : !index.IsForeign()) {
+		return false;
+	}
+	if (fk_keys.size() != index.column_ids.size()) {
+		return false;
+	}
+	for (auto &fk_key : fk_keys) {
 		bool is_found = false;
-		for (idx_t j = 0; j < index_column_ids.size(); j++) {
-			if ((*keys_ptr)[i] == index_column_ids[j]) {
+		for (auto &index_key : index.column_ids) {
+			if (fk_key == index_key) {
 				is_found = true;
 				break;
 			}
@@ -170387,10 +170414,20 @@ static bool FindColumnIndex(const vector<idx_t> *keys_ptr, const vector<column_t
 			return false;
 		}
 	}
-
 	return true;
 }
 
+Index *TableIndexList::FindForeignKeyIndex(const vector<idx_t> &fk_keys, ForeignKeyType fk_type) {
+	Index *result = nullptr;
+	Scan([&](Index &index) {
+		if (IsForeignKeyIndex(fk_keys, index, fk_type)) {
+			result = &index;
+		}
+		return false;
+	});
+	return result;
+}
+
 static void VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, ClientContext &context, DataChunk &chunk,
                                        bool is_append) {
 	const vector<idx_t> *src_keys_ptr = &bfk.info.fk_keys;
@@ -170429,26 +170466,24 @@ static void VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk, Cli
 	err_msgs.resize(count);
 	tran_err_msgs.resize(count);
 
+	auto fk_type = is_append ? ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE : ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
 	// check whether or not the chunk can be inserted or deleted into the referenced table' storage
-	TableIndexList &table_indices = data_table->info->indexes;
-	table_indices.Scan([&](Index &index) {
-		if (FindColumnIndex(dst_keys_ptr, index.column_ids)) {
-			if (is_append) {
-				index.VerifyAppendForeignKey(dst_chunk, err_msgs.data());
-			} else {
-				index.VerifyDeleteForeignKey(dst_chunk, err_msgs.data());
-			}
-		}
-		return false;
-	});
-
+	auto index = data_table->info->indexes.FindForeignKeyIndex(*dst_keys_ptr, fk_type);
+	if (!index) {
+		throw InternalException("Internal Foreign Key error: could not find index to verify...");
+	}
+	if (is_append) {
+		index->VerifyAppendForeignKey(dst_chunk, err_msgs.data());
+	} else {
+		index->VerifyDeleteForeignKey(dst_chunk, err_msgs.data());
+	}
 	// check whether or not the chunk can be inserted or deleted into the referenced table' transaction local storage
 	auto &transaction = Transaction::GetTransaction(context);
 	bool transaction_check = transaction.storage.Find(data_table);
 	if (transaction_check) {
 		vector<unique_ptr<Index>> &transact_index_vec = transaction.storage.GetIndexes(data_table);
 		for (idx_t i = 0; i < transact_index_vec.size(); i++) {
-			if (FindColumnIndex(dst_keys_ptr, transact_index_vec[i]->column_ids)) {
+			if (IsForeignKeyIndex(*dst_keys_ptr, *transact_index_vec[i], fk_type)) {
 				if (is_append) {
 					transact_index_vec[i]->VerifyAppendForeignKey(dst_chunk, tran_err_msgs.data());
 				} else {

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "29c1379da"
-#define DUCKDB_VERSION "v0.3.3-dev1401"
+#define DUCKDB_SOURCE_ID "6ac91ddc1"
+#define DUCKDB_VERSION "v0.3.3-dev1409"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -20947,6 +20947,8 @@ public:
 		return indexes.size();
 	}
 
+	Index *FindForeignKeyIndex(const vector<idx_t> &fk_keys, ForeignKeyType fk_type);
+
 private:
 	//! Indexes associated with the current table
 	mutex indexes_lock;