duckdb 0.3.3-dev1397.0 → 0.3.3-dev1404.0

package/package.json

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

package/src/duckdb.cpp

@@ -71601,17 +71601,21 @@ void RadixPartitionedHashTable::GetData(ExecutionContext &context, DataChunk &ch
 	// special case hack to sort out aggregating from empty intermediates
 	// for aggregations without groups
 	if (gstate.is_empty && grouping_set.empty()) {
-		D_ASSERT(chunk.ColumnCount() == op.aggregates.size());
+		D_ASSERT(chunk.ColumnCount() == null_groups.size() + op.aggregates.size());
 		// for each column in the aggregates, set to initial state
 		chunk.SetCardinality(1);
-		for (idx_t i = 0; i < chunk.ColumnCount(); i++) {
+		for (auto null_group : null_groups) {
+			chunk.data[null_group].SetVectorType(VectorType::CONSTANT_VECTOR);
+			ConstantVector::SetNull(chunk.data[null_group], true);
+		}
+		for (idx_t i = 0; i < op.aggregates.size(); i++) {
 			D_ASSERT(op.aggregates[i]->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
 			auto &aggr = (BoundAggregateExpression &)*op.aggregates[i];
 			auto aggr_state = unique_ptr<data_t[]>(new data_t[aggr.function.state_size()]);
 			aggr.function.initialize(aggr_state.get());
 
 			Vector state_vector(Value::POINTER((uintptr_t)aggr_state.get()));
-			aggr.function.finalize(state_vector, aggr.bind_info.get(), chunk.data[i], 1, 0);
+			aggr.function.finalize(state_vector, aggr.bind_info.get(), chunk.data[null_groups.size() + i], 1, 0);
 			if (aggr.function.destructor) {
 				aggr.function.destructor(state_vector, 1);
 			}
@@ -84399,7 +84403,7 @@ char *StrfTimeFormat::Write2(char *target, uint8_t value) {
 }
 
 // write a value in the range of 0..99 padded to 2 digits
-char *StrfTimeFormat::WritePadded2(char *target, int32_t value) {
+char *StrfTimeFormat::WritePadded2(char *target, uint32_t value) {
 	D_ASSERT(value < 100);
 	auto index = static_cast<unsigned>(value * 2);
 	*target++ = duckdb_fmt::internal::data::digits[index];
@@ -84422,9 +84426,9 @@ char *StrfTimeFormat::WritePadded3(char *target, uint32_t value) {
 }
 
 // write a value in the range of 0..999999 padded to 6 digits
-char *StrfTimeFormat::WritePadded(char *target, int32_t value, int32_t padding) {
+char *StrfTimeFormat::WritePadded(char *target, uint32_t value, size_t padding) {
 	D_ASSERT(padding % 2 == 0);
-	for (int i = 0; i < padding / 2; i++) {
+	for (size_t i = 0; i < padding / 2; i++) {
 		int decimals = value % 100;
 		WritePadded2(target + padding - 2 * (i + 1), decimals);
 		value /= 100;
@@ -84599,6 +84603,7 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 }
 
 void StrfTimeFormat::FormatString(date_t date, int32_t data[7], char *target) {
+	D_ASSERT(specifiers.size() + 1 == literals.size());
 	idx_t i;
 	for (i = 0; i < specifiers.size(); i++) {
 		// first copy the current literal
@@ -84819,12 +84824,12 @@ struct StrfTimeBindData : public FunctionData {
 template <bool REVERSED>
 static unique_ptr<FunctionData> StrfTimeBindFunction(ClientContext &context, ScalarFunction &bound_function,
                                                      vector<unique_ptr<Expression>> &arguments) {
-	if (!arguments[1]->IsFoldable()) {
+	if (!arguments[REVERSED ? 0 : 1]->IsFoldable()) {
 		throw InvalidInputException("strftime format must be a constant");
 	}
 	Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[REVERSED ? 0 : 1]);
 	StrfTimeFormat format;
-	if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
+	if (!options_str.IsNull()) {
 		auto format_string = options_str.GetValue<string>();
 		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
 		if (!error.empty()) {
@@ -155791,6 +155796,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 SchemaCatalogEntry *Binder::BindSchema(CreateInfo &info) {
@@ -156005,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.
@@ -156191,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);
 				}
@@ -156200,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);
 				}
@@ -170369,11 +170383,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;
 			}
@@ -170382,10 +170402,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;
@@ -170424,26 +170454,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 "c3ba7e5b0"
-#define DUCKDB_VERSION "v0.3.3-dev1397"
+#define DUCKDB_SOURCE_ID "514748429"
+#define DUCKDB_VERSION "v0.3.3-dev1404"
 //===----------------------------------------------------------------------===//
 //                         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;
@@ -21905,9 +21907,9 @@ protected:
 	static idx_t GetSpecifierLength(StrTimeSpecifier specifier, date_t date, dtime_t time);
 	char *WriteString(char *target, const string_t &str);
 	char *Write2(char *target, uint8_t value);
-	char *WritePadded2(char *target, int32_t value);
+	char *WritePadded2(char *target, uint32_t value);
 	char *WritePadded3(char *target, uint32_t value);
-	char *WritePadded(char *target, int32_t value, int32_t padding);
+	char *WritePadded(char *target, uint32_t value, size_t padding);
 	bool IsDateSpecifier(StrTimeSpecifier specifier);
 	char *WriteDateSpecifier(StrTimeSpecifier specifier, date_t date, char *target);
 	char *WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], char *target);