duckdb 0.8.1-dev26.0 → 0.8.1-dev276.0

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

@@ -32,10 +32,10 @@ static void TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumn
 	}
 }
 
-PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot *pivot) {
+PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot) {
 	PivotColumn col;
-	if (pivot->pivot_columns) {
-		TransformExpressionList(*pivot->pivot_columns, col.pivot_expressions);
+	if (pivot.pivot_columns) {
+		TransformExpressionList(*pivot.pivot_columns, col.pivot_expressions);
 		for (auto &expr : col.pivot_expressions) {
 			if (expr->IsScalar()) {
 				throw ParserException("Cannot pivot on constant value \"%s\"", expr->ToString());
@@ -44,14 +44,14 @@ PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot *pivot)
 				throw ParserException("Cannot pivot on subquery \"%s\"", expr->ToString());
 			}
 		}
-	} else if (pivot->unpivot_columns) {
-		col.unpivot_names = TransformStringList(pivot->unpivot_columns);
+	} else if (pivot.unpivot_columns) {
+		col.unpivot_names = TransformStringList(pivot.unpivot_columns);
 	} else {
 		throw InternalException("Either pivot_columns or unpivot_columns must be defined");
 	}
-	if (pivot->pivot_value) {
-		for (auto node = pivot->pivot_value->head; node != nullptr; node = node->next) {
-			auto n = (duckdb_libpgquery::PGNode *)node->data.ptr_value;
+	if (pivot.pivot_value) {
+		for (auto node = pivot.pivot_value->head; node != nullptr; node = node->next) {
+			auto n = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
 			auto expr = TransformExpression(n);
 			PivotColumnEntry entry;
 			entry.alias = expr->alias;
@@ -59,36 +59,39 @@ PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot *pivot)
 			col.entries.push_back(std::move(entry));
 		}
 	}
-	if (pivot->subquery) {
-		col.subquery = TransformSelectNode(reinterpret_cast<duckdb_libpgquery::PGSelectStmt *>(pivot->subquery));
+	if (pivot.subquery) {
+		col.subquery = TransformSelectNode(*PGPointerCast<duckdb_libpgquery::PGSelectStmt>(pivot.subquery));
 	}
-	if (pivot->pivot_enum) {
-		col.pivot_enum = pivot->pivot_enum;
+	if (pivot.pivot_enum) {
+		col.pivot_enum = pivot.pivot_enum;
 	}
 	return col;
 }
 
-vector<PivotColumn> Transformer::TransformPivotList(duckdb_libpgquery::PGList *list) {
+vector<PivotColumn> Transformer::TransformPivotList(duckdb_libpgquery::PGList &list) {
 	vector<PivotColumn> result;
-	for (auto node = list->head; node != nullptr; node = node->next) {
-		auto pivot = (duckdb_libpgquery::PGPivot *)node->data.ptr_value;
-		result.push_back(TransformPivotColumn(pivot));
+	for (auto node = list.head; node != nullptr; node = node->next) {
+		auto pivot = PGPointerCast<duckdb_libpgquery::PGPivot>(node->data.ptr_value);
+		result.push_back(TransformPivotColumn(*pivot));
 	}
 	return result;
 }
 
-unique_ptr<TableRef> Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr *root) {
+unique_ptr<TableRef> Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr &root) {
 	auto result = make_uniq<PivotRef>();
-	result->source = TransformTableRefNode(root->source);
-	if (root->aggrs) {
-		TransformExpressionList(*root->aggrs, result->aggregates);
+	result->source = TransformTableRefNode(*root.source);
+	if (root.aggrs) {
+		TransformExpressionList(*root.aggrs, result->aggregates);
 	}
-	if (root->unpivots) {
-		result->unpivot_names = TransformStringList(root->unpivots);
+	if (root.unpivots) {
+		result->unpivot_names = TransformStringList(root.unpivots);
 	}
-	result->pivots = TransformPivotList(root->pivots);
-	if (root->groups) {
-		result->groups = TransformStringList(root->groups);
+	result->pivots = TransformPivotList(*root.pivots);
+	if (!result->unpivot_names.empty() && result->pivots.size() > 1) {
+		throw ParserException("UNPIVOT requires a single pivot element");
+	}
+	if (root.groups) {
+		result->groups = TransformStringList(root.groups);
 	}
 	for (auto &pivot : result->pivots) {
 		idx_t expected_size;
@@ -116,8 +119,8 @@ unique_ptr<TableRef> Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr
 			}
 		}
 	}
-	result->include_nulls = root->include_nulls;
-	result->alias = TransformAlias(root->alias, result->column_name_alias);
+	result->include_nulls = root.include_nulls;
+	result->alias = TransformAlias(root.alias, result->column_name_alias);
 	return std::move(result);
 }
 

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

@@ -3,16 +3,16 @@
 
 namespace duckdb {
 
-unique_ptr<TableRef> Transformer::TransformRangeSubselect(duckdb_libpgquery::PGRangeSubselect *root) {
+unique_ptr<TableRef> Transformer::TransformRangeSubselect(duckdb_libpgquery::PGRangeSubselect &root) {
 	Transformer subquery_transformer(*this);
-	auto subquery = subquery_transformer.TransformSelect(root->subquery);
+	auto subquery = subquery_transformer.TransformSelect(root.subquery);
 	if (!subquery) {
 		return nullptr;
 	}
 	auto result = make_uniq<SubqueryRef>(std::move(subquery));
-	result->alias = TransformAlias(root->alias, result->column_name_alias);
-	if (root->sample) {
-		result->sample = TransformSampleOptions(root->sample);
+	result->alias = TransformAlias(root.alias, result->column_name_alias);
+	if (root.sample) {
+		result->sample = TransformSampleOptions(root.sample);
 	}
 	return std::move(result);
 }

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

@@ -4,19 +4,19 @@
 
 namespace duckdb {
 
-unique_ptr<TableRef> Transformer::TransformRangeFunction(duckdb_libpgquery::PGRangeFunction *root) {
-	if (root->ordinality) {
+unique_ptr<TableRef> Transformer::TransformRangeFunction(duckdb_libpgquery::PGRangeFunction &root) {
+	if (root.ordinality) {
 		throw NotImplementedException("WITH ORDINALITY not implemented");
 	}
-	if (root->is_rowsfrom) {
+	if (root.is_rowsfrom) {
 		throw NotImplementedException("ROWS FROM() not implemented");
 	}
-	if (root->functions->length != 1) {
+	if (root.functions->length != 1) {
 		throw NotImplementedException("Need exactly one function");
 	}
-	auto function_sublist = (duckdb_libpgquery::PGList *)root->functions->head->data.ptr_value;
+	auto function_sublist = PGPointerCast<duckdb_libpgquery::PGList>(root.functions->head->data.ptr_value);
 	D_ASSERT(function_sublist->length == 2);
-	auto call_tree = (duckdb_libpgquery::PGNode *)function_sublist->head->data.ptr_value;
+	auto call_tree = PGPointerCast<duckdb_libpgquery::PGNode>(function_sublist->head->data.ptr_value);
 	auto coldef = function_sublist->head->next->data.ptr_value;
 
 	if (coldef) {
@@ -26,20 +26,21 @@ unique_ptr<TableRef> Transformer::TransformRangeFunction(duckdb_libpgquery::PGRa
 	auto result = make_uniq<TableFunctionRef>();
 	switch (call_tree->type) {
 	case duckdb_libpgquery::T_PGFuncCall: {
-		auto func_call = (duckdb_libpgquery::PGFuncCall *)call_tree;
-		result->function = TransformFuncCall(func_call);
+		auto func_call = PGPointerCast<duckdb_libpgquery::PGFuncCall>(call_tree.get());
+		result->function = TransformFuncCall(*func_call);
 		result->query_location = func_call->location;
 		break;
 	}
 	case duckdb_libpgquery::T_PGSQLValueFunction:
-		result->function = TransformSQLValueFunction((duckdb_libpgquery::PGSQLValueFunction *)call_tree);
+		result->function =
+		    TransformSQLValueFunction(*PGPointerCast<duckdb_libpgquery::PGSQLValueFunction>(call_tree.get()));
 		break;
 	default:
 		throw ParserException("Not a function call or value function");
 	}
-	result->alias = TransformAlias(root->alias, result->column_name_alias);
-	if (root->sample) {
-		result->sample = TransformSampleOptions(root->sample);
+	result->alias = TransformAlias(root.alias, result->column_name_alias);
+	if (root.sample) {
+		result->sample = TransformSampleOptions(root.sample);
 	}
 	return std::move(result);
 }

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

@@ -4,22 +4,22 @@
 
 namespace duckdb {
 
-unique_ptr<TableRef> Transformer::TransformTableRefNode(duckdb_libpgquery::PGNode *n) {
+unique_ptr<TableRef> Transformer::TransformTableRefNode(duckdb_libpgquery::PGNode &n) {
 	auto stack_checker = StackCheck();
 
-	switch (n->type) {
+	switch (n.type) {
 	case duckdb_libpgquery::T_PGRangeVar:
-		return TransformRangeVar(reinterpret_cast<duckdb_libpgquery::PGRangeVar *>(n));
+		return TransformRangeVar(PGCast<duckdb_libpgquery::PGRangeVar>(n));
 	case duckdb_libpgquery::T_PGJoinExpr:
-		return TransformJoin(reinterpret_cast<duckdb_libpgquery::PGJoinExpr *>(n));
+		return TransformJoin(PGCast<duckdb_libpgquery::PGJoinExpr>(n));
 	case duckdb_libpgquery::T_PGRangeSubselect:
-		return TransformRangeSubselect(reinterpret_cast<duckdb_libpgquery::PGRangeSubselect *>(n));
+		return TransformRangeSubselect(PGCast<duckdb_libpgquery::PGRangeSubselect>(n));
 	case duckdb_libpgquery::T_PGRangeFunction:
-		return TransformRangeFunction(reinterpret_cast<duckdb_libpgquery::PGRangeFunction *>(n));
+		return TransformRangeFunction(PGCast<duckdb_libpgquery::PGRangeFunction>(n));
 	case duckdb_libpgquery::T_PGPivotExpr:
-		return TransformPivot(reinterpret_cast<duckdb_libpgquery::PGPivotExpr *>(n));
+		return TransformPivot(PGCast<duckdb_libpgquery::PGPivotExpr>(n));
 	default:
-		throw NotImplementedException("From Type %d not supported", n->type);
+		throw NotImplementedException("From Type %d not supported", n.type);
 	}
 }
 

package/src/duckdb/src/parser/transformer.cpp

@@ -42,8 +42,8 @@ bool Transformer::TransformParseTree(duckdb_libpgquery::PGList *tree, vector<uni
 	InitializeStackCheck();
 	for (auto entry = tree->head; entry != nullptr; entry = entry->next) {
 		Clear();
-		auto n = (duckdb_libpgquery::PGNode *)entry->data.ptr_value;
-		auto stmt = TransformStatement(n);
+		auto n = PGPointerCast<duckdb_libpgquery::PGNode>(entry->data.ptr_value);
+		auto stmt = TransformStatement(*n);
 		D_ASSERT(stmt);
 		if (HasPivotEntries()) {
 			stmt = CreatePivotStatement(std::move(stmt));
@@ -69,7 +69,7 @@ StackChecker Transformer::StackCheck(idx_t extra_stack) {
 	return StackChecker(root, extra_stack);
 }
 
-unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode *stmt) {
+unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode &stmt) {
 	auto result = TransformStatementInternal(stmt);
 	result->n_param = ParamCount();
 	if (!named_param_map.empty()) {
@@ -123,91 +123,91 @@ bool Transformer::HasNamedParameters() const {
 	return !root.named_param_map.empty();
 }
 
-unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgquery::PGNode *stmt) {
-	switch (stmt->type) {
+unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgquery::PGNode &stmt) {
+	switch (stmt.type) {
 	case duckdb_libpgquery::T_PGRawStmt: {
-		auto raw_stmt = (duckdb_libpgquery::PGRawStmt *)stmt;
-		auto result = TransformStatement(raw_stmt->stmt);
+		auto &raw_stmt = PGCast<duckdb_libpgquery::PGRawStmt>(stmt);
+		auto result = TransformStatement(*raw_stmt.stmt);
 		if (result) {
-			result->stmt_location = raw_stmt->stmt_location;
-			result->stmt_length = raw_stmt->stmt_len;
+			result->stmt_location = raw_stmt.stmt_location;
+			result->stmt_length = raw_stmt.stmt_len;
 		}
 		return result;
 	}
 	case duckdb_libpgquery::T_PGSelectStmt:
-		return TransformSelect(stmt);
+		return TransformSelect(PGCast<duckdb_libpgquery::PGSelectStmt>(stmt));
 	case duckdb_libpgquery::T_PGCreateStmt:
-		return TransformCreateTable(stmt);
+		return TransformCreateTable(PGCast<duckdb_libpgquery::PGCreateStmt>(stmt));
 	case duckdb_libpgquery::T_PGCreateSchemaStmt:
-		return TransformCreateSchema(stmt);
+		return TransformCreateSchema(PGCast<duckdb_libpgquery::PGCreateSchemaStmt>(stmt));
 	case duckdb_libpgquery::T_PGViewStmt:
-		return TransformCreateView(stmt);
+		return TransformCreateView(PGCast<duckdb_libpgquery::PGViewStmt>(stmt));
 	case duckdb_libpgquery::T_PGCreateSeqStmt:
-		return TransformCreateSequence(stmt);
+		return TransformCreateSequence(PGCast<duckdb_libpgquery::PGCreateSeqStmt>(stmt));
 	case duckdb_libpgquery::T_PGCreateFunctionStmt:
-		return TransformCreateFunction(stmt);
+		return TransformCreateFunction(PGCast<duckdb_libpgquery::PGCreateFunctionStmt>(stmt));
 	case duckdb_libpgquery::T_PGDropStmt:
-		return TransformDrop(stmt);
+		return TransformDrop(PGCast<duckdb_libpgquery::PGDropStmt>(stmt));
 	case duckdb_libpgquery::T_PGInsertStmt:
-		return TransformInsert(stmt);
+		return TransformInsert(PGCast<duckdb_libpgquery::PGInsertStmt>(stmt));
 	case duckdb_libpgquery::T_PGCopyStmt:
-		return TransformCopy(stmt);
+		return TransformCopy(PGCast<duckdb_libpgquery::PGCopyStmt>(stmt));
 	case duckdb_libpgquery::T_PGTransactionStmt:
-		return TransformTransaction(stmt);
+		return TransformTransaction(PGCast<duckdb_libpgquery::PGTransactionStmt>(stmt));
 	case duckdb_libpgquery::T_PGDeleteStmt:
-		return TransformDelete(stmt);
+		return TransformDelete(PGCast<duckdb_libpgquery::PGDeleteStmt>(stmt));
 	case duckdb_libpgquery::T_PGUpdateStmt:
-		return TransformUpdate(stmt);
+		return TransformUpdate(PGCast<duckdb_libpgquery::PGUpdateStmt>(stmt));
 	case duckdb_libpgquery::T_PGIndexStmt:
-		return TransformCreateIndex(stmt);
+		return TransformCreateIndex(PGCast<duckdb_libpgquery::PGIndexStmt>(stmt));
 	case duckdb_libpgquery::T_PGAlterTableStmt:
-		return TransformAlter(stmt);
+		return TransformAlter(PGCast<duckdb_libpgquery::PGAlterTableStmt>(stmt));
 	case duckdb_libpgquery::T_PGRenameStmt:
-		return TransformRename(stmt);
+		return TransformRename(PGCast<duckdb_libpgquery::PGRenameStmt>(stmt));
 	case duckdb_libpgquery::T_PGPrepareStmt:
-		return TransformPrepare(stmt);
+		return TransformPrepare(PGCast<duckdb_libpgquery::PGPrepareStmt>(stmt));
 	case duckdb_libpgquery::T_PGExecuteStmt:
-		return TransformExecute(stmt);
+		return TransformExecute(PGCast<duckdb_libpgquery::PGExecuteStmt>(stmt));
 	case duckdb_libpgquery::T_PGDeallocateStmt:
-		return TransformDeallocate(stmt);
+		return TransformDeallocate(PGCast<duckdb_libpgquery::PGDeallocateStmt>(stmt));
 	case duckdb_libpgquery::T_PGCreateTableAsStmt:
-		return TransformCreateTableAs(stmt);
+		return TransformCreateTableAs(PGCast<duckdb_libpgquery::PGCreateTableAsStmt>(stmt));
 	case duckdb_libpgquery::T_PGPragmaStmt:
-		return TransformPragma(stmt);
+		return TransformPragma(PGCast<duckdb_libpgquery::PGPragmaStmt>(stmt));
 	case duckdb_libpgquery::T_PGExportStmt:
-		return TransformExport(stmt);
+		return TransformExport(PGCast<duckdb_libpgquery::PGExportStmt>(stmt));
 	case duckdb_libpgquery::T_PGImportStmt:
-		return TransformImport(stmt);
+		return TransformImport(PGCast<duckdb_libpgquery::PGImportStmt>(stmt));
 	case duckdb_libpgquery::T_PGExplainStmt:
-		return TransformExplain(stmt);
+		return TransformExplain(PGCast<duckdb_libpgquery::PGExplainStmt>(stmt));
 	case duckdb_libpgquery::T_PGVacuumStmt:
-		return TransformVacuum(stmt);
+		return TransformVacuum(PGCast<duckdb_libpgquery::PGVacuumStmt>(stmt));
 	case duckdb_libpgquery::T_PGVariableShowStmt:
-		return TransformShow(stmt);
+		return TransformShow(PGCast<duckdb_libpgquery::PGVariableShowStmt>(stmt));
 	case duckdb_libpgquery::T_PGVariableShowSelectStmt:
-		return TransformShowSelect(stmt);
+		return TransformShowSelect(PGCast<duckdb_libpgquery::PGVariableShowSelectStmt>(stmt));
 	case duckdb_libpgquery::T_PGCallStmt:
-		return TransformCall(stmt);
+		return TransformCall(PGCast<duckdb_libpgquery::PGCallStmt>(stmt));
 	case duckdb_libpgquery::T_PGVariableSetStmt:
-		return TransformSet(stmt);
+		return TransformSet(PGCast<duckdb_libpgquery::PGVariableSetStmt>(stmt));
 	case duckdb_libpgquery::T_PGCheckPointStmt:
-		return TransformCheckpoint(stmt);
+		return TransformCheckpoint(PGCast<duckdb_libpgquery::PGCheckPointStmt>(stmt));
 	case duckdb_libpgquery::T_PGLoadStmt:
-		return TransformLoad(stmt);
+		return TransformLoad(PGCast<duckdb_libpgquery::PGLoadStmt>(stmt));
 	case duckdb_libpgquery::T_PGCreateTypeStmt:
-		return TransformCreateType(stmt);
+		return TransformCreateType(PGCast<duckdb_libpgquery::PGCreateTypeStmt>(stmt));
 	case duckdb_libpgquery::T_PGAlterSeqStmt:
-		return TransformAlterSequence(stmt);
+		return TransformAlterSequence(PGCast<duckdb_libpgquery::PGAlterSeqStmt>(stmt));
 	case duckdb_libpgquery::T_PGAttachStmt:
-		return TransformAttach(stmt);
+		return TransformAttach(PGCast<duckdb_libpgquery::PGAttachStmt>(stmt));
 	case duckdb_libpgquery::T_PGDetachStmt:
-		return TransformDetach(stmt);
+		return TransformDetach(PGCast<duckdb_libpgquery::PGDetachStmt>(stmt));
 	case duckdb_libpgquery::T_PGUseStmt:
-		return TransformUse(stmt);
+		return TransformUse(PGCast<duckdb_libpgquery::PGUseStmt>(stmt));
 	case duckdb_libpgquery::T_PGCreateDatabaseStmt:
-		return TransformCreateDatabase(stmt);
+		return TransformCreateDatabase(PGCast<duckdb_libpgquery::PGCreateDatabaseStmt>(stmt));
 	default:
-		throw NotImplementedException(NodetypeToString(stmt->type));
+		throw NotImplementedException(NodetypeToString(stmt.type));
 	}
 }
 

package/src/duckdb/src/planner/bind_context.cpp

@@ -12,6 +12,7 @@
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/planner/bound_query_node.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/planner/expression_binder/constant_binder.hpp"
 
@@ -161,7 +162,7 @@ unique_ptr<ParsedExpression> BindContext::ExpandGeneratedColumn(const string &ta
 
 	auto binding = GetBinding(table_name, error_message);
 	D_ASSERT(binding);
-	auto &table_binding = (TableBinding &)*binding;
+	auto &table_binding = binding->Cast<TableBinding>();
 	auto result = table_binding.ExpandGeneratedColumn(column_name);
 	result->alias = column_name;
 	return result;
@@ -176,7 +177,7 @@ static bool ColumnIsGenerated(Binding &binding, column_t index) {
 	if (binding.binding_type != BindingType::TABLE) {
 		return false;
 	}
-	auto &table_binding = (TableBinding &)binding;
+	auto &table_binding = binding.Cast<TableBinding>();
 	auto catalog_entry = table_binding.GetStandardEntry();
 	if (!catalog_entry) {
 		return false;
@@ -285,15 +286,14 @@ string BindContext::BindColumn(PositionalReferenceExpression &ref, string &table
 	return StringUtil::Format("Positional reference %d out of range (total %d columns)", ref.index, total_columns);
 }
 
-BindResult BindContext::BindColumn(PositionalReferenceExpression &ref, idx_t depth) {
+unique_ptr<ColumnRefExpression> BindContext::PositionToColumn(PositionalReferenceExpression &ref) {
 	string table_name, column_name;
 
 	string error = BindColumn(ref, table_name, column_name);
 	if (!error.empty()) {
-		return BindResult(error);
+		throw BinderException(error);
 	}
-	auto column_ref = make_uniq<ColumnRefExpression>(column_name, table_name);
-	return BindColumn(*column_ref, depth);
+	return make_uniq<ColumnRefExpression>(column_name, table_name);
 }
 
 bool BindContext::CheckExclusionList(StarExpression &expr, const string &column_name,
@@ -483,15 +483,14 @@ void BindContext::AddSubquery(idx_t index, const string &alias, SubqueryRef &ref
 }
 
 void BindContext::AddEntryBinding(idx_t index, const string &alias, const vector<string> &names,
-                                  const vector<LogicalType> &types, StandardEntry *entry) {
-	D_ASSERT(entry);
-	AddBinding(alias, make_uniq<EntryBinding>(alias, types, names, index, *entry));
+                                  const vector<LogicalType> &types, StandardEntry &entry) {
+	AddBinding(alias, make_uniq<EntryBinding>(alias, types, names, index, entry));
 }
 
 void BindContext::AddView(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery,
                           ViewCatalogEntry *view) {
 	auto names = AliasColumnNames(alias, subquery.names, ref.column_name_alias);
-	AddEntryBinding(index, alias, names, subquery.types, (StandardEntry *)view);
+	AddEntryBinding(index, alias, names, subquery.types, view->Cast<StandardEntry>());
 }
 
 void BindContext::AddSubquery(idx_t index, const string &alias, TableFunctionRef &ref, BoundQueryNode &subquery) {

package/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp

@@ -189,7 +189,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 	}
 
 	// capture the (lambda) columns
-	auto &bound_lambda_expr = (BoundLambdaExpression &)*children.back();
+	auto &bound_lambda_expr = children.back()->Cast<BoundLambdaExpression>();
 	CaptureLambdaColumns(bound_lambda_expr.captures, list_child_type, bound_lambda_expr.lambda_expr);
 
 	FunctionBinder function_binder(context);

package/src/duckdb/src/planner/binder/expression/bind_lambda.cpp

@@ -110,7 +110,7 @@ void ExpressionBinder::TransformCapturedLambdaColumn(unique_ptr<Expression> &ori
 	if (original->expression_class == ExpressionClass::BOUND_LAMBDA_REF) {
 
 		// determine if this is the lambda parameter
-		auto &bound_lambda_ref = (BoundLambdaRefExpression &)*original;
+		auto &bound_lambda_ref = original->Cast<BoundLambdaRefExpression>();
 		auto alias = bound_lambda_ref.alias;
 
 		if (lambda_bindings && bound_lambda_ref.lambda_index != lambda_bindings->size()) {

package/src/duckdb/src/planner/binder/expression/bind_positional_reference_expression.cpp

@@ -4,11 +4,16 @@
 
 namespace duckdb {
 
-BindResult ExpressionBinder::BindExpression(PositionalReferenceExpression &ref, idx_t depth) {
+BindResult ExpressionBinder::BindPositionalReference(unique_ptr<ParsedExpression> &expr, idx_t depth,
+                                                     bool root_expression) {
+	auto &ref = expr->Cast<PositionalReferenceExpression>();
 	if (depth != 0) {
-		return BindResult("Positional reference expression could not be bound");
+		throw InternalException("Positional reference expression could not be bound");
 	}
-	return binder.bind_context.BindColumn(ref, depth);
+	// replace the positional reference with a column
+	auto column = binder.bind_context.PositionToColumn(ref);
+	expr = std::move(column);
+	return BindExpression(expr, depth, root_expression);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/binder/expression/bind_star_expression.cpp

@@ -55,7 +55,7 @@ bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpressi
 		in_columns = true;
 		if (*star) {
 			// we can have multiple
-			if (!StarExpression::Equal(*star, &current_star)) {
+			if (!(*star)->Equals(current_star)) {
 				throw BinderException(
 				    FormatError(*expr, "Multiple different STAR/COLUMNS in the same expression are not supported"));
 			}

package/src/duckdb/src/planner/binder/expression/bind_subquery_expression.cpp

@@ -8,6 +8,9 @@
 namespace duckdb {
 
 class BoundSubqueryNode : public QueryNode {
+public:
+	static constexpr const QueryNodeType TYPE = QueryNodeType::BOUND_SUBQUERY_NODE;
+
 public:
 	BoundSubqueryNode(shared_ptr<Binder> subquery_binder, unique_ptr<BoundQueryNode> bound_node,
 	                  unique_ptr<SelectStatement> subquery)
@@ -74,9 +77,9 @@ BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t dept
 	}
 	// both binding the child and binding the subquery was successful
 	D_ASSERT(expr.subquery->node->type == QueryNodeType::BOUND_SUBQUERY_NODE);
-	auto bound_subquery = (BoundSubqueryNode *)expr.subquery->node.get();
-	auto subquery_binder = std::move(bound_subquery->subquery_binder);
-	auto bound_node = std::move(bound_subquery->bound_node);
+	auto &bound_subquery = expr.subquery->node->Cast<BoundSubqueryNode>();
+	auto subquery_binder = std::move(bound_subquery.subquery_binder);
+	auto bound_node = std::move(bound_subquery.bound_node);
 	LogicalType return_type =
 	    expr.subquery_type == SubqueryType::SCALAR ? bound_node->types[0] : LogicalType(LogicalTypeId::BOOLEAN);
 	if (return_type.id() == LogicalTypeId::UNKNOWN) {

package/src/duckdb/src/planner/binder/query_node/bind_select_node.cpp

@@ -113,7 +113,7 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 		unique_ptr<BoundResultModifier> bound_modifier;
 		switch (mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &distinct = (DistinctModifier &)*mod;
+			auto &distinct = mod->Cast<DistinctModifier>();
 			auto bound_distinct = make_uniq<BoundDistinctModifier>();
 			bound_distinct->distinct_type =
 			    distinct.distinct_on_targets.empty() ? DistinctType::DISTINCT : DistinctType::DISTINCT_ON;
@@ -133,7 +133,7 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
-			auto &order = (OrderModifier &)*mod;
+			auto &order = mod->Cast<OrderModifier>();
 			auto bound_order = make_uniq<BoundOrderModifier>();
 			auto &config = DBConfig::GetConfig(context);
 			D_ASSERT(!order.orders.empty());
@@ -174,10 +174,10 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 			break;
 		}
 		case ResultModifierType::LIMIT_MODIFIER:
-			bound_modifier = BindLimit(order_binder, (LimitModifier &)*mod);
+			bound_modifier = BindLimit(order_binder, mod->Cast<LimitModifier>());
 			break;
 		case ResultModifierType::LIMIT_PERCENT_MODIFIER:
-			bound_modifier = BindLimitPercent(order_binder, (LimitPercentModifier &)*mod);
+			bound_modifier = BindLimitPercent(order_binder, mod->Cast<LimitPercentModifier>());
 			break;
 		default:
 			throw Exception("Unsupported result modifier");
@@ -203,7 +203,7 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 	for (auto &bound_mod : result.modifiers) {
 		switch (bound_mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &distinct = (BoundDistinctModifier &)*bound_mod;
+			auto &distinct = bound_mod->Cast<BoundDistinctModifier>();
 			D_ASSERT(!distinct.target_distincts.empty());
 			// set types of distinct targets
 			for (auto &expr : distinct.target_distincts) {
@@ -226,19 +226,19 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 			break;
 		}
 		case ResultModifierType::LIMIT_MODIFIER: {
-			auto &limit = (BoundLimitModifier &)*bound_mod;
+			auto &limit = bound_mod->Cast<BoundLimitModifier>();
 			AssignReturnType(limit.limit, sql_types);
 			AssignReturnType(limit.offset, sql_types);
 			break;
 		}
 		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
-			auto &limit = (BoundLimitPercentModifier &)*bound_mod;
+			auto &limit = bound_mod->Cast<BoundLimitPercentModifier>();
 			AssignReturnType(limit.limit, sql_types);
 			AssignReturnType(limit.offset, sql_types);
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
-			auto &order = (BoundOrderModifier &)*bound_mod;
+			auto &order = bound_mod->Cast<BoundOrderModifier>();
 			for (auto &order_node : order.orders) {
 				auto &expr = order_node.expression;
 				D_ASSERT(expr->type == ExpressionType::BOUND_COLUMN_REF);

package/src/duckdb/src/planner/binder/query_node/plan_query_node.cpp

@@ -13,14 +13,14 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 	for (auto &mod : node.modifiers) {
 		switch (mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &bound = (BoundDistinctModifier &)*mod;
+			auto &bound = mod->Cast<BoundDistinctModifier>();
 			auto distinct = make_uniq<LogicalDistinct>(std::move(bound.target_distincts), bound.distinct_type);
 			distinct->AddChild(std::move(root));
 			root = std::move(distinct);
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
-			auto &bound = (BoundOrderModifier &)*mod;
+			auto &bound = mod->Cast<BoundOrderModifier>();
 			if (root->type == LogicalOperatorType::LOGICAL_DISTINCT) {
 				auto &distinct = root->Cast<LogicalDistinct>();
 				if (distinct.distinct_type == DistinctType::DISTINCT_ON) {
@@ -37,7 +37,7 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 			break;
 		}
 		case ResultModifierType::LIMIT_MODIFIER: {
-			auto &bound = (BoundLimitModifier &)*mod;
+			auto &bound = mod->Cast<BoundLimitModifier>();
 			auto limit = make_uniq<LogicalLimit>(bound.limit_val, bound.offset_val, std::move(bound.limit),
 			                                     std::move(bound.offset));
 			limit->AddChild(std::move(root));
@@ -45,7 +45,7 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 			break;
 		}
 		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
-			auto &bound = (BoundLimitPercentModifier &)*mod;
+			auto &bound = mod->Cast<BoundLimitPercentModifier>();
 			auto limit = make_uniq<LogicalLimitPercent>(bound.limit_percent, bound.offset_val, std::move(bound.limit),
 			                                            std::move(bound.offset));
 			limit->AddChild(std::move(root));

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -501,7 +501,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SCHEMA, std::move(stmt.info));
 		break;
 	case CatalogType::VIEW_ENTRY: {
-		auto &base = (CreateViewInfo &)*stmt.info;
+		auto &base = stmt.info->Cast<CreateViewInfo>();
 		// bind the schema
 		auto &schema = BindCreateSchema(*stmt.info);
 		BindCreateViewInfo(base);

package/src/duckdb/src/planner/binder/statement/bind_create_table.cpp

@@ -294,9 +294,26 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 		BindLogicalType(context, column.TypeMutable(), &result->schema.catalog);
 		// We add a catalog dependency
 		auto type_dependency = EnumType::GetCatalog(column.Type());
+
 		if (type_dependency) {
 			// Only if the USER comes from a create type
-			result->dependencies.AddDependency(*type_dependency);
+			if (!schema.catalog.IsTemporaryCatalog()) {
+				// If it is not a TEMP table we add a dependency
+				result->dependencies.AddDependency(*type_dependency);
+			} else {
+				auto enum_type = type_dependency->user_type;
+				auto &enum_entries = EnumType::GetValuesInsertOrder(enum_type);
+				auto enum_size = EnumType::GetSize(enum_type);
+				Vector copy_enum_entries_vec(LogicalType::VARCHAR, enum_size);
+				auto copy_enum_entries_ptr = FlatVector::GetData<string_t>(copy_enum_entries_vec);
+				auto enum_entries_ptr = FlatVector::GetData<string_t>(enum_entries);
+				for (idx_t enum_idx = 0; enum_idx < enum_size; enum_idx++) {
+					copy_enum_entries_ptr[enum_idx] =
+					    StringVector::AddStringOrBlob(copy_enum_entries_vec, enum_entries_ptr[enum_idx]);
+				}
+				auto copy_type = LogicalType::ENUM(EnumType::GetTypeName(enum_type), copy_enum_entries_vec, enum_size);
+				column.SetType(copy_type);
+			}
 		}
 	}
 	result->dependencies.VerifyDependencies(schema.catalog, result->Base().table);