duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

package/src/duckdb/src/parser/tableref/expressionlistref.cpp

@@ -1,8 +1,7 @@
 #include "duckdb/parser/tableref/expressionlistref.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -65,44 +64,4 @@ unique_ptr<TableRef> ExpressionListRef::Copy() {
 	return std::move(result);
 }
 
-void ExpressionListRef::Serialize(FieldWriter &writer) const {
-	writer.WriteList<string>(expected_names);
-	writer.WriteRegularSerializableList<LogicalType>(expected_types);
-	auto &serializer = writer.GetSerializer();
-	writer.WriteField<uint32_t>(values.size());
-	for (idx_t i = 0; i < values.size(); i++) {
-		serializer.WriteList(values[i]);
-	}
-}
-
-void ExpressionListRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("expected_names", expected_names);
-	serializer.WriteProperty("expected_types", expected_types);
-	serializer.WriteProperty("values", values);
-}
-
-unique_ptr<TableRef> ExpressionListRef::FormatDeserialize(FormatDeserializer &source) {
-	auto result = make_uniq<ExpressionListRef>();
-	source.ReadProperty("expected_names", result->expected_names);
-	source.ReadProperty("expected_types", result->expected_types);
-	source.ReadProperty("values", result->values);
-	return std::move(result);
-}
-
-unique_ptr<TableRef> ExpressionListRef::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<ExpressionListRef>();
-	// value list
-	result->expected_names = reader.ReadRequiredList<string>();
-	result->expected_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	idx_t value_list_size = reader.ReadRequired<uint32_t>();
-	auto &source = reader.GetSource();
-	for (idx_t i = 0; i < value_list_size; i++) {
-		vector<unique_ptr<ParsedExpression>> value_list;
-		source.ReadList<ParsedExpression>(value_list);
-		result->values.push_back(std::move(value_list));
-	}
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/joinref.cpp

@@ -1,9 +1,8 @@
 #include "duckdb/parser/tableref/joinref.hpp"
 
 #include "duckdb/common/limits.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -28,6 +27,9 @@ string JoinRef::ToString() const {
 	case JoinRefType::POSITIONAL:
 		result += "POSITIONAL JOIN ";
 		break;
+	case JoinRefType::DEPENDENT:
+		result += "DEPENDENT JOIN ";
+		break;
 	}
 	result += right->ToString();
 	if (condition) {
@@ -79,47 +81,4 @@ unique_ptr<TableRef> JoinRef::Copy() {
 	return std::move(copy);
 }
 
-void JoinRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*left);
-	writer.WriteSerializable(*right);
-	writer.WriteOptional(condition);
-	writer.WriteField<JoinType>(type);
-	writer.WriteField<JoinRefType>(ref_type);
-	writer.WriteList<string>(using_columns);
-}
-
-void JoinRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("left", *left);
-	serializer.WriteProperty("right", *right);
-	serializer.WriteOptionalProperty("condition", condition);
-	serializer.WriteProperty("join_type", type);
-	serializer.WriteProperty("ref_type", ref_type);
-	serializer.WriteProperty("using_columns", using_columns);
-}
-
-unique_ptr<TableRef> JoinRef::FormatDeserialize(FormatDeserializer &source) {
-	auto result = make_uniq<JoinRef>(JoinRefType::REGULAR);
-
-	source.ReadProperty("left", result->left);
-	source.ReadProperty("right", result->right);
-	source.ReadOptionalProperty("condition", result->condition);
-	source.ReadProperty("join_type", result->type);
-	source.ReadProperty("ref_type", result->ref_type);
-	source.ReadProperty("using_columns", result->using_columns);
-
-	return std::move(result);
-}
-
-unique_ptr<TableRef> JoinRef::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<JoinRef>(JoinRefType::REGULAR);
-	result->left = reader.ReadRequiredSerializable<TableRef>();
-	result->right = reader.ReadRequiredSerializable<TableRef>();
-	result->condition = reader.ReadOptional<ParsedExpression>(nullptr);
-	result->type = reader.ReadRequired<JoinType>();
-	result->ref_type = reader.ReadRequired<JoinRefType>();
-	result->using_columns = reader.ReadRequiredList<string>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/pivotref.cpp

@@ -1,9 +1,6 @@
 #include "duckdb/parser/tableref/pivotref.hpp"
 
 #include "duckdb/common/limits.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -121,42 +118,6 @@ PivotColumn PivotColumn::Copy() const {
 	return result;
 }
 
-void PivotColumn::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteSerializableList(pivot_expressions);
-	writer.WriteList<string>(unpivot_names);
-	writer.WriteRegularSerializableList(entries);
-	writer.WriteString(pivot_enum);
-	writer.Finalize();
-}
-
-void PivotColumn::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("pivot_expressions", pivot_expressions);
-	serializer.WriteProperty("unpivot_names", unpivot_names);
-	serializer.WriteProperty("entries", entries);
-	serializer.WriteProperty("pivot_enum", pivot_enum);
-}
-
-PivotColumn PivotColumn::Deserialize(Deserializer &source) {
-	PivotColumn result;
-	FieldReader reader(source);
-	result.pivot_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
-	result.unpivot_names = reader.ReadRequiredList<string>();
-	result.entries = reader.ReadRequiredSerializableList<PivotColumnEntry, PivotColumnEntry>();
-	result.pivot_enum = reader.ReadRequired<string>();
-	reader.Finalize();
-	return result;
-}
-
-PivotColumn PivotColumn::FormatDeserialize(FormatDeserializer &source) {
-	PivotColumn result;
-	source.ReadProperty("pivot_expressions", result.pivot_expressions);
-	source.ReadProperty("unpivot_names", result.unpivot_names);
-	source.ReadProperty("entries", result.entries);
-	source.ReadProperty("pivot_enum", result.pivot_enum);
-	return result;
-}
-
 //===--------------------------------------------------------------------===//
 // PivotColumnEntry
 //===--------------------------------------------------------------------===//
@@ -168,38 +129,6 @@ PivotColumnEntry PivotColumnEntry::Copy() const {
 	return result;
 }
 
-void PivotColumnEntry::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteRegularSerializableList(values);
-	writer.WriteOptional(star_expr);
-	writer.WriteString(alias);
-	writer.Finalize();
-}
-
-void PivotColumnEntry::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("values", values);
-	serializer.WriteOptionalProperty("star_expr", star_expr);
-	serializer.WriteProperty("alias", alias);
-}
-
-PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &source) {
-	PivotColumnEntry result;
-	FieldReader reader(source);
-	result.values = reader.ReadRequiredSerializableList<Value, Value>();
-	result.star_expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	result.alias = reader.ReadRequired<string>();
-	reader.Finalize();
-	return result;
-}
-
-PivotColumnEntry PivotColumnEntry::FormatDeserialize(FormatDeserializer &source) {
-	PivotColumnEntry result;
-	source.ReadProperty("values", result.values);
-	source.ReadOptionalProperty("star_expr", result.star_expr);
-	source.ReadProperty("alias", result.alias);
-	return result;
-}
-
 //===--------------------------------------------------------------------===//
 // PivotRef
 //===--------------------------------------------------------------------===//
@@ -320,49 +249,4 @@ unique_ptr<TableRef> PivotRef::Copy() {
 	return std::move(copy);
 }
 
-void PivotRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*source);
-	writer.WriteSerializableList(aggregates);
-	writer.WriteList<string>(unpivot_names);
-	writer.WriteRegularSerializableList(pivots);
-	writer.WriteList<string>(groups);
-	writer.WriteList<string>(column_name_alias);
-	writer.WriteField<bool>(include_nulls);
-}
-
-void PivotRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("source", source);
-	serializer.WriteProperty("aggregates", aggregates);
-	serializer.WriteProperty("unpivot_names", unpivot_names);
-	serializer.WriteProperty("pivots", pivots);
-	serializer.WriteProperty("groups", groups);
-	serializer.WriteProperty("column_name_alias", column_name_alias);
-	serializer.WriteProperty("include_nulls", include_nulls);
-}
-
-unique_ptr<TableRef> PivotRef::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<PivotRef>();
-	result->source = reader.ReadRequiredSerializable<TableRef>();
-	result->aggregates = reader.ReadRequiredSerializableList<ParsedExpression>();
-	result->unpivot_names = reader.ReadRequiredList<string>();
-	result->pivots = reader.ReadRequiredSerializableList<PivotColumn, PivotColumn>();
-	result->groups = reader.ReadRequiredList<string>();
-	result->column_name_alias = reader.ReadRequiredList<string>();
-	result->include_nulls = reader.ReadRequired<bool>();
-	return std::move(result);
-}
-
-unique_ptr<TableRef> PivotRef::FormatDeserialize(FormatDeserializer &source) {
-	auto result = make_uniq<PivotRef>();
-	source.ReadProperty("source", result->source);
-	source.ReadProperty("aggregates", result->aggregates);
-	source.ReadProperty("unpivot_names", result->unpivot_names);
-	source.ReadProperty("pivots", result->pivots);
-	source.ReadProperty("groups", result->groups);
-	source.ReadProperty("column_name_alias", result->column_name_alias);
-	source.ReadProperty("include_nulls", result->include_nulls);
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/subqueryref.cpp

@@ -1,9 +1,8 @@
 #include "duckdb/parser/tableref/subqueryref.hpp"
 
 #include "duckdb/common/limits.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -12,6 +11,9 @@ string SubqueryRef::ToString() const {
 	return BaseToString(result, column_name_alias);
 }
 
+SubqueryRef::SubqueryRef() : TableRef(TableReferenceType::SUBQUERY) {
+}
+
 SubqueryRef::SubqueryRef(unique_ptr<SelectStatement> subquery_p, string alias_p)
     : TableRef(TableReferenceType::SUBQUERY), subquery(std::move(subquery_p)) {
 	this->alias = std::move(alias_p);
@@ -32,29 +34,4 @@ unique_ptr<TableRef> SubqueryRef::Copy() {
 	return std::move(copy);
 }
 
-void SubqueryRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*subquery);
-	writer.WriteList<string>(column_name_alias);
-}
-
-void SubqueryRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("subquery", subquery);
-	serializer.WriteProperty("column_name_alias", column_name_alias);
-}
-
-unique_ptr<TableRef> SubqueryRef::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto subquery = deserializer.ReadProperty<unique_ptr<SelectStatement>>("subquery");
-	auto result = make_uniq<SubqueryRef>(std::move(subquery));
-	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
-	return std::move(result);
-}
-
-unique_ptr<TableRef> SubqueryRef::Deserialize(FieldReader &reader) {
-	auto subquery = reader.ReadRequiredSerializable<SelectStatement>();
-	auto result = make_uniq<SubqueryRef>(std::move(subquery));
-	result->column_name_alias = reader.ReadRequiredList<string>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/table_function.cpp

@@ -1,8 +1,7 @@
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/common/vector.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -21,35 +20,6 @@ bool TableFunctionRef::Equals(const TableRef &other_p) const {
 	return function->Equals(*other.function);
 }
 
-void TableFunctionRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*function);
-	writer.WriteString(alias);
-	writer.WriteList<string>(column_name_alias);
-}
-
-void TableFunctionRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("function", function);
-	serializer.WriteProperty("alias", alias);
-	serializer.WriteProperty("column_name_alias", column_name_alias);
-}
-
-unique_ptr<TableRef> TableFunctionRef::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = make_uniq<TableFunctionRef>();
-	deserializer.ReadProperty("function", result->function);
-	deserializer.ReadProperty("alias", result->alias);
-	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
-	return std::move(result);
-}
-
-unique_ptr<TableRef> TableFunctionRef::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<TableFunctionRef>();
-	result->function = reader.ReadRequiredSerializable<ParsedExpression>();
-	result->alias = reader.ReadRequired<string>();
-	result->column_name_alias = reader.ReadRequiredList<string>();
-	return std::move(result);
-}
-
 unique_ptr<TableRef> TableFunctionRef::Copy() {
 	auto copy = make_uniq<TableFunctionRef>();
 

package/src/duckdb/src/parser/tableref.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/tableref.hpp"
 
 #include "duckdb/common/printer.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/tableref/list.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/common/to_string.hpp"
 
 namespace duckdb {
@@ -44,99 +43,6 @@ bool TableRef::Equals(const TableRef &other) const {
 	return type == other.type && alias == other.alias && SampleOptions::Equals(sample.get(), other.sample.get());
 }
 
-void TableRef::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<TableReferenceType>(type);
-	writer.WriteString(alias);
-	writer.WriteOptional(sample);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-void TableRef::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type);
-	serializer.WriteProperty("alias", alias);
-	serializer.WriteOptionalProperty("sample", sample);
-}
-
-unique_ptr<TableRef> TableRef::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<TableReferenceType>("type");
-	auto alias = deserializer.ReadProperty<string>("alias");
-	auto sample = deserializer.ReadOptionalProperty<unique_ptr<SampleOptions>>("sample");
-
-	unique_ptr<TableRef> result;
-
-	switch (type) {
-	case TableReferenceType::BASE_TABLE:
-		result = BaseTableRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::JOIN:
-		result = JoinRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::SUBQUERY:
-		result = SubqueryRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::TABLE_FUNCTION:
-		result = TableFunctionRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::EMPTY:
-		result = EmptyTableRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::EXPRESSION_LIST:
-		result = ExpressionListRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::PIVOT:
-		result = PivotRef::FormatDeserialize(deserializer);
-		break;
-	case TableReferenceType::CTE:
-	case TableReferenceType::INVALID:
-		throw InternalException("Unsupported type for TableRef::FormatDeserialize");
-	}
-	result->alias = alias;
-	result->sample = std::move(sample);
-	return result;
-}
-
-unique_ptr<TableRef> TableRef::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-
-	auto type = reader.ReadRequired<TableReferenceType>();
-	auto alias = reader.ReadRequired<string>();
-	auto sample = reader.ReadOptional<SampleOptions>(nullptr);
-	unique_ptr<TableRef> result;
-	switch (type) {
-	case TableReferenceType::BASE_TABLE:
-		result = BaseTableRef::Deserialize(reader);
-		break;
-	case TableReferenceType::JOIN:
-		result = JoinRef::Deserialize(reader);
-		break;
-	case TableReferenceType::SUBQUERY:
-		result = SubqueryRef::Deserialize(reader);
-		break;
-	case TableReferenceType::TABLE_FUNCTION:
-		result = TableFunctionRef::Deserialize(reader);
-		break;
-	case TableReferenceType::EMPTY:
-		result = EmptyTableRef::Deserialize(reader);
-		break;
-	case TableReferenceType::EXPRESSION_LIST:
-		result = ExpressionListRef::Deserialize(reader);
-		break;
-	case TableReferenceType::PIVOT:
-		result = PivotRef::Deserialize(reader);
-		break;
-	case TableReferenceType::CTE:
-	case TableReferenceType::INVALID:
-		throw InternalException("Unsupported type for TableRef::Deserialize");
-	}
-	reader.Finalize();
-
-	result->alias = alias;
-	result->sample = std::move(sample);
-	return result;
-}
-
 void TableRef::CopyProperties(TableRef &target) const {
 	D_ASSERT(type == target.type);
 	target.alias = alias;

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!");
 	}

package/src/duckdb/src/parser/transform/expression/transform_array_access.cpp

@@ -27,10 +27,19 @@ unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery
 			children.push_back(std::move(result));
 			if (index->is_slice) {
 				// slice
-				children.push_back(!index->lidx ? make_uniq<ConstantExpression>(Value())
-				                                : TransformExpression(index->lidx));
-				children.push_back(!index->uidx ? make_uniq<ConstantExpression>(Value())
-				                                : TransformExpression(index->uidx));
+				// if either the lower or upper bound is not specified, we use an empty const list so that we can
+				// handle it in the execution
+				unique_ptr<ParsedExpression> lower =
+				    index->lidx ? TransformExpression(index->lidx)
+				                : make_uniq<ConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
+				children.push_back(std::move(lower));
+				unique_ptr<ParsedExpression> upper =
+				    index->uidx ? TransformExpression(index->uidx)
+				                : make_uniq<ConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
+				children.push_back(std::move(upper));
+				if (index->step) {
+					children.push_back(TransformExpression(index->step));
+				}
 				result = make_uniq<OperatorExpression>(ExpressionType::ARRAY_SLICE, std::move(children));
 			} else {
 				// array access

package/src/duckdb/src/parser/transform/expression/transform_constant.cpp

@@ -1,8 +1,11 @@
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/limits.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/types/decimal.hpp"
+#include "duckdb/parser/expression/cast_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/parser/transformer.hpp"
 
 namespace duckdb {
 
@@ -76,4 +79,53 @@ unique_ptr<ParsedExpression> Transformer::TransformConstant(duckdb_libpgquery::P
 	return TransformValue(c.val);
 }
 
+bool Transformer::ConstructConstantFromExpression(const ParsedExpression &expr, Value &value) {
+	// We have to construct it like this because we don't have the ClientContext for binding/executing the expr here
+	switch (expr.type) {
+	case ExpressionType::FUNCTION: {
+		auto &function = expr.Cast<FunctionExpression>();
+		if (function.function_name == "struct_pack") {
+			unordered_set<string> unique_names;
+			child_list_t<Value> values;
+			values.reserve(function.children.size());
+			for (const auto &child : function.children) {
+				if (!unique_names.insert(child->alias).second) {
+					throw BinderException("Duplicate struct entry name \"%s\"", child->alias);
+				}
+				Value child_value;
+				if (!ConstructConstantFromExpression(*child, child_value)) {
+					return false;
+				}
+				values.emplace_back(child->alias, std::move(child_value));
+			}
+			value = Value::STRUCT(std::move(values));
+			return true;
+		} else {
+			return false;
+		}
+	}
+	case ExpressionType::VALUE_CONSTANT: {
+		auto &constant = expr.Cast<ConstantExpression>();
+		value = constant.value;
+		return true;
+	}
+	case ExpressionType::OPERATOR_CAST: {
+		auto &cast = expr.Cast<CastExpression>();
+		Value dummy_value;
+		if (!ConstructConstantFromExpression(*cast.child, dummy_value)) {
+			return false;
+		}
+
+		string error_message;
+		if (!dummy_value.DefaultTryCastAs(cast.cast_type, value, &error_message)) {
+			throw ConversionException("Unable to cast %s to %s", dummy_value.ToString(),
+			                          EnumUtil::ToString(cast.cast_type.id()));
+		}
+		return true;
+	}
+	default:
+		return false;
+	}
+}
+
 } // namespace duckdb