duckdb 0.8.2-dev2842.0 → 0.8.2-dev2850.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev2842.0",
+  "version": "0.8.2-dev2850.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/json/include/json_deserializer.hpp

@@ -48,7 +48,7 @@ private:
 	void ThrowTypeError(yyjson_val *val, const char *expected);
 
 	// Set the 'tag' of the property to read
-	void SetTag(const field_id_t field_id, const char *tag) final;
+	void SetTag(const field_id_t, const char *tag) final;
 
 	//===--------------------------------------------------------------------===//
 	// Nested Types Hooks

package/src/duckdb/extension/json/include/json_serializer.hpp

@@ -42,7 +42,7 @@ public:
 		return stack.front();
 	};
 
-	void SetTag(const field_id_t field_id, const char *tag) final;
+	void SetTag(const field_id_t, const char *tag) final;
 
 	//===--------------------------------------------------------------------===//
 	// Nested Types Hooks

package/src/duckdb/extension/json/json_deserializer.cpp

@@ -3,7 +3,7 @@
 
 namespace duckdb {
 
-void JsonDeserializer::SetTag(const field_id_t field_id, const char *tag) {
+void JsonDeserializer::SetTag(const field_id_t, const char *tag) {
 	current_tag = tag;
 }
 
@@ -43,8 +43,10 @@ void JsonDeserializer::ThrowTypeError(yyjson_val *val, const char *expected) {
 	if (yyjson_is_obj(parent.val)) {
 		auto msg =
 		    StringUtil::Format("property '%s' expected type '%s', but got type: '%s'", current_tag, expected, actual);
+		throw ParserException(msg);
 	} else if (yyjson_is_arr(parent.val)) {
 		auto msg = StringUtil::Format("Sequence expect child of type '%s', but got type: %s", expected, actual);
+		throw ParserException(msg);
 	} else {
 		// unreachable?
 		throw InternalException("cannot get nested value from non object or array-type");
@@ -178,7 +180,7 @@ bool JsonDeserializer::ReadBool() {
 
 int8_t JsonDeserializer::ReadSignedInt8() {
 	auto val = GetNextValue();
-	if (!yyjson_is_sint(val)) {
+	if (!yyjson_is_int(val)) {
 		ThrowTypeError(val, "int8_t");
 	}
 	return yyjson_get_sint(val);
@@ -194,7 +196,7 @@ uint8_t JsonDeserializer::ReadUnsignedInt8() {
 
 int16_t JsonDeserializer::ReadSignedInt16() {
 	auto val = GetNextValue();
-	if (!yyjson_is_sint(val)) {
+	if (!yyjson_is_int(val)) {
 		ThrowTypeError(val, "int16_t");
 	}
 	return yyjson_get_sint(val);
@@ -210,7 +212,7 @@ uint16_t JsonDeserializer::ReadUnsignedInt16() {
 
 int32_t JsonDeserializer::ReadSignedInt32() {
 	auto val = GetNextValue();
-	if (!yyjson_is_sint(val)) {
+	if (!yyjson_is_int(val)) {
 		ThrowTypeError(val, "int32_t");
 	}
 	return yyjson_get_sint(val);
@@ -226,7 +228,7 @@ uint32_t JsonDeserializer::ReadUnsignedInt32() {
 
 int64_t JsonDeserializer::ReadSignedInt64() {
 	auto val = GetNextValue();
-	if (!yyjson_is_sint(val)) {
+	if (!yyjson_is_int(val)) {
 		ThrowTypeError(val, "int64_t");
 	}
 	return yyjson_get_sint(val);

package/src/duckdb/extension/json/json_serializer.cpp

@@ -19,8 +19,7 @@ void JsonSerializer::PushValue(yyjson_mut_val *val) {
 	}
 }
 
-void JsonSerializer::SetTag(const field_id_t field_id, const char *tag) {
-	(void)field_id;
+void JsonSerializer::SetTag(const field_id_t, const char *tag) {
 	current_tag = yyjson_mut_strcpy(doc, tag);
 }
 
@@ -173,7 +172,7 @@ void JsonSerializer::WriteValue(uint32_t value) {
 }
 
 void JsonSerializer::WriteValue(int32_t value) {
-	auto val = yyjson_mut_int(doc, value);
+	auto val = yyjson_mut_sint(doc, value);
 	PushValue(val);
 }
 

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev2842"
+#define DUCKDB_VERSION "0.8.2-dev2850"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "6421a36e94"
+#define DUCKDB_SOURCE_ID "e2128946cc"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp

@@ -17,8 +17,58 @@ static void ParseSchemaTableNameFK(duckdb_libpgquery::PGRangeVar *input, Foreign
 	fk_info.table = input->relname;
 }
 
+static bool ForeignKeyActionSupported(char action) {
+	switch (action) {
+	case PG_FKCONSTR_ACTION_NOACTION:
+	case PG_FKCONSTR_ACTION_RESTRICT:
+		return true;
+	case PG_FKCONSTR_ACTION_CASCADE:
+	case PG_FKCONSTR_ACTION_SETDEFAULT:
+	case PG_FKCONSTR_ACTION_SETNULL:
+		return false;
+	default:
+		D_ASSERT(false);
+	}
+	return false;
+}
+
+static unique_ptr<ForeignKeyConstraint>
+TransformForeignKeyConstraint(duckdb_libpgquery::PGConstraint *constraint,
+                              optional_ptr<const string> override_fk_column = nullptr) {
+	D_ASSERT(constraint);
+	if (!ForeignKeyActionSupported(constraint->fk_upd_action) ||
+	    !ForeignKeyActionSupported(constraint->fk_del_action)) {
+		throw ParserException("FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT");
+	}
+	ForeignKeyInfo fk_info;
+	fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
+	ParseSchemaTableNameFK(constraint->pktable, fk_info);
+	vector<string> pk_columns, fk_columns;
+	if (override_fk_column) {
+		D_ASSERT(!constraint->fk_attrs);
+		fk_columns.emplace_back(*override_fk_column);
+	} else if (constraint->fk_attrs) {
+		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);
+		}
+	}
+	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.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()) {
+		throw ParserException("The set of referencing and referenced columns for foreign keys must be not empty");
+	}
+	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
+}
+
 unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGListCell *cell) {
 	auto constraint = reinterpret_cast<duckdb_libpgquery::PGConstraint *>(cell->data.ptr_value);
+	D_ASSERT(constraint);
 	switch (constraint->contype) {
 	case duckdb_libpgquery::PG_CONSTR_UNIQUE:
 	case duckdb_libpgquery::PG_CONSTR_PRIMARY: {
@@ -36,27 +86,9 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 		}
 		return make_uniq<CheckConstraint>(TransformExpression(constraint->raw_expr));
 	}
-	case duckdb_libpgquery::PG_CONSTR_FOREIGN: {
-		ForeignKeyInfo fk_info;
-		fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-		ParseSchemaTableNameFK(constraint->pktable, fk_info);
-		vector<string> pk_columns, fk_columns;
-		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);
-		}
-		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.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()) {
-			throw ParserException("The set of referencing and referenced columns for foreign keys must be not empty");
-		}
-		return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
-	}
+	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
+		return TransformForeignKeyConstraint(constraint);
+
 	default:
 		throw NotImplementedException("Constraint type not handled yet!");
 	}
@@ -96,23 +128,8 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 			                      "dictionary, pfor, bitpacking or fsst");
 		}
 		return nullptr;
-	case duckdb_libpgquery::PG_CONSTR_FOREIGN: {
-		ForeignKeyInfo fk_info;
-		fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-		ParseSchemaTableNameFK(constraint->pktable, fk_info);
-
-		vector<string> pk_columns, fk_columns;
-		fk_columns.emplace_back(column.Name().c_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.empty() && pk_columns.size() != fk_columns.size()) {
-			throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
-		}
-		return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
-	}
+	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
+		return TransformForeignKeyConstraint(constraint, &column.Name());
 	default:
 		throw NotImplementedException("Constraint not implemented!");
 	}