duckdb 0.10.3-dev0.0 → 0.10.3-dev6.0

package/src/duckdb/src/parser/statement/multi_statement.cpp

@@ -15,4 +15,12 @@ unique_ptr<SQLStatement> MultiStatement::Copy() const {
 	return unique_ptr<MultiStatement>(new MultiStatement(*this));
 }
 
+string MultiStatement::ToString() const {
+	vector<string> stringified;
+	for (auto &stmt : statements) {
+		stringified.push_back(stmt->ToString());
+	}
+	return StringUtil::Join(stringified, ";") + ";";
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/pragma_statement.cpp

@@ -12,4 +12,8 @@ unique_ptr<SQLStatement> PragmaStatement::Copy() const {
 	return unique_ptr<PragmaStatement>(new PragmaStatement(*this));
 }
 
+string PragmaStatement::ToString() const {
+	return info->ToString();
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/prepare_statement.cpp

@@ -13,4 +13,17 @@ unique_ptr<SQLStatement> PrepareStatement::Copy() const {
 	return unique_ptr<PrepareStatement>(new PrepareStatement(*this));
 }
 
+string PrepareStatement::ToString() const {
+	string result = "";
+	result += "PREPARE";
+	result += " ";
+	result += name;
+	result += " ";
+	result += "AS";
+	result += " ";
+	result += statement->ToString();
+	// NOTE: We expect SQLStatement->ToString() to always end in a ';' ^
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/relation_statement.cpp

@@ -10,4 +10,8 @@ unique_ptr<SQLStatement> RelationStatement::Copy() const {
 	return unique_ptr<RelationStatement>(new RelationStatement(*this));
 }
 
+string RelationStatement::ToString() const {
+	return relation->ToString();
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/set_statement.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/parser/statement/set_statement.hpp"
+#include "duckdb/common/enum_util.hpp"
 
 namespace duckdb {
 
@@ -6,10 +7,6 @@ SetStatement::SetStatement(std::string name_p, SetScope scope_p, SetType type_p)
     : SQLStatement(StatementType::SET_STATEMENT), name(std::move(name_p)), scope(scope_p), set_type(type_p) {
 }
 
-unique_ptr<SQLStatement> SetStatement::Copy() const {
-	return unique_ptr<SetStatement>(new SetStatement(*this));
-}
-
 // Set Variable
 
 SetVariableStatement::SetVariableStatement(std::string name_p, unique_ptr<ParsedExpression> value_p, SetScope scope_p)
@@ -24,10 +21,42 @@ unique_ptr<SQLStatement> SetVariableStatement::Copy() const {
 	return unique_ptr<SetVariableStatement>(new SetVariableStatement(*this));
 }
 
+static string ScopeToString(SetScope scope) {
+	switch (scope) {
+	case SetScope::AUTOMATIC:
+		return "";
+	case SetScope::LOCAL:
+		return "LOCAL";
+	case SetScope::SESSION:
+		return "SESSION";
+	case SetScope::GLOBAL:
+		return "GLOBAL";
+	default:
+		throw InternalException("ToString not implemented for SetScope of type: %s", EnumUtil::ToString(scope));
+	}
+}
+
+string SetVariableStatement::ToString() const {
+	return StringUtil::Format("SET %s %s TO %s;", ScopeToString(scope), name, value->ToString());
+}
+
 // Reset Variable
 
 ResetVariableStatement::ResetVariableStatement(std::string name_p, SetScope scope_p)
     : SetStatement(std::move(name_p), scope_p, SetType::RESET) {
 }
 
+unique_ptr<SQLStatement> ResetVariableStatement::Copy() const {
+	return unique_ptr<ResetVariableStatement>(new ResetVariableStatement(*this));
+}
+
+string ResetVariableStatement::ToString() const {
+	string result = "";
+	result += "RESET";
+	result += " " + ScopeToString(scope);
+	result += " " + name;
+	result += ";";
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/transaction_statement.cpp

@@ -14,4 +14,8 @@ unique_ptr<SQLStatement> TransactionStatement::Copy() const {
 	return unique_ptr<TransactionStatement>(new TransactionStatement(*this));
 }
 
+string TransactionStatement::ToString() const {
+	return info->ToString();
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/update_extensions_statement.cpp

@@ -0,0 +1,34 @@
+#include "duckdb/parser/statement/update_extensions_statement.hpp"
+
+namespace duckdb {
+
+UpdateExtensionsStatement::UpdateExtensionsStatement() : SQLStatement(StatementType::UPDATE_EXTENSIONS_STATEMENT) {
+}
+
+UpdateExtensionsStatement::UpdateExtensionsStatement(const UpdateExtensionsStatement &other)
+    : SQLStatement(other), info(other.info->Copy()) {
+}
+
+string UpdateExtensionsStatement::ToString() const {
+	string result;
+	result += "UPDATE EXTENSIONS";
+
+	if (!info->extensions_to_update.empty()) {
+		result += "(";
+		for (idx_t i = 0; i < info->extensions_to_update.size(); i++) {
+			if (i > 0) {
+				result += ", ";
+			}
+			result += info->extensions_to_update[i];
+		}
+		result += ")";
+	}
+
+	return result;
+}
+
+unique_ptr<SQLStatement> UpdateExtensionsStatement::Copy() const {
+	return unique_ptr<UpdateExtensionsStatement>(new UpdateExtensionsStatement(*this));
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/statement/vacuum_statement.cpp

@@ -13,4 +13,8 @@ unique_ptr<SQLStatement> VacuumStatement::Copy() const {
 	return unique_ptr<VacuumStatement>(new VacuumStatement(*this));
 }
 
+string VacuumStatement::ToString() const {
+	return info->ToString();
+}
+
 } // namespace duckdb

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

@@ -0,0 +1,81 @@
+#include "duckdb/parser/tableref/column_data_ref.hpp"
+#include "duckdb/common/string_util.hpp"
+
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
+
+namespace duckdb {
+
+string ColumnDataRef::ToString() const {
+	auto result = collection->ToString();
+	return BaseToString(result, expected_names);
+}
+
+bool ColumnDataRef::Equals(const TableRef &other_p) const {
+	if (!TableRef::Equals(other_p)) {
+		return false;
+	}
+	auto &other = other_p.Cast<ColumnDataRef>();
+	auto expected_types = collection->Types();
+	auto other_expected_types = other.collection->Types();
+	if (expected_types.size() != other_expected_types.size()) {
+		return false;
+	}
+	if (expected_names.size() != other.expected_names.size()) {
+		return false;
+	}
+	D_ASSERT(expected_types.size() == expected_names.size());
+	for (idx_t i = 0; i < expected_types.size(); i++) {
+		auto &this_type = expected_types[i];
+		auto &other_type = other_expected_types[i];
+
+		auto &this_name = expected_names[i];
+		auto &other_name = other.expected_names[i];
+
+		if (this_type != other_type) {
+			return false;
+		}
+		if (!StringUtil::CIEquals(this_name, other_name)) {
+			return false;
+		}
+	}
+	string unused;
+	if (!ColumnDataCollection::ResultEquals(*collection, *other.collection, unused, true)) {
+		return false;
+	}
+	return true;
+}
+
+unique_ptr<TableRef> ColumnDataRef::Copy() {
+	unique_ptr<ColumnDataRef> result;
+	if (collection.is_owned()) {
+		// This collection is owned, the copy should be self sufficient so it needs a copy
+		auto new_collection = make_uniq<ColumnDataCollection>(*collection);
+
+		DataChunk chunk;
+		collection->InitializeScanChunk(chunk);
+
+		ColumnDataScanState scan_state;
+		collection->InitializeScan(scan_state);
+
+		ColumnDataAppendState append_state;
+		new_collection->InitializeAppend(append_state);
+		while (collection->Scan(scan_state, chunk)) {
+			new_collection->Append(append_state, chunk);
+		}
+#ifdef DEBUG
+		string error_message;
+		if (!ColumnDataCollection::ResultEquals(*collection, *new_collection, error_message, true)) {
+			throw InternalException("Copied ColumnDataCollection was not equal: %s", error_message);
+		}
+#endif
+		result = make_uniq<ColumnDataRef>(expected_names, std::move(new_collection));
+	} else {
+		result = make_uniq<ColumnDataRef>(*collection);
+	}
+	result->expected_names = expected_names;
+	CopyProperties(*result);
+	return std::move(result);
+}
+
+} // namespace duckdb

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

@@ -48,6 +48,7 @@ void TableRef::CopyProperties(TableRef &target) const {
 	target.alias = alias;
 	target.query_location = query_location;
 	target.sample = sample ? sample->Copy() : nullptr;
+	target.external_dependency = external_dependency;
 }
 
 void TableRef::Print() {

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

@@ -20,9 +20,9 @@ static unique_ptr<ParsedExpression> TransformBooleanTestInternal(unique_ptr<Pars
 }
 
 static unique_ptr<ParsedExpression> TransformBooleanTestIsNull(unique_ptr<ParsedExpression> argument,
-                                                               ExpressionType operator_type, idx_t query_location) {
+                                                               ExpressionType operator_type, int query_location) {
 	auto result = make_uniq<OperatorExpression>(operator_type, std::move(argument));
-	Transformer::SetQueryLocation(*result, UnsafeNumericCast<int32_t>(query_location));
+	Transformer::SetQueryLocation(*result, query_location);
 	return std::move(result);
 }
 

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

@@ -18,7 +18,7 @@ unique_ptr<ParsedExpression> Transformer::TransformTypeCast(duckdb_libpgquery::P
 		if (c->val.type == duckdb_libpgquery::T_PGString) {
 			CastParameters parameters;
 			if (root.location >= 0) {
-				parameters.query_location = root.location;
+				parameters.query_location = NumericCast<idx_t>(root.location);
 			}
 			auto blob_data = Blob::ToBlob(string(c->val.val.str), parameters);
 			return make_uniq<ConstantExpression>(Value::BLOB_RAW(blob_data));

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

@@ -34,7 +34,7 @@ unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::P
 
 	int32_t mask = NumericCast<int32_t>(
 	    PGPointerCast<duckdb_libpgquery::PGAConst>(node.typmods->head->data.ptr_value)->val.val.ival);
-	// these seemingly random constants are from datetime.hpp
+	// these seemingly random constants are from libpg_query/include/utils/datetime.hpp
 	// they are copied here to avoid having to include this header
 	// the bitshift is from the function INTERVAL_MASK in the parser
 	constexpr int32_t MONTH_MASK = 1 << 1;
@@ -49,6 +49,7 @@ unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::P
 	constexpr int32_t DECADE_MASK = 1 << 25;
 	constexpr int32_t CENTURY_MASK = 1 << 26;
 	constexpr int32_t MILLENNIUM_MASK = 1 << 27;
+	constexpr int32_t QUARTER_MASK = 1 << 29;
 
 	// we need to check certain combinations
 	// because certain interval masks (e.g. INTERVAL '10' HOURS TO DAYS) set multiple bits
@@ -115,6 +116,10 @@ unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::P
 		// WEEK
 		fname = "to_weeks";
 		target_type = LogicalType::INTEGER;
+	} else if (mask & QUARTER_MASK) {
+		// QUARTER
+		fname = "to_quarters";
+		target_type = LogicalType::INTEGER;
 	} else if (mask & DECADE_MASK) {
 		// DECADE
 		fname = "to_decades";

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

@@ -40,7 +40,7 @@ unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::P
 		// We have not seen this parameter before
 		if (node.number != 0) {
 			// Preserve the parameter number
-			known_param_index = node.number;
+			known_param_index = NumericCast<idx_t>(node.number);
 		} else {
 			known_param_index = ParamCount() + 1;
 			if (!node.name) {

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

@@ -8,7 +8,7 @@ unique_ptr<ParsedExpression> Transformer::TransformPositionalReference(duckdb_li
 	if (node.position <= 0) {
 		throw ParserException("Positional reference node needs to be >= 1");
 	}
-	auto result = make_uniq<PositionalReferenceExpression>(node.position);
+	auto result = make_uniq<PositionalReferenceExpression>(NumericCast<idx_t>(node.position));
 	SetQueryLocation(*result, node.location);
 	return std::move(result);
 }

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

@@ -4,9 +4,23 @@
 #include "duckdb/parser/tableref/subqueryref.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/positional_reference_expression.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
 
 namespace duckdb {
 
+void RemoveOrderQualificationRecursive(unique_ptr<ParsedExpression> &expr) {
+	if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
+		auto &col_ref = expr->Cast<ColumnRefExpression>();
+		auto &col_names = col_ref.column_names;
+		if (col_names.size() > 1) {
+			col_names = vector<string> {col_names.back()};
+		}
+	} else {
+		ParsedExpressionIterator::EnumerateChildren(
+		    *expr, [](unique_ptr<ParsedExpression> &child) { RemoveOrderQualificationRecursive(child); });
+	}
+}
+
 unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::PGSubLink &root) {
 	auto subquery_expr = make_uniq<SubqueryExpression>();
 
@@ -90,6 +104,8 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 						idx_t positional_index = order_index < 0 ? NumericLimits<idx_t>::Maximum() : idx_t(order_index);
 						order.expression = make_uniq<PositionalReferenceExpression>(positional_index);
 					}
+				} else {
+					RemoveOrderQualificationRecursive(order.expression);
 				}
 			}
 		}

package/src/duckdb/src/parser/transform/helpers/nodetype_to_string.cpp

@@ -458,6 +458,8 @@ std::string Transformer::NodetypeToString(duckdb_libpgquery::PGNodeTag type) { /
 		return "T_DeleteStmt";
 	case duckdb_libpgquery::T_PGUpdateStmt:
 		return "T_UpdateStmt";
+	case duckdb_libpgquery::T_PGUpdateExtensionsStmt:
+		return "T_UpdateExtensionsStmt";
 	case duckdb_libpgquery::T_PGSelectStmt:
 		return "T_SelectStmt";
 	case duckdb_libpgquery::T_PGAlterTableStmt:

package/src/duckdb/src/parser/transform/helpers/transform_typename.cpp

@@ -5,9 +5,72 @@
 #include "duckdb/parser/transformer.hpp"
 #include "duckdb/common/types/decimal.hpp"
 #include "duckdb/common/types/vector.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
 
 namespace duckdb {
 
+struct SizeModifiers {
+	int64_t width = 0;
+	int64_t scale = 0;
+	// How many modifiers were found
+	idx_t count = 0;
+};
+
+static SizeModifiers GetSizeModifiers(duckdb_libpgquery::PGTypeName &type_name, LogicalTypeId base_type) {
+
+	SizeModifiers result;
+
+	if (base_type == LogicalTypeId::DECIMAL) {
+		// Defaults for DECIMAL
+		result.width = 18;
+		result.scale = 3;
+	}
+
+	if (type_name.typmods) {
+		for (auto node = type_name.typmods->head; node; node = node->next) {
+			auto &const_val = *Transformer::PGPointerCast<duckdb_libpgquery::PGAConst>(node->data.ptr_value);
+			if (const_val.type != duckdb_libpgquery::T_PGAConst ||
+			    const_val.val.type != duckdb_libpgquery::T_PGInteger) {
+				throw ParserException("Expected an integer constant as type modifier");
+			}
+			if (const_val.val.val.ival < 0) {
+				throw ParserException("Negative modifier not supported");
+			}
+			if (result.count == 0) {
+				result.width = const_val.val.val.ival;
+				if (base_type == LogicalTypeId::BIT && const_val.location != -1) {
+					result.width = 0;
+				}
+			} else if (result.count == 1) {
+				result.scale = const_val.val.val.ival;
+			} else {
+				throw ParserException("A maximum of two modifiers is supported");
+			}
+			result.count++;
+		}
+	}
+	return result;
+}
+
+vector<Value> Transformer::TransformTypeModifiers(duckdb_libpgquery::PGTypeName &type_name) {
+	vector<Value> type_mods;
+	if (type_name.typmods) {
+		for (auto node = type_name.typmods->head; node; node = node->next) {
+			if (type_mods.size() > 9) {
+				auto name = PGPointerCast<duckdb_libpgquery::PGValue>(type_name.names->tail->data.ptr_value)->val.str;
+				throw ParserException("'%s': a maximum of 9 type modifiers is allowed", name);
+			}
+			auto &const_val = *PGPointerCast<duckdb_libpgquery::PGAConst>(node->data.ptr_value);
+			if (const_val.type != duckdb_libpgquery::T_PGAConst) {
+				throw ParserException("Expected a constant as type modifier");
+			}
+			auto const_expr = TransformValue(const_val.val);
+			type_mods.push_back(std::move(const_expr->value));
+		}
+	}
+	return type_mods;
+}
+
 LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_name) {
 	if (type_name.type != duckdb_libpgquery::T_PGTypeName) {
 		throw ParserException("Expected a type");
@@ -20,11 +83,13 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 		for (auto cell = type_name.names->head; cell; cell = cell->next) {
 			names.push_back(PGPointerCast<duckdb_libpgquery::PGValue>(cell->data.ptr_value)->val.str);
 		}
+		vector<Value> type_mods = TransformTypeModifiers(type_name);
 		switch (type_name.names->length) {
 		case 2:
-			return LogicalType::USER(INVALID_CATALOG, std::move(names[0]), std::move(names[1]));
+			return LogicalType::USER(INVALID_CATALOG, std::move(names[0]), std::move(names[1]), std::move(type_mods));
 		case 3:
-			return LogicalType::USER(std::move(names[0]), std::move(names[1]), std::move(names[2]));
+			return LogicalType::USER(std::move(names[0]), std::move(names[1]), std::move(names[2]),
+			                         std::move(type_mods));
 		default:
 			throw ParserException(
 			    "Too many qualifications for type name - expected [catalog.schema.name] or [schema.name]");
@@ -41,7 +106,7 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 		if (!type_name.typmods || type_name.typmods->length == 0) {
 			throw ParserException("Enum needs a set of entries");
 		}
-		Vector enum_vector(LogicalType::VARCHAR, type_name.typmods->length);
+		Vector enum_vector(LogicalType::VARCHAR, NumericCast<idx_t>(type_name.typmods->length));
 		auto string_data = FlatVector::GetData<string_t>(enum_vector);
 		idx_t pos = 0;
 		for (auto node = type_name.typmods->head; node; node = node->next) {
@@ -52,7 +117,7 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 			}
 			string_data[pos++] = StringVector::AddString(enum_vector, constant_value->val.val.str);
 		}
-		return LogicalType::ENUM(enum_vector, type_name.typmods->length);
+		return LogicalType::ENUM(enum_vector, NumericCast<idx_t>(type_name.typmods->length));
 	} else if (base_type == LogicalTypeId::STRUCT) {
 		if (!type_name.typmods || type_name.typmods->length == 0) {
 			throw ParserException("Struct needs a name and entries");
@@ -131,97 +196,66 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 		}
 		D_ASSERT(!children.empty());
 		result_type = LogicalType::UNION(std::move(children));
+	} else if (base_type == LogicalTypeId::USER) {
+		string user_type_name {name};
+		vector<Value> type_mods = TransformTypeModifiers(type_name);
+		result_type = LogicalType::USER(user_type_name, type_mods);
 	} else {
-		idx_t width, scale;
-		if (base_type == LogicalTypeId::DECIMAL) {
-			// default decimal width/scale
-			width = 18;
-			scale = 3;
-		} else {
-			width = 0;
-			scale = 0;
-		}
-		// check any modifiers
-		int modifier_idx = 0;
-		if (type_name.typmods) {
-			for (auto node = type_name.typmods->head; node; node = node->next) {
-				auto &const_val = *PGPointerCast<duckdb_libpgquery::PGAConst>(node->data.ptr_value);
-				if (const_val.type != duckdb_libpgquery::T_PGAConst ||
-				    const_val.val.type != duckdb_libpgquery::T_PGInteger) {
-					throw ParserException("Expected an integer constant as type modifier");
-				}
-				if (const_val.val.val.ival < 0) {
-					throw ParserException("Negative modifier not supported");
-				}
-				if (modifier_idx == 0) {
-					width = const_val.val.val.ival;
-					if (base_type == LogicalTypeId::BIT && const_val.location != -1) {
-						width = 0;
-					}
-				} else if (modifier_idx == 1) {
-					scale = const_val.val.val.ival;
-				} else {
-					throw ParserException("A maximum of two modifiers is supported");
-				}
-				modifier_idx++;
-			}
-		}
+		SizeModifiers modifiers = GetSizeModifiers(type_name, base_type);
 		switch (base_type) {
 		case LogicalTypeId::VARCHAR:
-			if (modifier_idx > 1) {
+			if (modifiers.count > 1) {
 				throw ParserException("VARCHAR only supports a single modifier");
 			}
 			// FIXME: create CHECK constraint based on varchar width
-			width = 0;
+			modifiers.width = 0;
 			result_type = LogicalType::VARCHAR;
 			break;
 		case LogicalTypeId::DECIMAL:
-			if (modifier_idx == 1) {
+			if (modifiers.count > 2) {
+				throw ParserException("DECIMAL only supports a maximum of two modifiers");
+			}
+			if (modifiers.count == 1) {
 				// only width is provided: set scale to 0
-				scale = 0;
+				modifiers.scale = 0;
 			}
-			if (width <= 0 || width > Decimal::MAX_WIDTH_DECIMAL) {
+			if (modifiers.width <= 0 || modifiers.width > Decimal::MAX_WIDTH_DECIMAL) {
 				throw ParserException("Width must be between 1 and %d!", (int)Decimal::MAX_WIDTH_DECIMAL);
 			}
-			if (scale > width) {
+			if (modifiers.scale > modifiers.width) {
 				throw ParserException("Scale cannot be bigger than width");
 			}
-			result_type = LogicalType::DECIMAL(NumericCast<uint8_t>(width), NumericCast<uint8_t>(scale));
+			result_type =
+			    LogicalType::DECIMAL(NumericCast<uint8_t>(modifiers.width), NumericCast<uint8_t>(modifiers.scale));
 			break;
 		case LogicalTypeId::INTERVAL:
-			if (modifier_idx > 1) {
+			if (modifiers.count > 1) {
 				throw ParserException("INTERVAL only supports a single modifier");
 			}
-			width = 0;
+			modifiers.width = 0;
 			result_type = LogicalType::INTERVAL;
 			break;
-		case LogicalTypeId::USER: {
-			string user_type_name {name};
-			result_type = LogicalType::USER(user_type_name);
-			break;
-		}
-		case LogicalTypeId::BIT: {
-			if (!width && type_name.typmods) {
+		case LogicalTypeId::BIT:
+			if (!modifiers.width && type_name.typmods) {
 				throw ParserException("Type %s does not support any modifiers!", LogicalType(base_type).ToString());
 			}
 			result_type = LogicalType(base_type);
 			break;
-		}
 		case LogicalTypeId::TIMESTAMP:
-			if (modifier_idx == 0) {
+			if (modifiers.count == 0) {
 				result_type = LogicalType::TIMESTAMP;
 			} else {
-				if (modifier_idx > 1) {
+				if (modifiers.count > 1) {
 					throw ParserException("TIMESTAMP only supports a single modifier");
 				}
-				if (width > 10) {
+				if (modifiers.width > 10) {
 					throw ParserException("TIMESTAMP only supports until nano-second precision (9)");
 				}
-				if (width == 0) {
+				if (modifiers.width == 0) {
 					result_type = LogicalType::TIMESTAMP_S;
-				} else if (width <= 3) {
+				} else if (modifiers.width <= 3) {
 					result_type = LogicalType::TIMESTAMP_MS;
-				} else if (width <= 6) {
+				} else if (modifiers.width <= 6) {
 					result_type = LogicalType::TIMESTAMP;
 				} else {
 					result_type = LogicalType::TIMESTAMP_NS;
@@ -229,7 +263,7 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 			}
 			break;
 		default:
-			if (modifier_idx > 0) {
+			if (modifiers.count > 0) {
 				throw ParserException("Type %s does not support any modifiers!", LogicalType(base_type).ToString());
 			}
 			result_type = LogicalType(base_type);
@@ -255,7 +289,7 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 			} else if (array_size > static_cast<int64_t>(ArrayType::MAX_ARRAY_SIZE)) {
 				throw ParserException("Arrays must have a size of at most %d", ArrayType::MAX_ARRAY_SIZE);
 			} else {
-				result_type = LogicalType::ARRAY(result_type, array_size);
+				result_type = LogicalType::ARRAY(result_type, NumericCast<idx_t>(array_size));
 			}
 		}
 	}

package/src/duckdb/src/parser/transform/statement/transform_checkpoint.cpp

@@ -11,6 +11,8 @@ unique_ptr<SQLStatement> Transformer::TransformCheckpoint(duckdb_libpgquery::PGC
 	auto checkpoint_name = stmt.force ? "force_checkpoint" : "checkpoint";
 	auto result = make_uniq<CallStatement>();
 	auto function = make_uniq<FunctionExpression>(checkpoint_name, std::move(children));
+	function->catalog = SYSTEM_CATALOG;
+	function->schema = DEFAULT_SCHEMA;
 	if (stmt.name) {
 		function->children.push_back(make_uniq<ConstantExpression>(Value(stmt.name)));
 	}

package/src/duckdb/src/parser/transform/statement/transform_copy.cpp

@@ -117,7 +117,7 @@ unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGCopySt
 		info.schema = table.schema_name;
 		info.catalog = table.catalog_name;
 	} else {
-		result->select_statement = TransformSelectNode(*PGPointerCast<duckdb_libpgquery::PGSelectStmt>(stmt.query));
+		info.select_statement = TransformSelectNode(*PGPointerCast<duckdb_libpgquery::PGSelectStmt>(stmt.query));
 	}
 
 	// handle the different options of the COPY statement

package/src/duckdb/src/parser/transform/statement/transform_load.cpp

@@ -8,8 +8,10 @@ unique_ptr<LoadStatement> Transformer::TransformLoad(duckdb_libpgquery::PGLoadSt
 
 	auto load_stmt = make_uniq<LoadStatement>();
 	auto load_info = make_uniq<LoadInfo>();
-	load_info->filename = std::string(stmt.filename);
-	load_info->repository = std::string(stmt.repository);
+	load_info->filename = stmt.filename ? string(stmt.filename) : "";
+	load_info->repository = stmt.repository ? string(stmt.repository) : "";
+	load_info->repo_is_alias = stmt.repo_is_alias;
+	load_info->version = stmt.version ? string(stmt.version) : "";
 	switch (stmt.load_type) {
 	case duckdb_libpgquery::PG_LOAD_TYPE_LOAD:
 		load_info->load_type = LoadType::LOAD;