duckdb 0.3.5-dev162.0 → 0.3.5-dev169.0

package/package.json

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

package/src/duckdb.cpp

@@ -51502,7 +51502,7 @@ void ART::VerifyExistence(DataChunk &chunk, VerifyExistenceType verify_type, str
 		case VerifyExistenceType::APPEND_FK: {
 			// found node no exists in tree
 			exception_msg =
-			    "violates foreign key constraint because key \"" + key_name + "\" no exist in referenced table";
+			    "violates foreign key constraint because key \"" + key_name + "\" does not exist in referenced table";
 			break;
 		}
 		case VerifyExistenceType::DELETE_FK: {
@@ -88836,8 +88836,8 @@ void ListExtractFun::RegisterFunction(BuiltinFunctions &set) {
 namespace duckdb {
 
 struct ListSortBindData : public FunctionData {
-	ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p, LogicalType &return_type_p,
-	                 LogicalType &child_type_p, ClientContext &context_p);
+	ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p, const LogicalType &return_type_p,
+	                 const LogicalType &child_type_p, ClientContext &context_p);
 	~ListSortBindData() override;
 
 	OrderType order_type;
@@ -88853,11 +88853,14 @@ struct ListSortBindData : public FunctionData {
 	RowLayout payload_layout;
 	vector<BoundOrderByNode> orders;
 
-	unique_ptr<FunctionData> Copy() override;
+public:
+	bool Equals(const FunctionData &other_p) const override;
+	unique_ptr<FunctionData> Copy() const override;
 };
 
-ListSortBindData::ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p, LogicalType &return_type_p,
-                                   LogicalType &child_type_p, ClientContext &context_p)
+ListSortBindData::ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p,
+                                   const LogicalType &return_type_p, const LogicalType &child_type_p,
+                                   ClientContext &context_p)
     : order_type(order_type_p), null_order(null_order_p), return_type(return_type_p), child_type(child_type_p),
       context(context_p) {
 
@@ -88880,10 +88883,15 @@ ListSortBindData::ListSortBindData(OrderType order_type_p, OrderByNullType null_
 	orders.emplace_back(order_type, null_order, move(lists_col_expr));
 }
 
-unique_ptr<FunctionData> ListSortBindData::Copy() {
+unique_ptr<FunctionData> ListSortBindData::Copy() const {
 	return make_unique<ListSortBindData>(order_type, null_order, return_type, child_type, context);
 }
 
+bool ListSortBindData::Equals(const FunctionData &other_p) const {
+	auto &other = (ListSortBindData &)other_p;
+	return order_type == other.order_type && null_order == other.null_order;
+}
+
 ListSortBindData::~ListSortBindData() {
 }
 
@@ -148066,10 +148074,12 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 		for (auto kc = constraint->fk_attrs->head; kc; kc = kc->next) {
 			fk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
 		}
-		for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
-			pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
+		if (constraint->pk_attrs) {
+			for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
+				pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
+			}
 		}
-		if (pk_columns.size() != fk_columns.size()) {
+		if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
 			throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
 		}
 		if (fk_columns.empty()) {
@@ -157079,6 +157089,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 SchemaCatalogEntry *Binder::BindSchema(CreateInfo &info) {
@@ -157203,6 +157214,35 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, const st
 	}
 }
 
+static void FindMatchingPrimaryKeyColumns(vector<unique_ptr<Constraint>> &constraints, ForeignKeyConstraint &fk) {
+	if (!fk.pk_columns.empty()) {
+		return;
+	}
+	// find the matching primary key constraint
+	for (auto &constr : constraints) {
+		if (constr->type != ConstraintType::UNIQUE) {
+			continue;
+		}
+		auto &unique = (UniqueConstraint &)*constr;
+		if (!unique.is_primary_key) {
+			continue;
+		}
+		idx_t column_count;
+		if (unique.index != DConstants::INVALID_INDEX) {
+			fk.info.pk_keys.push_back(unique.index);
+			column_count = 1;
+		} else {
+			fk.pk_columns = unique.columns;
+			column_count = unique.columns.size();
+		}
+		if (column_count != fk.fk_columns.size()) {
+			throw BinderException("The number of referencing and referenced columns for foreign keys must be the same");
+		}
+		return;
+	}
+	throw BinderException("there is no primary key for referenced table \"%s\"", fk.info.table);
+}
+
 BoundStatement Binder::Bind(CreateStatement &stmt) {
 	BoundStatement result;
 	result.names = {"Count"};
@@ -157283,13 +157323,15 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			if (fk.info.type != ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
 				continue;
 			}
-			D_ASSERT(fk.info.pk_keys.empty() && !fk.pk_columns.empty());
+			D_ASSERT(fk.info.pk_keys.empty());
 			if (create_info.table == fk.info.table) {
 				fk.info.type = ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE;
+				FindMatchingPrimaryKeyColumns(create_info.constraints, fk);
 			} else {
 				// have to resolve referenced table
 				auto pk_table_entry_ptr = catalog.GetEntry<TableCatalogEntry>(context, fk.info.schema, fk.info.table);
-				D_ASSERT(!fk.pk_columns.empty() && fk.info.pk_keys.empty());
+				D_ASSERT(fk.info.pk_keys.empty());
+				FindMatchingPrimaryKeyColumns(pk_table_entry_ptr->constraints, fk);
 				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()) {
@@ -172948,15 +172990,27 @@ static void UpdateChunk(Vector &data, Vector &updates, Vector &row_ids, idx_t co
 	case PhysicalType::INT8:
 		TemplatedUpdateLoop<int8_t>(data, updates, row_ids, count, base_index);
 		break;
+	case PhysicalType::UINT8:
+		TemplatedUpdateLoop<uint8_t>(data, updates, row_ids, count, base_index);
+		break;
 	case PhysicalType::INT16:
 		TemplatedUpdateLoop<int16_t>(data, updates, row_ids, count, base_index);
 		break;
+	case PhysicalType::UINT16:
+		TemplatedUpdateLoop<uint16_t>(data, updates, row_ids, count, base_index);
+		break;
 	case PhysicalType::INT32:
 		TemplatedUpdateLoop<int32_t>(data, updates, row_ids, count, base_index);
 		break;
+	case PhysicalType::UINT32:
+		TemplatedUpdateLoop<uint32_t>(data, updates, row_ids, count, base_index);
+		break;
 	case PhysicalType::INT64:
 		TemplatedUpdateLoop<int64_t>(data, updates, row_ids, count, base_index);
 		break;
+	case PhysicalType::UINT64:
+		TemplatedUpdateLoop<uint64_t>(data, updates, row_ids, count, base_index);
+		break;
 	case PhysicalType::FLOAT:
 		TemplatedUpdateLoop<float>(data, updates, row_ids, count, base_index);
 		break;