duckdb 0.5.2-dev2.0 → 0.5.2-dev34.0

package/package.json

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

package/src/duckdb.cpp

@@ -43588,12 +43588,16 @@ hash_t Hash(hugeint_t val) {
 
 template <>
 hash_t Hash(float val) {
-	return std::hash<float> {}(val);
+	static_assert(sizeof(float) == sizeof(uint32_t), "");
+	uint32_t uval = *((uint32_t *)&val);
+	return murmurhash64(uval);
 }
 
 template <>
 hash_t Hash(double val) {
-	return std::hash<double> {}(val);
+	static_assert(sizeof(double) == sizeof(uint64_t), "");
+	uint64_t uval = *((uint64_t *)&val);
+	return murmurhash64(uval);
 }
 
 template <>
@@ -45707,6 +45711,11 @@ public:
 		return layout.GetTypes();
 	}
 
+	//! The number of rows in the collection
+	inline idx_t Count() const {
+		return total_count;
+	}
+
 	//! The number of rows scanned so far
 	inline idx_t Scanned() const {
 		return total_scanned;
@@ -66288,7 +66297,7 @@ void WindowBoundariesState::Update(const idx_t row_idx, WindowInputColumn &range
 struct WindowExecutor {
 	WindowExecutor(BoundWindowExpression *wexpr, Allocator &allocator, const idx_t count);
 
-	void Sink(DataChunk &input_chunk, const idx_t input_idx);
+	void Sink(DataChunk &input_chunk, const idx_t input_idx, const idx_t total_count);
 	void Finalize(WindowAggregationMode mode);
 
 	void Evaluate(idx_t row_idx, DataChunk &input_chunk, Vector &result, const ValidityMask &partition_mask,
@@ -66362,7 +66371,7 @@ WindowExecutor::WindowExecutor(BoundWindowExpression *wexpr, Allocator &allocato
 	PrepareInputExpressions(exprs.data(), exprs.size(), payload_executor, payload_chunk);
 }
 
-void WindowExecutor::Sink(DataChunk &input_chunk, const idx_t input_idx) {
+void WindowExecutor::Sink(DataChunk &input_chunk, const idx_t input_idx, const idx_t total_count) {
 	// Single pass over the input to produce the global data.
 	// Vectorisation for the win...
 
@@ -66397,7 +66406,7 @@ void WindowExecutor::Sink(DataChunk &input_chunk, const idx_t input_idx) {
 			if (!vdata.validity.AllValid()) {
 				//	Lazily materialise the contents when we find the first NULL
 				if (ignore_nulls.AllValid()) {
-					ignore_nulls.Initialize(payload_collection.Count());
+					ignore_nulls.Initialize(total_count);
 				}
 				// Write to the current position
 				// Chunks in a collection are full, so we don't have to worry about raggedness
@@ -66926,7 +66935,7 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 
 		//	TODO: Parallelization opportunity
 		for (auto &wexec : window_execs) {
-			wexec->Sink(input_chunk, input_idx);
+			wexec->Sink(input_chunk, input_idx, scanner->Count());
 		}
 		input_idx += input_chunk.size();
 	}
@@ -118595,15 +118604,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,
@@ -118634,7 +118675,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");
@@ -118646,15 +118686,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);
 }
 
@@ -118669,30 +118723,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:
@@ -118706,14 +118745,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()));
 
@@ -118725,7 +118823,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: {
@@ -118748,7 +118845,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));
 				}
@@ -120916,6 +121013,13 @@ static void PragmaStorageInfoFunction(ClientContext &context, TableFunctionInput
 	auto &bind_data = (PragmaStorageFunctionData &)*data_p.bind_data;
 	auto &data = (PragmaStorageOperatorData &)*data_p.global_state;
 	idx_t count = 0;
+	map<storage_t, column_t> soid_to_idx;
+	for (idx_t cidx = 0; cidx < bind_data.table_entry->columns.size(); cidx++) {
+		auto &entry = bind_data.table_entry->columns[cidx];
+		if (!entry.Generated()) {
+			soid_to_idx[entry.StorageOid()] = entry.Oid();
+		}
+	}
 	while (data.offset < bind_data.storage_info.size() && count < STANDARD_VECTOR_SIZE) {
 		auto &entry = bind_data.storage_info[data.offset++];
 		D_ASSERT(entry.size() + 1 == output.ColumnCount());
@@ -120923,8 +121027,9 @@ static void PragmaStorageInfoFunction(ClientContext &context, TableFunctionInput
 		for (idx_t col_idx = 0; col_idx < entry.size(); col_idx++, result_idx++) {
 			if (col_idx == 1) {
 				// write the column name
-				auto column_index = entry[col_idx].GetValue<int64_t>();
-				output.SetValue(result_idx, count, Value(bind_data.table_entry->columns[column_index].Name()));
+				auto storage_column_index = entry[col_idx].GetValue<int64_t>();
+				output.SetValue(result_idx, count,
+				                Value(bind_data.table_entry->columns[soid_to_idx[storage_column_index]].Name()));
 				result_idx++;
 			}
 			output.SetValue(result_idx, count, entry[col_idx]);
@@ -197917,8 +198022,9 @@ void DataTable::VerifyAppendConstraints(TableCatalogEntry &table, ClientContext
 		auto &constraint = table.bound_constraints[i];
 		switch (base_constraint->type) {
 		case ConstraintType::NOT_NULL: {
-			auto &not_null = *reinterpret_cast<BoundNotNullConstraint *>(constraint.get());
-			VerifyNotNullConstraint(table, chunk.data[not_null.index], chunk.size(),
+			auto &bound_not_null = *reinterpret_cast<BoundNotNullConstraint *>(constraint.get());
+			auto &not_null = *reinterpret_cast<NotNullConstraint *>(base_constraint.get());
+			VerifyNotNullConstraint(table, chunk.data[bound_not_null.index], chunk.size(),
 			                        table.columns[not_null.index].Name());
 			break;
 		}
@@ -198389,13 +198495,16 @@ static bool CreateMockChunk(TableCatalogEntry &table, const vector<column_t> &co
 
 void DataTable::VerifyUpdateConstraints(TableCatalogEntry &table, DataChunk &chunk,
                                         const vector<column_t> &column_ids) {
-	for (auto &constraint : table.bound_constraints) {
+	for (idx_t i = 0; i < table.bound_constraints.size(); i++) {
+		auto &base_constraint = table.constraints[i];
+		auto &constraint = table.bound_constraints[i];
 		switch (constraint->type) {
 		case ConstraintType::NOT_NULL: {
-			auto &not_null = *reinterpret_cast<BoundNotNullConstraint *>(constraint.get());
+			auto &bound_not_null = *reinterpret_cast<BoundNotNullConstraint *>(constraint.get());
+			auto &not_null = *reinterpret_cast<NotNullConstraint *>(base_constraint.get());
 			// check if the constraint is in the list of column_ids
 			for (idx_t i = 0; i < column_ids.size(); i++) {
-				if (column_ids[i] == not_null.index) {
+				if (column_ids[i] == bound_not_null.index) {
 					// found the column id: check the data in
 					VerifyNotNullConstraint(table, chunk.data[i], chunk.size(), table.columns[not_null.index].Name());
 					break;

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 "8b019cb8e"
-#define DUCKDB_VERSION "v0.5.2-dev2"
+#define DUCKDB_SOURCE_ID "d8f7ef99b"
+#define DUCKDB_VERSION "v0.5.2-dev34"
 //===----------------------------------------------------------------------===//
 //                         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.
@@ -11416,6 +11416,7 @@ public:
 	DUCKDB_API ~ColumnDataCollection();
 
 public:
+	//! The types of columns in the ColumnDataCollection
 	DUCKDB_API vector<LogicalType> &Types() {
 		return types;
 	}
@@ -14409,7 +14410,7 @@ public:
 	ChunkCollection(Allocator &allocator);
 	ChunkCollection(ClientContext &context);
 
-	//! The amount of columns in the ChunkCollection
+	//! The types of columns in the ChunkCollection
 	DUCKDB_API vector<LogicalType> &Types() {
 		return types;
 	}