duckdb 0.5.2-dev18.0 → 0.5.2-dev32.0

package/package.json

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

package/src/duckdb.cpp

@@ -118599,15 +118599,47 @@ void DuckDBColumnsFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+namespace duckdb {
+
+struct UniqueKeyInfo {
+	string schema, table;
+	vector<storage_t> columns;
+
+	bool operator==(const UniqueKeyInfo &other) const {
+		return (schema == other.schema) && (table == other.table) && (columns == other.columns);
+	}
+};
+
+} // namespace duckdb
+
+namespace std {
+
+template <>
+struct hash<duckdb::UniqueKeyInfo> {
+	template <class X>
+	static size_t ComputeHash(const X &x) {
+		return hash<X>()(x);
+	}
+
+	size_t operator()(const duckdb::UniqueKeyInfo &j) const {
+		D_ASSERT(j.columns.size() > 0);
+		return ComputeHash(j.schema) + ComputeHash(j.table) + ComputeHash(j.columns[0]);
+	}
+};
+
+} // namespace std
+
 namespace duckdb {
 
 struct DuckDBConstraintsData : public GlobalTableFunctionState {
-	DuckDBConstraintsData() : offset(0), constraint_offset(0) {
+	DuckDBConstraintsData() : offset(0), constraint_offset(0), unique_constraint_offset(0) {
 	}
 
 	vector<CatalogEntry *> entries;
 	idx_t offset;
 	idx_t constraint_offset;
+	idx_t unique_constraint_offset;
+	unordered_map<UniqueKeyInfo, idx_t> known_fk_unique_constraint_offsets;
 };
 
 static unique_ptr<FunctionData> DuckDBConstraintsBind(ClientContext &context, TableFunctionBindInput &input,
@@ -118638,7 +118670,6 @@ static unique_ptr<FunctionData> DuckDBConstraintsBind(ClientContext &context, Ta
 	return_types.emplace_back(LogicalType::VARCHAR);
 
 	names.emplace_back("constraint_column_indexes");
-	;
 	return_types.push_back(LogicalType::LIST(LogicalType::BIGINT));
 
 	names.emplace_back("constraint_column_names");
@@ -118650,15 +118681,29 @@ static unique_ptr<FunctionData> DuckDBConstraintsBind(ClientContext &context, Ta
 unique_ptr<GlobalTableFunctionState> DuckDBConstraintsInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBConstraintsData>();
 
-	// scan all the schemas for tables and collect themand collect them
+	// scan all the schemas for tables and collect them
 	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
+
+	sort(schemas.begin(), schemas.end(), [&](CatalogEntry *x, CatalogEntry *y) { return (x->name < y->name); });
+
+	// check the temp schema as well
+	auto &temp_schema = ClientData::Get(context).temporary_objects;
+	schemas.push_back(temp_schema.get());
+
 	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
+		vector<CatalogEntry *> entries;
+
+		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
+			if (entry->type == CatalogType::TABLE_ENTRY) {
+				entries.push_back(entry);
+			}
+		});
+
+		sort(entries.begin(), entries.end(), [&](CatalogEntry *x, CatalogEntry *y) { return (x->name < y->name); });
+
+		result->entries.insert(result->entries.end(), entries.begin(), entries.end());
 	};
 
-	// check the temp schema as well
-	ClientData::Get(context).temporary_objects->Scan(context, CatalogType::TABLE_ENTRY,
-	                                                 [&](CatalogEntry *entry) { result->entries.push_back(entry); });
 	return move(result);
 }
 
@@ -118673,30 +118718,15 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 	idx_t count = 0;
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
 		auto &entry = data.entries[data.offset];
-
-		if (entry->type != CatalogType::TABLE_ENTRY) {
-			data.offset++;
-			continue;
-		}
+		D_ASSERT(entry->type == CatalogType::TABLE_ENTRY);
 
 		auto &table = (TableCatalogEntry &)*entry;
 		for (; data.constraint_offset < table.constraints.size() && count < STANDARD_VECTOR_SIZE;
 		     data.constraint_offset++) {
 			auto &constraint = table.constraints[data.constraint_offset];
 			// return values:
-			// schema_name, LogicalType::VARCHAR
-			output.SetValue(0, count, Value(table.schema->name));
-			// schema_oid, LogicalType::BIGINT
-			output.SetValue(1, count, Value::BIGINT(table.schema->oid));
-			// table_name, LogicalType::VARCHAR
-			output.SetValue(2, count, Value(table.name));
-			// table_oid, LogicalType::BIGINT
-			output.SetValue(3, count, Value::BIGINT(table.oid));
-
-			// constraint_index, BIGINT
-			output.SetValue(4, count, Value::BIGINT(data.constraint_offset));
-
 			// constraint_type, VARCHAR
+			// Processing this first due to shortcut (early continue)
 			string constraint_type;
 			switch (constraint->type) {
 			case ConstraintType::CHECK:
@@ -118710,14 +118740,73 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			case ConstraintType::NOT_NULL:
 				constraint_type = "NOT NULL";
 				break;
-			case ConstraintType::FOREIGN_KEY:
+			case ConstraintType::FOREIGN_KEY: {
+				auto &bound_foreign_key =
+				    (const BoundForeignKeyConstraint &)*table.bound_constraints[data.constraint_offset];
+				if (bound_foreign_key.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE) {
+					// Those are already covered by PRIMARY KEY and UNIQUE entries
+					continue;
+				}
 				constraint_type = "FOREIGN KEY";
 				break;
+			}
 			default:
 				throw NotImplementedException("Unimplemented constraint for duckdb_constraints");
 			}
 			output.SetValue(5, count, Value(constraint_type));
 
+			// schema_name, LogicalType::VARCHAR
+			output.SetValue(0, count, Value(table.schema->name));
+			// schema_oid, LogicalType::BIGINT
+			output.SetValue(1, count, Value::BIGINT(table.schema->oid));
+			// table_name, LogicalType::VARCHAR
+			output.SetValue(2, count, Value(table.name));
+			// table_oid, LogicalType::BIGINT
+			output.SetValue(3, count, Value::BIGINT(table.oid));
+
+			// constraint_index, BIGINT
+			auto &bound_constraint = (BoundConstraint &)*table.bound_constraints[data.constraint_offset];
+			UniqueKeyInfo uk_info;
+			switch (bound_constraint.type) {
+			case ConstraintType::UNIQUE: {
+				auto &bound_unique = (BoundUniqueConstraint &)bound_constraint;
+				uk_info = {table.schema->name, table.name, bound_unique.keys};
+				break;
+			}
+			case ConstraintType::FOREIGN_KEY: {
+				const auto &bound_foreign_key = (const BoundForeignKeyConstraint &)bound_constraint;
+				const auto &info = bound_foreign_key.info;
+				uk_info = {info.schema, info.table, info.pk_keys};
+				if (uk_info.schema.empty()) {
+					// FIXME: Can we somehow make use of Binder::BindSchema() here?
+					// From experiments, an omitted schema in REFERENCES ... means "main" or "temp", even if the table
+					// resides in a different schema. Is this guaranteed to be stable?
+					if (entry->temporary) {
+						uk_info.schema = "temp";
+					} else {
+						uk_info.schema = "main";
+					}
+				}
+
+				break;
+			}
+			default:
+				break;
+			}
+
+			if (uk_info.columns.empty()) {
+				output.SetValue(4, count, Value::BIGINT(data.unique_constraint_offset++));
+			} else {
+				auto known_unique_constraint_offset = data.known_fk_unique_constraint_offsets.find(uk_info);
+				if (known_unique_constraint_offset == data.known_fk_unique_constraint_offsets.end()) {
+					data.known_fk_unique_constraint_offsets.insert(make_pair(uk_info, data.unique_constraint_offset));
+					output.SetValue(4, count, Value::BIGINT(data.unique_constraint_offset));
+					data.unique_constraint_offset++;
+				} else {
+					output.SetValue(4, count, Value::BIGINT(known_unique_constraint_offset->second));
+				}
+			}
+
 			// constraint_text, VARCHAR
 			output.SetValue(6, count, Value(constraint->ToString()));
 
@@ -118729,7 +118818,6 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			}
 			output.SetValue(7, count, expression_text);
 
-			auto &bound_constraint = (BoundConstraint &)*table.bound_constraints[data.constraint_offset];
 			vector<column_t> column_index_list;
 			switch (bound_constraint.type) {
 			case ConstraintType::CHECK: {
@@ -118752,7 +118840,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 				break;
 			}
 			case ConstraintType::FOREIGN_KEY: {
-				auto &bound_foreign_key = (BoundForeignKeyConstraint &)bound_constraint;
+				auto &bound_foreign_key = (const BoundForeignKeyConstraint &)bound_constraint;
 				for (auto &col_idx : bound_foreign_key.info.fk_keys) {
 					column_index_list.push_back(column_t(col_idx));
 				}

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 "09248843b"
-#define DUCKDB_VERSION "v0.5.2-dev18"
+#define DUCKDB_SOURCE_ID "a272c85bc"
+#define DUCKDB_VERSION "v0.5.2-dev32"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -9491,7 +9491,7 @@ struct ForeignKeyInfo {
 	//! The set of main key table's column's index
 	vector<storage_t> pk_keys;
 	//! The set of foreign key table's column's index
-	vector<idx_t> fk_keys;
+	vector<storage_t> fk_keys;
 };
 
 //! Constraint is the base class of any type of table constraint.