duckdb 0.9.3-dev0.0 → 0.9.3-dev3.0

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

@@ -22,6 +22,8 @@ unique_ptr<ConstantExpression> Transformer::TransformValue(duckdb_libpgquery::PG
 		bool try_cast_as_integer = true;
 		bool try_cast_as_decimal = true;
 		int decimal_position = -1;
+		int num_underscores = 0;
+		int num_integer_underscores = 0;
 		for (idx_t i = 0; i < str_val.GetSize(); i++) {
 			if (val.val.str[i] == '.') {
 				// decimal point: cast as either decimal or double
@@ -33,6 +35,12 @@ unique_ptr<ConstantExpression> Transformer::TransformValue(duckdb_libpgquery::PG
 				try_cast_as_integer = false;
 				try_cast_as_decimal = false;
 			}
+			if (val.val.str[i] == '_') {
+				num_underscores++;
+				if (decimal_position < 0) {
+					num_integer_underscores++;
+				}
+			}
 		}
 		if (try_cast_as_integer) {
 			int64_t bigint_value;
@@ -50,10 +58,10 @@ unique_ptr<ConstantExpression> Transformer::TransformValue(duckdb_libpgquery::PG
 		}
 		idx_t decimal_offset = val.val.str[0] == '-' ? 3 : 2;
 		if (try_cast_as_decimal && decimal_position >= 0 &&
-		    str_val.GetSize() < Decimal::MAX_WIDTH_DECIMAL + decimal_offset) {
+		    str_val.GetSize() - num_underscores < Decimal::MAX_WIDTH_DECIMAL + decimal_offset) {
 			// figure out the width/scale based on the decimal position
-			auto width = uint8_t(str_val.GetSize() - 1);
-			auto scale = uint8_t(width - decimal_position);
+			auto width = uint8_t(str_val.GetSize() - 1 - num_underscores);
+			auto scale = uint8_t(width - decimal_position + num_integer_underscores);
 			if (val.val.str[0] == '-') {
 				width--;
 			}
@@ -76,7 +84,9 @@ unique_ptr<ConstantExpression> Transformer::TransformValue(duckdb_libpgquery::PG
 }
 
 unique_ptr<ParsedExpression> Transformer::TransformConstant(duckdb_libpgquery::PGAConst &c) {
-	return TransformValue(c.val);
+	auto constant = TransformValue(c.val);
+	SetQueryLocation(*constant, c.location);
+	return std::move(constant);
 }
 
 bool Transformer::ConstructConstantFromExpression(const ParsedExpression &expr, Value &value) {
@@ -100,6 +110,26 @@ bool Transformer::ConstructConstantFromExpression(const ParsedExpression &expr,
 			}
 			value = Value::STRUCT(std::move(values));
 			return true;
+		} else if (function.function_name == "list_value") {
+			vector<Value> values;
+			values.reserve(function.children.size());
+			for (const auto &child : function.children) {
+				Value child_value;
+				if (!ConstructConstantFromExpression(*child, child_value)) {
+					return false;
+				}
+				values.emplace_back(std::move(child_value));
+			}
+
+			// figure out child type
+			LogicalType child_type(LogicalTypeId::SQLNULL);
+			for (auto &child_value : values) {
+				child_type = LogicalType::ForceMaxLogicalType(child_type, child_value.type());
+			}
+
+			// finally create the list
+			value = Value::LIST(child_type, values);
+			return true;
 		} else {
 			return false;
 		}

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

@@ -41,12 +41,15 @@ void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef &window_sp
 		    "Window frames starting with unbounded following or ending in unbounded preceding make no sense");
 	}
 
+	if (window_spec.frameOptions & FRAMEOPTION_GROUPS) {
+		throw ParserException("GROUPS mode for window functions is not implemented yet");
+	}
 	const bool rangeMode = (window_spec.frameOptions & FRAMEOPTION_RANGE) != 0;
 	if (window_spec.frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING) {
 		expr.start = WindowBoundary::UNBOUNDED_PRECEDING;
-	} else if (window_spec.frameOptions & FRAMEOPTION_START_VALUE_PRECEDING) {
+	} else if (window_spec.frameOptions & FRAMEOPTION_START_OFFSET_PRECEDING) {
 		expr.start = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS;
-	} else if (window_spec.frameOptions & FRAMEOPTION_START_VALUE_FOLLOWING) {
+	} else if (window_spec.frameOptions & FRAMEOPTION_START_OFFSET_FOLLOWING) {
 		expr.start = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS;
 	} else if (window_spec.frameOptions & FRAMEOPTION_START_CURRENT_ROW) {
 		expr.start = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS;
@@ -54,21 +57,31 @@ void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef &window_sp
 
 	if (window_spec.frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING) {
 		expr.end = WindowBoundary::UNBOUNDED_FOLLOWING;
-	} else if (window_spec.frameOptions & FRAMEOPTION_END_VALUE_PRECEDING) {
+	} else if (window_spec.frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING) {
 		expr.end = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS;
-	} else if (window_spec.frameOptions & FRAMEOPTION_END_VALUE_FOLLOWING) {
+	} else if (window_spec.frameOptions & FRAMEOPTION_END_OFFSET_FOLLOWING) {
 		expr.end = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS;
 	} else if (window_spec.frameOptions & FRAMEOPTION_END_CURRENT_ROW) {
 		expr.end = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS;
 	}
 
 	D_ASSERT(expr.start != WindowBoundary::INVALID && expr.end != WindowBoundary::INVALID);
-	if (((window_spec.frameOptions & (FRAMEOPTION_START_VALUE_PRECEDING | FRAMEOPTION_START_VALUE_FOLLOWING)) &&
+	if (((window_spec.frameOptions & (FRAMEOPTION_START_OFFSET_PRECEDING | FRAMEOPTION_START_OFFSET_FOLLOWING)) &&
 	     !expr.start_expr) ||
-	    ((window_spec.frameOptions & (FRAMEOPTION_END_VALUE_PRECEDING | FRAMEOPTION_END_VALUE_FOLLOWING)) &&
+	    ((window_spec.frameOptions & (FRAMEOPTION_END_OFFSET_PRECEDING | FRAMEOPTION_END_OFFSET_FOLLOWING)) &&
 	     !expr.end_expr)) {
 		throw InternalException("Failed to transform window boundary expression");
 	}
+
+	if (window_spec.frameOptions & FRAMEOPTION_EXCLUDE_CURRENT_ROW) {
+		expr.exclude_clause = WindowExcludeMode::CURRENT_ROW;
+	} else if (window_spec.frameOptions & FRAMEOPTION_EXCLUDE_GROUP) {
+		expr.exclude_clause = WindowExcludeMode::GROUP;
+	} else if (window_spec.frameOptions & FRAMEOPTION_EXCLUDE_TIES) {
+		expr.exclude_clause = WindowExcludeMode::TIES;
+	} else {
+		expr.exclude_clause = WindowExcludeMode::NO_OTHER;
+	}
 }
 
 bool Transformer::ExpressionIsEmptyStar(ParsedExpression &expr) {
@@ -135,8 +148,8 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			throw InternalException("Unknown/unsupported window function");
 		}
 
-		if (root.agg_distinct) {
-			throw ParserException("DISTINCT is not implemented for window functions!");
+		if (win_fun_type != ExpressionType::WINDOW_AGGREGATE && root.agg_distinct) {
+			throw ParserException("DISTINCT is not implemented for non-aggregate window functions!");
 		}
 
 		if (root.agg_order) {
@@ -156,6 +169,7 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 
 		auto expr = make_uniq<WindowExpression>(win_fun_type, std::move(catalog), std::move(schema), lowercase_name);
 		expr->ignore_nulls = root.agg_ignore_nulls;
+		expr->distinct = root.agg_distinct;
 
 		if (root.agg_filter) {
 			auto filter_expr = TransformExpression(root.agg_filter);
@@ -193,7 +207,7 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		}
 		auto window_spec = PGPointerCast<duckdb_libpgquery::PGWindowDef>(root.over);
 		if (window_spec->name) {
-			auto it = window_clauses.find(StringUtil::Lower(string(window_spec->name)));
+			auto it = window_clauses.find(string(window_spec->name));
 			if (it == window_clauses.end()) {
 				throw ParserException("window \"%s\" does not exist", window_spec->name);
 			}
@@ -203,7 +217,7 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		auto window_ref = window_spec;
 		auto window_name = window_ref->refname;
 		if (window_ref->refname) {
-			auto it = window_clauses.find(StringUtil::Lower(string(window_spec->refname)));
+			auto it = window_clauses.find(string(window_spec->refname));
 			if (it == window_clauses.end()) {
 				throw ParserException("window \"%s\" does not exist", window_spec->refname);
 			}
@@ -220,7 +234,7 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		}
 		TransformWindowFrame(*window_spec, *expr);
 		in_window_definition = false;
-		expr->query_location = root.location;
+		SetQueryLocation(*expr, root.location);
 		return std::move(expr);
 	}
 
@@ -322,7 +336,7 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 	auto function = make_uniq<FunctionExpression>(std::move(catalog), std::move(schema), lowercase_name.c_str(),
 	                                              std::move(children), std::move(filter_expr), std::move(order_bys),
 	                                              root.agg_distinct, false, root.export_state);
-	function->query_location = root.location;
+	SetQueryLocation(*function, root.location);
 
 	return std::move(function);
 }

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

@@ -9,7 +9,7 @@ unique_ptr<ParsedExpression> Transformer::TransformGroupingFunction(duckdb_libpg
 		auto n = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
 		op->children.push_back(TransformExpression(n));
 	}
-	op->query_location = grouping.location;
+	SetQueryLocation(*op, grouping.location);
 	return std::move(op);
 }
 

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

@@ -44,6 +44,10 @@ unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::P
 	constexpr int32_t SECOND_MASK = 1 << 12;
 	constexpr int32_t MILLISECOND_MASK = 1 << 13;
 	constexpr int32_t MICROSECOND_MASK = 1 << 14;
+	constexpr int32_t WEEK_MASK = 1 << 24;
+	constexpr int32_t DECADE_MASK = 1 << 25;
+	constexpr int32_t CENTURY_MASK = 1 << 26;
+	constexpr int32_t MILLENNIUM_MASK = 1 << 27;
 
 	// we need to check certain combinations
 	// because certain interval masks (e.g. INTERVAL '10' HOURS TO DAYS) set multiple bits
@@ -51,6 +55,7 @@ unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::P
 	// (we might add support if someone complains about it)
 
 	string fname;
+	LogicalType parse_type = LogicalType::DOUBLE;
 	LogicalType target_type;
 	if (mask & YEAR_MASK && mask & MONTH_MASK) {
 		// DAY TO HOUR
@@ -96,20 +101,44 @@ unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::P
 	} else if (mask & SECOND_MASK) {
 		// SECOND
 		fname = "to_seconds";
-		target_type = LogicalType::BIGINT;
+		target_type = LogicalType::DOUBLE;
 	} else if (mask & MILLISECOND_MASK) {
 		// MILLISECOND
 		fname = "to_milliseconds";
-		target_type = LogicalType::BIGINT;
+		target_type = LogicalType::DOUBLE;
 	} else if (mask & MICROSECOND_MASK) {
-		// SECOND
+		// MICROSECOND
 		fname = "to_microseconds";
 		target_type = LogicalType::BIGINT;
+	} else if (mask & WEEK_MASK) {
+		// WEEK
+		fname = "to_weeks";
+		target_type = LogicalType::INTEGER;
+	} else if (mask & DECADE_MASK) {
+		// DECADE
+		fname = "to_decades";
+		target_type = LogicalType::INTEGER;
+	} else if (mask & CENTURY_MASK) {
+		// CENTURY
+		fname = "to_centuries";
+		target_type = LogicalType::INTEGER;
+	} else if (mask & MILLENNIUM_MASK) {
+		// MILLENNIUM
+		fname = "to_millennia";
+		target_type = LogicalType::INTEGER;
 	} else {
 		throw InternalException("Unsupported interval post-fix");
 	}
-	// first push a cast to the target type
-	expr = make_uniq<CastExpression>(target_type, std::move(expr));
+	// first push a cast to the parse type
+	expr = make_uniq<CastExpression>(parse_type, std::move(expr));
+
+	// next, truncate it if the target type doesn't match the parse type
+	if (target_type != parse_type) {
+		vector<unique_ptr<ParsedExpression>> children;
+		children.push_back(std::move(expr));
+		expr = make_uniq<FunctionExpression>("trunc", std::move(children));
+		expr = make_uniq<CastExpression>(target_type, std::move(expr));
+	}
 	// now push the operation
 	vector<unique_ptr<ParsedExpression>> children;
 	children.push_back(std::move(expr));

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

@@ -13,7 +13,9 @@ unique_ptr<ParsedExpression> Transformer::TransformNullTest(duckdb_libpgquery::P
 	                               ? ExpressionType::OPERATOR_IS_NULL
 	                               : ExpressionType::OPERATOR_IS_NOT_NULL;
 
-	return unique_ptr<ParsedExpression>(new OperatorExpression(expr_type, std::move(arg)));
+	auto result = make_uniq<OperatorExpression>(expr_type, std::move(arg));
+	SetQueryLocation(*result, root.location);
+	return std::move(result);
 }
 
 } // namespace duckdb

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

@@ -12,7 +12,9 @@ unique_ptr<ParsedExpression> Transformer::TransformLambda(duckdb_libpgquery::PGL
 	auto rhs = TransformExpression(node.rhs);
 	D_ASSERT(lhs);
 	D_ASSERT(rhs);
-	return make_uniq<LambdaExpression>(std::move(lhs), std::move(rhs));
+	auto result = make_uniq<LambdaExpression>(std::move(lhs), std::move(rhs));
+	SetQueryLocation(*result, node.location);
+	return std::move(result);
 }
 
 } // namespace duckdb

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

@@ -15,13 +15,13 @@ unique_ptr<ParsedExpression> Transformer::TransformMultiAssignRef(duckdb_libpgqu
 			return TransformExpression(root.source);
 		}
 
+		int provided_values = func.args ? func.args->length : 0;
 		// Too many columns (ie. (x, y) = (1, 2, 3) )
-		if (root.ncolumns < func.args->length) {
+		if (root.ncolumns < provided_values || !func.args) {
 			throw ParserException(
 			    "Could not perform multiple assignment, target only expects %d values, %d were provided", root.ncolumns,
-			    func.args->length);
+			    provided_values);
 		}
-
 		// Get the expression corresponding with the current column
 		idx_t idx = 1;
 		auto list = func.args->head;

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

@@ -81,7 +81,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 		subquery_expr->subquery_type = SubqueryType::ANY;
 		subquery_expr->child = std::move(left_expr);
 		subquery_expr->comparison_type = OperatorToExpressionType(name);
-		subquery_expr->query_location = root.location;
+		SetQueryLocation(*subquery_expr, root.location);
 		if (subquery_expr->comparison_type == ExpressionType::INVALID) {
 			throw ParserException("Unsupported comparison \"%s\" for ANY/ALL subquery", name);
 		}
@@ -107,7 +107,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 			operator_type = ExpressionType::COMPARE_IN;
 		}
 		auto result = make_uniq<OperatorExpression>(operator_type, std::move(left_expr));
-		result->query_location = root.location;
+		SetQueryLocation(*result, root.location);
 		TransformExpressionList(*PGPointerCast<duckdb_libpgquery::PGList>(root.rexpr), result->children);
 		return std::move(result);
 	}
@@ -210,7 +210,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAExpr &root) {
 	auto result = TransformAExprInternal(root);
 	if (result) {
-		result->query_location = root.location;
+		SetQueryLocation(*result, root.location);
 	}
 	return result;
 }

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

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

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

@@ -9,8 +9,9 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 	auto subquery_expr = make_uniq<SubqueryExpression>();
 
 	subquery_expr->subquery = TransformSelect(root.subselect);
+	SetQueryLocation(*subquery_expr, root.location);
 	D_ASSERT(subquery_expr->subquery);
-	D_ASSERT(subquery_expr->subquery->node->GetSelectList().size() > 0);
+	D_ASSERT(!subquery_expr->subquery->node->GetSelectList().empty());
 
 	switch (root.subLinkType) {
 	case duckdb_libpgquery::PG_EXISTS_SUBLINK: {
@@ -55,19 +56,20 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 		break;
 	}
 	case duckdb_libpgquery::PG_ARRAY_SUBLINK: {
-		auto subquery_table_alias = "__subquery";
-		auto subquery_column_alias = "__arr_element";
-
 		// ARRAY expression
-		// wrap subquery into "SELECT CASE WHEN ARRAY_AGG(i) IS NULL THEN [] ELSE ARRAY_AGG(i) END FROM (...) tbl(i)"
+		// wrap subquery into
+		// "SELECT CASE WHEN ARRAY_AGG(COLUMNS(*)) IS NULL THEN [] ELSE ARRAY_AGG(COLUMNS(*)) END FROM (...) tbl"
 		auto select_node = make_uniq<SelectNode>();
 
-		// ARRAY_AGG(i)
+		// COLUMNS(*)
+		auto columns_star = make_uniq<StarExpression>();
+		columns_star->columns = true;
+
+		// ARRAY_AGG(COLUMNS(*))
 		vector<unique_ptr<ParsedExpression>> children;
-		children.push_back(
-		    make_uniq_base<ParsedExpression, ColumnRefExpression>(subquery_column_alias, subquery_table_alias));
+		children.push_back(std::move(columns_star));
 		auto aggr = make_uniq<FunctionExpression>("array_agg", std::move(children));
-		// ARRAY_AGG(i) IS NULL
+		// ARRAY_AGG(COLUMNS(*)) IS NULL
 		auto agg_is_null = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_IS_NULL, aggr->Copy());
 		// empty list
 		vector<unique_ptr<ParsedExpression>> list_children;
@@ -82,9 +84,8 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 
 		select_node->select_list.push_back(std::move(case_expr));
 
-		// FROM (...) tbl(i)
-		auto child_subquery = make_uniq<SubqueryRef>(std::move(subquery_expr->subquery), subquery_table_alias);
-		child_subquery->column_name_alias.emplace_back(subquery_column_alias);
+		// FROM (...) tbl
+		auto child_subquery = make_uniq<SubqueryRef>(std::move(subquery_expr->subquery));
 		select_node->from_table = std::move(child_subquery);
 
 		auto new_subquery = make_uniq<SelectStatement>();
@@ -97,7 +98,6 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 	default:
 		throw NotImplementedException("Subquery of type %d not implemented\n", (int)root.subLinkType);
 	}
-	subquery_expr->query_location = root.location;
 	return std::move(subquery_expr);
 }
 

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

@@ -478,6 +478,8 @@ std::string Transformer::NodetypeToString(duckdb_libpgquery::PGNodeTag type) { /
 		return "T_ClosePortalStmt";
 	case duckdb_libpgquery::T_PGClusterStmt:
 		return "T_ClusterStmt";
+	case duckdb_libpgquery::T_PGCommentOnStmt:
+		return "T_CommentOnStmt";
 	case duckdb_libpgquery::T_PGCopyStmt:
 		return "T_CopyStmt";
 	case duckdb_libpgquery::T_PGCreateStmt:

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

@@ -33,9 +33,9 @@ void Transformer::ExtractCTEsRecursive(CommonTableExpressionMap &cte_map) {
 
 void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, CommonTableExpressionMap &cte_map,
                                vector<unique_ptr<CTENode>> &materialized_ctes) {
-	// TODO: might need to update in case of future lawsuit
 	stored_cte_map.push_back(&cte_map);
 
+	// TODO: might need to update in case of future lawsuit
 	D_ASSERT(de_with_clause.ctes);
 	for (auto cte_ele = de_with_clause.ctes->head; cte_ele != nullptr; cte_ele = cte_ele->next) {
 		auto info = make_uniq<CommonTableExpressionInfo>();

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

@@ -14,6 +14,22 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 	}
 	auto stack_checker = StackCheck();
 
+	if (type_name.names->length > 1) {
+		// qualified typename
+		vector<string> names;
+		for (auto cell = type_name.names->head; cell; cell = cell->next) {
+			names.push_back(PGPointerCast<duckdb_libpgquery::PGValue>(cell->data.ptr_value)->val.str);
+		}
+		switch (type_name.names->length) {
+		case 2:
+			return LogicalType::USER(INVALID_CATALOG, std::move(names[0]), std::move(names[1]));
+		case 3:
+			return LogicalType::USER(std::move(names[0]), std::move(names[1]), std::move(names[2]));
+		default:
+			throw ParserException(
+			    "Too many qualifications for type name - expected [catalog.schema.name] or [schema.name]");
+		}
+	}
 	auto name = PGPointerCast<duckdb_libpgquery::PGValue>(type_name.names->tail->data.ptr_value)->val.str;
 	// transform it to the SQL type
 	LogicalTypeId base_type = TransformStringToLogicalTypeId(name);
@@ -224,8 +240,23 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 		// array bounds: turn the type into a list
 		idx_t extra_stack = 0;
 		for (auto cell = type_name.arrayBounds->head; cell != nullptr; cell = cell->next) {
-			result_type = LogicalType::LIST(result_type);
 			StackCheck(extra_stack++);
+			auto val = PGPointerCast<duckdb_libpgquery::PGValue>(cell->data.ptr_value);
+			if (val->type != duckdb_libpgquery::T_PGInteger) {
+				throw ParserException("Expected integer value as array bound");
+			}
+			auto array_size = val->val.ival;
+			if (array_size < 0) {
+				// -1 if bounds are empty
+				result_type = LogicalType::LIST(result_type);
+			} else if (array_size == 0) {
+				// Empty arrays are not supported
+				throw ParserException("Arrays must have a size of at least 1");
+			} 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);
+			}
 		}
 	}
 	return result_type;

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

@@ -95,7 +95,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGAlte
 		}
 		case duckdb_libpgquery::PG_AT_DropConstraint:
 		default:
-			throw NotImplementedException("ALTER TABLE option not supported yet!");
+			throw NotImplementedException("No support for that ALTER TABLE option yet!");
 		}
 	}
 

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

@@ -10,6 +10,7 @@ unique_ptr<AttachStatement> Transformer::TransformAttach(duckdb_libpgquery::PGAt
 	auto info = make_uniq<AttachInfo>();
 	info->name = stmt.name ? stmt.name : string();
 	info->path = stmt.path;
+	info->on_conflict = TransformOnConflict(stmt.onconflict);
 
 	if (stmt.options) {
 		duckdb_libpgquery::PGListCell *cell;

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

@@ -0,0 +1,108 @@
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/parsed_data/alter_info.hpp"
+#include "duckdb/parser/parsed_data/alter_table_info.hpp"
+#include "duckdb/parser/statement/alter_statement.hpp"
+#include "duckdb/parser/transformer.hpp"
+
+namespace duckdb {
+
+unique_ptr<AlterStatement> Transformer::TransformCommentOn(duckdb_libpgquery::PGCommentOnStmt &stmt) {
+	QualifiedName qualified_name;
+	string column_name;
+
+	if (stmt.object_type != duckdb_libpgquery::PG_OBJECT_COLUMN) {
+		qualified_name = TransformQualifiedName(*stmt.name);
+	} else {
+		auto transformed_expr = TransformExpression(stmt.column_expr);
+
+		if (transformed_expr->GetExpressionType() != ExpressionType::COLUMN_REF) {
+			throw ParserException("Unexpected expression found, expected column reference to comment on (e.g. "
+			                      "'schema.table.column'), found '%s'",
+			                      transformed_expr->ToString());
+		}
+
+		auto colref_expr = transformed_expr->Cast<ColumnRefExpression>();
+
+		if (colref_expr.column_names.size() > 4) {
+			throw ParserException("Invalid column reference: '%s', too many dots", colref_expr.ToString());
+		}
+		if (colref_expr.column_names.size() < 2) {
+			throw ParserException("Invalid column reference: '%s', please specify a table", colref_expr.ToString());
+		}
+
+		column_name = colref_expr.GetColumnName();
+		qualified_name.name = colref_expr.column_names.size() > 1 ? colref_expr.GetTableName() : "";
+
+		if (colref_expr.column_names.size() == 4) {
+			qualified_name.catalog = colref_expr.column_names[0];
+			qualified_name.schema = colref_expr.column_names[1];
+		} else if (colref_expr.column_names.size() == 3) {
+			qualified_name.schema = colref_expr.column_names[0];
+		}
+	}
+
+	auto res = make_uniq<AlterStatement>();
+	unique_ptr<AlterInfo> info;
+
+	auto expr = TransformExpression(stmt.value);
+	if (expr->expression_class != ExpressionClass::CONSTANT) {
+		throw NotImplementedException("Can only use constants as comments");
+	}
+	auto comment_value = expr->Cast<ConstantExpression>().value;
+
+	CatalogType type = CatalogType::INVALID;
+
+	// Regular CatalogTypes
+	switch (stmt.object_type) {
+	case duckdb_libpgquery::PG_OBJECT_TABLE:
+		type = CatalogType::TABLE_ENTRY;
+		break;
+	case duckdb_libpgquery::PG_OBJECT_INDEX:
+		type = CatalogType::INDEX_ENTRY;
+		break;
+	case duckdb_libpgquery::PG_OBJECT_VIEW:
+		type = CatalogType::VIEW_ENTRY;
+		break;
+	case duckdb_libpgquery::PG_OBJECT_FUNCTION:
+		type = CatalogType::MACRO_ENTRY;
+		break;
+	case duckdb_libpgquery::PG_OBJECT_TABLE_MACRO:
+		type = CatalogType::TABLE_MACRO_ENTRY;
+		break;
+	case duckdb_libpgquery::PG_OBJECT_SEQUENCE:
+		type = CatalogType::SEQUENCE_ENTRY;
+		break;
+	case duckdb_libpgquery::PG_OBJECT_TYPE:
+		type = CatalogType::TYPE_ENTRY;
+		break;
+	default:
+		break;
+	}
+
+	if (type != CatalogType::INVALID) {
+		info = make_uniq<SetCommentInfo>(type, qualified_name.catalog, qualified_name.schema, qualified_name.name,
+		                                 comment_value, OnEntryNotFound::THROW_EXCEPTION);
+	} else if (stmt.object_type == duckdb_libpgquery::PG_OBJECT_COLUMN) {
+		// Special case: Table Column
+		AlterEntryData alter_entry_data;
+		alter_entry_data.catalog = qualified_name.catalog;
+		alter_entry_data.schema = qualified_name.schema;
+		alter_entry_data.name = qualified_name.name;
+		alter_entry_data.if_not_found = OnEntryNotFound::THROW_EXCEPTION;
+
+		info = make_uniq<SetColumnCommentInfo>(alter_entry_data, column_name, comment_value);
+	} else if (stmt.object_type == duckdb_libpgquery::PG_OBJECT_DATABASE) {
+		throw NotImplementedException("Adding comments to databases is not implemented");
+	} else if (stmt.object_type == duckdb_libpgquery::PG_OBJECT_SCHEMA) {
+		throw NotImplementedException("Adding comments to schemas is not implemented");
+	}
+
+	if (info) {
+		res->info = std::move(info);
+		return res;
+	}
+
+	throw NotImplementedException("Can not comment on this type");
+}
+
+} // namespace duckdb