duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

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

@@ -27,7 +27,7 @@ BoundStatement Binder::Bind(AlterStatement &stmt) {
 		stmt.info->catalog = entry->catalog->GetName();
 		stmt.info->schema = ((StandardEntry *)entry)->schema->name;
 	}
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_ALTER, move(stmt.info));
+	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_ALTER, std::move(stmt.info));
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }
@@ -39,7 +39,7 @@ BoundStatement Binder::Bind(TransactionStatement &stmt) {
 	BoundStatement result;
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_TRANSACTION, move(stmt.info));
+	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_TRANSACTION, std::move(stmt.info));
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }

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

@@ -11,58 +11,60 @@ namespace duckdb {
 
 static unique_ptr<ParsedExpression> SummarizeWrapUnnest(vector<unique_ptr<ParsedExpression>> &children,
                                                         const string &alias) {
-	auto list_function = make_unique<FunctionExpression>("list_value", move(children));
+	auto list_function = make_unique<FunctionExpression>("list_value", std::move(children));
 	vector<unique_ptr<ParsedExpression>> unnest_children;
-	unnest_children.push_back(move(list_function));
-	auto unnest_function = make_unique<FunctionExpression>("unnest", move(unnest_children));
+	unnest_children.push_back(std::move(list_function));
+	auto unnest_function = make_unique<FunctionExpression>("unnest", std::move(unnest_children));
 	unnest_function->alias = alias;
-	return move(unnest_function);
+	return std::move(unnest_function);
 }
 
 static unique_ptr<ParsedExpression> SummarizeCreateAggregate(const string &aggregate, string column_name) {
 	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(make_unique<ColumnRefExpression>(move(column_name)));
-	auto aggregate_function = make_unique<FunctionExpression>(aggregate, move(children));
-	auto cast_function = make_unique<CastExpression>(LogicalType::VARCHAR, move(aggregate_function));
-	return move(cast_function);
+	children.push_back(make_unique<ColumnRefExpression>(std::move(column_name)));
+	auto aggregate_function = make_unique<FunctionExpression>(aggregate, std::move(children));
+	auto cast_function = make_unique<CastExpression>(LogicalType::VARCHAR, std::move(aggregate_function));
+	return std::move(cast_function);
 }
 
 static unique_ptr<ParsedExpression> SummarizeCreateAggregate(const string &aggregate, string column_name,
                                                              const Value &modifier) {
 	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(make_unique<ColumnRefExpression>(move(column_name)));
+	children.push_back(make_unique<ColumnRefExpression>(std::move(column_name)));
 	children.push_back(make_unique<ConstantExpression>(modifier));
-	auto aggregate_function = make_unique<FunctionExpression>(aggregate, move(children));
-	auto cast_function = make_unique<CastExpression>(LogicalType::VARCHAR, move(aggregate_function));
-	return move(cast_function);
+	auto aggregate_function = make_unique<FunctionExpression>(aggregate, std::move(children));
+	auto cast_function = make_unique<CastExpression>(LogicalType::VARCHAR, std::move(aggregate_function));
+	return std::move(cast_function);
 }
 
 static unique_ptr<ParsedExpression> SummarizeCreateCountStar() {
 	vector<unique_ptr<ParsedExpression>> children;
-	auto aggregate_function = make_unique<FunctionExpression>("count_star", move(children));
-	return move(aggregate_function);
+	auto aggregate_function = make_unique<FunctionExpression>("count_star", std::move(children));
+	return std::move(aggregate_function);
 }
 
 static unique_ptr<ParsedExpression> SummarizeCreateBinaryFunction(const string &op, unique_ptr<ParsedExpression> left,
                                                                   unique_ptr<ParsedExpression> right) {
 	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(move(left));
-	children.push_back(move(right));
-	auto binary_function = make_unique<FunctionExpression>(op, move(children));
-	return move(binary_function);
+	children.push_back(std::move(left));
+	children.push_back(std::move(right));
+	auto binary_function = make_unique<FunctionExpression>(op, std::move(children));
+	return std::move(binary_function);
 }
 
 static unique_ptr<ParsedExpression> SummarizeCreateNullPercentage(string column_name) {
 	auto count_star = make_unique<CastExpression>(LogicalType::DOUBLE, SummarizeCreateCountStar());
-	auto count = make_unique<CastExpression>(LogicalType::DOUBLE, SummarizeCreateAggregate("count", move(column_name)));
-	auto null_percentage = SummarizeCreateBinaryFunction("/", move(count), move(count_star));
-	auto negate_x =
-	    SummarizeCreateBinaryFunction("-", make_unique<ConstantExpression>(Value::DOUBLE(1)), move(null_percentage));
+	auto count =
+	    make_unique<CastExpression>(LogicalType::DOUBLE, SummarizeCreateAggregate("count", std::move(column_name)));
+	auto null_percentage = SummarizeCreateBinaryFunction("/", std::move(count), std::move(count_star));
+	auto negate_x = SummarizeCreateBinaryFunction("-", make_unique<ConstantExpression>(Value::DOUBLE(1)),
+	                                              std::move(null_percentage));
 	auto percentage_x =
-	    SummarizeCreateBinaryFunction("*", move(negate_x), make_unique<ConstantExpression>(Value::DOUBLE(100)));
-	auto round_x =
-	    SummarizeCreateBinaryFunction("round", move(percentage_x), make_unique<ConstantExpression>(Value::INTEGER(2)));
-	auto concat_x = SummarizeCreateBinaryFunction("concat", move(round_x), make_unique<ConstantExpression>(Value("%")));
+	    SummarizeCreateBinaryFunction("*", std::move(negate_x), make_unique<ConstantExpression>(Value::DOUBLE(100)));
+	auto round_x = SummarizeCreateBinaryFunction("round", std::move(percentage_x),
+	                                             make_unique<ConstantExpression>(Value::INTEGER(2)));
+	auto concat_x =
+	    SummarizeCreateBinaryFunction("concat", std::move(round_x), make_unique<ConstantExpression>(Value("%")));
 
 	return concat_x;
 }
@@ -87,7 +89,7 @@ BoundStatement Binder::BindSummarize(ShowStatement &stmt) {
 	vector<unique_ptr<ParsedExpression>> count_children;
 	vector<unique_ptr<ParsedExpression>> null_percentage_children;
 	auto select = make_unique<SelectStatement>();
-	select->node = move(query_copy);
+	select->node = std::move(query_copy);
 	for (idx_t i = 0; i < plan.names.size(); i++) {
 		name_children.push_back(make_unique<ConstantExpression>(Value(plan.names[i])));
 		type_children.push_back(make_unique<ConstantExpression>(Value(plan.types[i].ToString())));
@@ -110,7 +112,7 @@ BoundStatement Binder::BindSummarize(ShowStatement &stmt) {
 		count_children.push_back(SummarizeCreateCountStar());
 		null_percentage_children.push_back(SummarizeCreateNullPercentage(plan.names[i]));
 	}
-	auto subquery_ref = make_unique<SubqueryRef>(move(select), "summarize_tbl");
+	auto subquery_ref = make_unique<SubqueryRef>(std::move(select), "summarize_tbl");
 	subquery_ref->column_name_alias = plan.names;
 
 	auto select_node = make_unique<SelectNode>();
@@ -126,7 +128,7 @@ BoundStatement Binder::BindSummarize(ShowStatement &stmt) {
 	select_node->select_list.push_back(SummarizeWrapUnnest(q75_children, "q75"));
 	select_node->select_list.push_back(SummarizeWrapUnnest(count_children, "count"));
 	select_node->select_list.push_back(SummarizeWrapUnnest(null_percentage_children, "null_percentage"));
-	select_node->from_table = move(subquery_ref);
+	select_node->from_table = std::move(subquery_ref);
 
 	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return Bind(*select_node);

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

@@ -1,6 +1,7 @@
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/statement/update_statement.hpp"
 #include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/tableref/bound_joinref.hpp"
 #include "duckdb/planner/bound_tableref.hpp"
 #include "duckdb/planner/constraints/bound_check_constraint.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
@@ -12,7 +13,7 @@
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/operator/logical_update.hpp"
 #include "duckdb/planner/tableref/bound_basetableref.hpp"
-#include "duckdb/planner/tableref/bound_crossproductref.hpp"
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/storage/data_table.hpp"
 
 #include <algorithm>
@@ -42,7 +43,7 @@ static void BindExtraColumns(TableCatalogEntry &table, LogicalGet &get, LogicalP
 				continue;
 			}
 			// column is not projected yet: project it by adding the clause "i=i" to the set of updated columns
-			auto &column = table.columns.GetColumn(check_column_id);
+			auto &column = table.GetColumns().GetColumn(check_column_id);
 			update.expressions.push_back(make_unique<BoundColumnRefExpression>(
 			    column.Type(), ColumnBinding(proj.table_index, proj.expressions.size())));
 			proj.expressions.push_back(make_unique<BoundColumnRefExpression>(
@@ -76,21 +77,25 @@ static bool TypeSupportsRegularUpdate(const LogicalType &type) {
 
 static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, LogicalProjection &proj,
                                   LogicalUpdate &update) {
+	if (!table.IsDuckTable()) {
+		return;
+	}
 	// check the constraints and indexes of the table to see if we need to project any additional columns
 	// we do this for indexes with multiple columns and CHECK constraints in the UPDATE clause
 	// suppose we have a constraint CHECK(i + j < 10); now we need both i and j to check the constraint
 	// if we are only updating one of the two columns we add the other one to the UPDATE set
 	// with a "useless" update (i.e. i=i) so we can verify that the CHECK constraint is not violated
-	for (auto &constraint : table.bound_constraints) {
+	for (auto &constraint : table.GetBoundConstraints()) {
 		if (constraint->type == ConstraintType::CHECK) {
 			auto &check = *reinterpret_cast<BoundCheckConstraint *>(constraint.get());
 			// check constraint! check if we need to add any extra columns to the UPDATE clause
 			BindExtraColumns(table, get, proj, update, check.bound_columns);
 		}
 	}
+	auto &storage = table.GetStorage();
 	if (update.return_chunk) {
 		physical_index_set_t all_columns;
-		for (idx_t i = 0; i < table.storage->column_definitions.size(); i++) {
+		for (idx_t i = 0; i < storage.column_definitions.size(); i++) {
 			all_columns.insert(PhysicalIndex(i));
 		}
 		BindExtraColumns(table, get, proj, update, all_columns);
@@ -100,7 +105,7 @@ static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, Log
 	// If the returning keyword is used, we need access to the whole row in case the user requests it.
 	// Therefore switch the update to a delete and insert.
 	update.update_is_del_and_insert = false;
-	table.storage->info->indexes.Scan([&](Index &index) {
+	storage.info->indexes.Scan([&](Index &index) {
 		if (index.IndexIsUpdated(update.columns)) {
 			update.update_is_del_and_insert = true;
 			return true;
@@ -110,7 +115,7 @@ static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, Log
 
 	// we also convert any updates on LIST columns into delete + insert
 	for (auto &col_index : update.columns) {
-		auto &column = table.columns.GetColumn(col_index);
+		auto &column = table.GetColumns().GetColumn(col_index);
 		if (!TypeSupportsRegularUpdate(column.Type())) {
 			update.update_is_del_and_insert = true;
 			break;
@@ -121,13 +126,58 @@ static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, Log
 		// the update updates a column required by an index or requires returning the updated rows,
 		// push projections for all columns
 		physical_index_set_t all_columns;
-		for (idx_t i = 0; i < table.storage->column_definitions.size(); i++) {
+		for (idx_t i = 0; i < storage.column_definitions.size(); i++) {
 			all_columns.insert(PhysicalIndex(i));
 		}
 		BindExtraColumns(table, get, proj, update, all_columns);
 	}
 }
 
+// This creates a LogicalProjection and moves 'root' into it as a child
+// unless there are no expressions to project, in which case it just returns 'root'
+unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator *op, unique_ptr<LogicalOperator> root,
+                                                  UpdateSetInfo &set_info, TableCatalogEntry *table,
+                                                  vector<PhysicalIndex> &columns) {
+	auto proj_index = GenerateTableIndex();
+
+	vector<unique_ptr<Expression>> projection_expressions;
+	D_ASSERT(set_info.columns.size() == set_info.expressions.size());
+	for (idx_t i = 0; i < set_info.columns.size(); i++) {
+		auto &colname = set_info.columns[i];
+		auto &expr = set_info.expressions[i];
+		if (!table->ColumnExists(colname)) {
+			throw BinderException("Referenced update column %s not found in table!", colname);
+		}
+		auto &column = table->GetColumn(colname);
+		if (column.Generated()) {
+			throw BinderException("Cant update column \"%s\" because it is a generated column!", column.Name());
+		}
+		if (std::find(columns.begin(), columns.end(), column.Physical()) != columns.end()) {
+			throw BinderException("Multiple assignments to same column \"%s\"", colname);
+		}
+		columns.push_back(column.Physical());
+		if (expr->type == ExpressionType::VALUE_DEFAULT) {
+			op->expressions.push_back(make_unique<BoundDefaultExpression>(column.Type()));
+		} else {
+			UpdateBinder binder(*this, context);
+			binder.target_type = column.Type();
+			auto bound_expr = binder.Bind(expr);
+			PlanSubqueries(&bound_expr, &root);
+
+			op->expressions.push_back(make_unique<BoundColumnRefExpression>(
+			    bound_expr->return_type, ColumnBinding(proj_index, projection_expressions.size())));
+			projection_expressions.push_back(std::move(bound_expr));
+		}
+	}
+	if (op->type != LogicalOperatorType::LOGICAL_UPDATE && projection_expressions.empty()) {
+		return root;
+	}
+	// now create the projection
+	auto proj = make_unique<LogicalProjection>(proj_index, std::move(projection_expressions));
+	proj->AddChild(std::move(root));
+	return unique_ptr_cast<LogicalProjection, LogicalOperator>(std::move(proj));
+}
+
 BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	BoundStatement result;
 	unique_ptr<LogicalOperator> root;
@@ -145,8 +195,8 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	AddCTEMap(stmt.cte_map);
 
 	if (stmt.from_table) {
-		BoundCrossProductRef bound_crossproduct;
-		bound_crossproduct.left = move(bound_table);
+		BoundJoinRef bound_crossproduct(JoinRefType::CROSS);
+		bound_crossproduct.left = std::move(bound_table);
 		bound_crossproduct.right = Bind(*stmt.from_table);
 		root = CreatePlan(bound_crossproduct);
 		get = (LogicalGet *)root->children[0].get();
@@ -166,80 +216,48 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 		update->return_chunk = true;
 	}
 	// bind the default values
-	BindDefaultValues(table->columns, update->bound_defaults);
+	BindDefaultValues(table->GetColumns(), update->bound_defaults);
 
 	// project any additional columns required for the condition/expressions
-	if (stmt.condition) {
+	if (stmt.set_info->condition) {
 		WhereBinder binder(*this, context);
-		auto condition = binder.Bind(stmt.condition);
+		auto condition = binder.Bind(stmt.set_info->condition);
 
 		PlanSubqueries(&condition, &root);
-		auto filter = make_unique<LogicalFilter>(move(condition));
-		filter->AddChild(move(root));
-		root = move(filter);
+		auto filter = make_unique<LogicalFilter>(std::move(condition));
+		filter->AddChild(std::move(root));
+		root = std::move(filter);
 	}
 
-	D_ASSERT(stmt.columns.size() == stmt.expressions.size());
-
-	auto proj_index = GenerateTableIndex();
-	vector<unique_ptr<Expression>> projection_expressions;
+	D_ASSERT(stmt.set_info);
+	D_ASSERT(stmt.set_info->columns.size() == stmt.set_info->expressions.size());
 
-	for (idx_t i = 0; i < stmt.columns.size(); i++) {
-		auto &colname = stmt.columns[i];
-		auto &expr = stmt.expressions[i];
-		if (!table->ColumnExists(colname)) {
-			throw BinderException("Referenced update column %s not found in table!", colname);
-		}
-		auto &column = table->GetColumn(colname);
-		if (column.Generated()) {
-			throw BinderException("Cant update column \"%s\" because it is a generated column!", column.Name());
-		}
-		if (std::find(update->columns.begin(), update->columns.end(), column.Physical()) != update->columns.end()) {
-			throw BinderException("Multiple assignments to same column \"%s\"", colname);
-		}
-		update->columns.push_back(column.Physical());
-
-		if (expr->type == ExpressionType::VALUE_DEFAULT) {
-			update->expressions.push_back(make_unique<BoundDefaultExpression>(column.Type()));
-		} else {
-			UpdateBinder binder(*this, context);
-			binder.target_type = column.Type();
-			auto bound_expr = binder.Bind(expr);
-			PlanSubqueries(&bound_expr, &root);
-
-			update->expressions.push_back(make_unique<BoundColumnRefExpression>(
-			    bound_expr->return_type, ColumnBinding(proj_index, projection_expressions.size())));
-			projection_expressions.push_back(move(bound_expr));
-		}
-	}
-
-	// now create the projection
-	auto proj = make_unique<LogicalProjection>(proj_index, move(projection_expressions));
-	proj->AddChild(move(root));
+	auto proj_tmp = BindUpdateSet(update.get(), std::move(root), *stmt.set_info, table, update->columns);
+	D_ASSERT(proj_tmp->type == LogicalOperatorType::LOGICAL_PROJECTION);
+	auto proj = unique_ptr_cast<LogicalOperator, LogicalProjection>(std::move(proj_tmp));
 
 	// bind any extra columns necessary for CHECK constraints or indexes
 	BindUpdateConstraints(*table, *get, *proj, *update);
-
 	// finally add the row id column to the projection list
 	proj->expressions.push_back(make_unique<BoundColumnRefExpression>(
 	    LogicalType::ROW_TYPE, ColumnBinding(get->table_index, get->column_ids.size())));
 	get->column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
 
 	// set the projection as child of the update node and finalize the result
-	update->AddChild(move(proj));
+	update->AddChild(std::move(proj));
 
 	auto update_table_index = GenerateTableIndex();
 	update->table_index = update_table_index;
 	if (!stmt.returning_list.empty()) {
-		unique_ptr<LogicalOperator> update_as_logicaloperator = move(update);
+		unique_ptr<LogicalOperator> update_as_logicaloperator = std::move(update);
 
-		return BindReturning(move(stmt.returning_list), table, update_table_index, move(update_as_logicaloperator),
-		                     move(result));
+		return BindReturning(std::move(stmt.returning_list), table, update_table_index,
+		                     std::move(update_as_logicaloperator), std::move(result));
 	}
 
 	result.names = {"Count"};
 	result.types = {LogicalType::BIGINT};
-	result.plan = move(update);
+	result.plan = std::move(update);
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::CHANGED_ROWS;
 	return result;

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

@@ -4,6 +4,7 @@
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/operator/logical_simple.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
 
@@ -19,7 +20,7 @@ BoundStatement Binder::Bind(VacuumStatement &stmt) {
 		if (bound_table->type != TableReferenceType::BASE_TABLE) {
 			throw InvalidInputException("Can only vacuum/analyze base tables!");
 		}
-		auto ref = unique_ptr_cast<BoundTableRef, BoundBaseTableRef>(move(bound_table));
+		auto ref = unique_ptr_cast<BoundTableRef, BoundBaseTableRef>(std::move(bound_table));
 		stmt.info->table = ref->table;
 
 		auto &columns = stmt.info->columns;
@@ -51,9 +52,9 @@ BoundStatement Binder::Bind(VacuumStatement &stmt) {
 			if (result.HasError()) {
 				throw BinderException(result.error);
 			}
-			select_list.push_back(move(result.expression));
+			select_list.push_back(std::move(result.expression));
 		}
-		stmt.info->columns = move(non_generated_column_names);
+		stmt.info->columns = std::move(non_generated_column_names);
 		if (!select_list.empty()) {
 			auto table_scan = CreatePlan(*ref);
 			D_ASSERT(table_scan->type == LogicalOperatorType::LOGICAL_GET);
@@ -64,13 +65,13 @@ BoundStatement Binder::Bind(VacuumStatement &stmt) {
 			D_ASSERT(stmt.info->columns.size() == get.column_ids.size());
 			for (idx_t i = 0; i < get.column_ids.size(); i++) {
 				stmt.info->column_id_map[i] =
-				    ref->table->columns.LogicalToPhysical(LogicalIndex(get.column_ids[i])).index;
+				    ref->table->GetColumns().LogicalToPhysical(LogicalIndex(get.column_ids[i])).index;
 			}
 
-			auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(select_list));
-			projection->children.push_back(move(table_scan));
+			auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), std::move(select_list));
+			projection->children.push_back(std::move(table_scan));
 
-			root = move(projection);
+			root = std::move(projection);
 		} else {
 			// eg. CREATE TABLE test (x AS (1));
 			//     ANALYZE test;
@@ -78,14 +79,14 @@ BoundStatement Binder::Bind(VacuumStatement &stmt) {
 			stmt.info->has_table = false;
 		}
 	}
-	auto vacuum = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_VACUUM, move(stmt.info));
+	auto vacuum = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_VACUUM, std::move(stmt.info));
 	if (root) {
-		vacuum->children.push_back(move(root));
+		vacuum->children.push_back(std::move(root));
 	}
 
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
-	result.plan = move(vacuum);
+	result.plan = std::move(vacuum);
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }

package/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp

@@ -1,3 +1,4 @@
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
 #include "duckdb/parser/tableref/basetableref.hpp"
 #include "duckdb/parser/tableref/subqueryref.hpp"
@@ -8,7 +9,6 @@
 #include "duckdb/planner/tableref/bound_cteref.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
-#include "duckdb/function/table/table_scan.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/main/config.hpp"
@@ -57,8 +57,8 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 			(*cteref)++;
 
 			result->types = b->types;
-			result->bound_columns = move(names);
-			return move(result);
+			result->bound_columns = std::move(names);
+			return std::move(result);
 		}
 	}
 	// not a CTE
@@ -79,7 +79,16 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 				auto replacement_function = scan.function(context, table_name, scan.data.get());
 				if (replacement_function) {
 					replacement_function->alias = ref.alias.empty() ? ref.table_name : ref.alias;
-					replacement_function->column_name_alias = ref.column_name_alias;
+					if (replacement_function->type == TableReferenceType::TABLE_FUNCTION) {
+						auto &table_function = (TableFunctionRef &)*replacement_function;
+						table_function.column_name_alias = ref.column_name_alias;
+						;
+					} else if (replacement_function->type == TableReferenceType::SUBQUERY) {
+						auto &subquery = (SubqueryRef &)*replacement_function;
+						subquery.column_name_alias = ref.column_name_alias;
+					} else {
+						throw InternalException("Replacement scan should return either a table function or a subquery");
+					}
 					return Bind(*replacement_function);
 				}
 			}
@@ -108,8 +117,8 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		auto table_index = GenerateTableIndex();
 		auto table = (TableCatalogEntry *)table_or_view;
 
-		auto scan_function = TableScanFunction::GetFunction();
-		auto bind_data = make_unique<TableScanBindData>(table);
+		unique_ptr<FunctionData> bind_data;
+		auto scan_function = table->GetScanFunction(context, bind_data);
 		auto alias = ref.alias.empty() ? ref.table_name : ref.alias;
 		// TODO: bundle the type and name vector in a struct (e.g PackedColumnMetadata)
 		vector<LogicalType> table_types;
@@ -118,7 +127,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 
 		vector<LogicalType> return_types;
 		vector<string> return_names;
-		for (auto &col : table->columns.Logical()) {
+		for (auto &col : table->GetColumns().Logical()) {
 			table_types.push_back(col.Type());
 			table_names.push_back(col.Name());
 			return_types.push_back(col.Type());
@@ -126,11 +135,11 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		}
 		table_names = BindContext::AliasColumnNames(alias, table_names, ref.column_name_alias);
 
-		auto logical_get = make_unique<LogicalGet>(table_index, scan_function, move(bind_data), move(return_types),
-		                                           move(return_names));
+		auto logical_get = make_unique<LogicalGet>(table_index, scan_function, std::move(bind_data),
+		                                           std::move(return_types), std::move(return_names));
 		bind_context.AddBaseTable(table_index, alias, table_names, table_types, logical_get->column_ids,
 		                          logical_get->GetTable());
-		return make_unique_base<BoundTableRef, BoundBaseTableRef>(table, move(logical_get));
+		return make_unique_base<BoundTableRef, BoundBaseTableRef>(table, std::move(logical_get));
 	}
 	case CatalogType::VIEW_ENTRY: {
 		// the node is a view: get the query that the view represents

package/src/duckdb/src/planner/binder/tableref/bind_expressionlistref.cpp

@@ -30,9 +30,9 @@ unique_ptr<BoundTableRef> Binder::Bind(ExpressionListRef &expr) {
 				binder.target_type = result->types[val_idx];
 			}
 			auto expr = binder.Bind(expression_list[val_idx]);
-			list.push_back(move(expr));
+			list.push_back(std::move(expr));
 		}
-		result->values.push_back(move(list));
+		result->values.push_back(std::move(list));
 	}
 	if (result->types.empty() && !expr.values.empty()) {
 		// there are no types specified
@@ -53,13 +53,13 @@ unique_ptr<BoundTableRef> Binder::Bind(ExpressionListRef &expr) {
 			auto &list = result->values[list_idx];
 			for (idx_t val_idx = 0; val_idx < list.size(); val_idx++) {
 				list[val_idx] =
-				    BoundCastExpression::AddCastToType(context, move(list[val_idx]), result->types[val_idx]);
+				    BoundCastExpression::AddCastToType(context, std::move(list[val_idx]), result->types[val_idx]);
 			}
 		}
 	}
 	result->bind_index = GenerateTableIndex();
 	bind_context.AddGenericBinding(result->bind_index, expr.alias, result->names, result->types);
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/binder/tableref/bind_joinref.cpp

@@ -18,7 +18,7 @@ static unique_ptr<ParsedExpression> BindColumn(Binder &binder, ClientContext &co
 	auto expr = make_unique_base<ParsedExpression, ColumnRefExpression>(column_name, alias);
 	ExpressionBinder expr_binder(binder, context);
 	auto result = expr_binder.Bind(expr);
-	return make_unique<BoundExpression>(move(result));
+	return make_unique<BoundExpression>(std::move(result));
 }
 
 static unique_ptr<ParsedExpression> AddCondition(ClientContext &context, Binder &left_binder, Binder &right_binder,
@@ -27,7 +27,7 @@ static unique_ptr<ParsedExpression> AddCondition(ClientContext &context, Binder
 	ExpressionBinder expr_binder(left_binder, context);
 	auto left = BindColumn(left_binder, context, left_alias, column_name);
 	auto right = BindColumn(right_binder, context, right_alias, column_name);
-	return make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, move(left), move(right));
+	return make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, std::move(left), std::move(right));
 }
 
 bool Binder::TryFindBinding(const string &using_column, const string &join_side, string &result) {
@@ -117,7 +117,7 @@ static vector<string> RemoveDuplicateUsingColumns(const vector<string> &using_co
 }
 
 unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
-	auto result = make_unique<BoundJoinRef>();
+	auto result = make_unique<BoundJoinRef>(ref.ref_type);
 	result->left_binder = Binder::CreateBinder(context, this);
 	result->right_binder = Binder::CreateBinder(context, this);
 	auto &left_binder = *result->left_binder;
@@ -140,7 +140,8 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 
 	vector<unique_ptr<ParsedExpression>> extra_conditions;
 	vector<string> extra_using_columns;
-	if (ref.is_natural) {
+	switch (ref.ref_type) {
+	case JoinRefType::NATURAL: {
 		// natural join, figure out which column names are present in both sides of the join
 		// first bind the left hand side and get a list of all the tables and column names
 		case_insensitive_set_t lhs_columns;
@@ -191,10 +192,18 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 			error_msg += "\n   Right candidates: " + right_candidates;
 			throw BinderException(FormatError(ref, error_msg));
 		}
-	} else if (!ref.using_columns.empty()) {
-		// USING columns
-		D_ASSERT(!result->condition);
-		extra_using_columns = ref.using_columns;
+		break;
+	}
+	case JoinRefType::REGULAR:
+		if (!ref.using_columns.empty()) {
+			// USING columns
+			D_ASSERT(!result->condition);
+			extra_using_columns = ref.using_columns;
+		}
+		break;
+	case JoinRefType::CROSS:
+	case JoinRefType::POSITIONAL:
+		break;
 	}
 	extra_using_columns = RemoveDuplicateUsingColumns(extra_using_columns);
 
@@ -239,28 +248,27 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 			                                  using_column);
 			bind_context.TransferUsingBinding(right_binder.bind_context, right_using_binding, set.get(), right_binding,
 			                                  using_column);
-			AddUsingBindingSet(move(set));
+			AddUsingBindingSet(std::move(set));
 		}
 	}
 
-	bind_context.AddContext(move(left_binder.bind_context));
-	bind_context.AddContext(move(right_binder.bind_context));
+	bind_context.AddContext(std::move(left_binder.bind_context));
+	bind_context.AddContext(std::move(right_binder.bind_context));
 	MoveCorrelatedExpressions(left_binder);
 	MoveCorrelatedExpressions(right_binder);
 	for (auto &condition : extra_conditions) {
 		if (ref.condition) {
-			ref.condition = make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, move(ref.condition),
-			                                                   move(condition));
+			ref.condition = make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
+			                                                   std::move(ref.condition), std::move(condition));
 		} else {
-			ref.condition = move(condition);
+			ref.condition = std::move(condition);
 		}
 	}
 	if (ref.condition) {
 		WhereBinder binder(*this, context);
 		result->condition = binder.Bind(ref.condition);
 	}
-	D_ASSERT(result->condition);
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/binder/tableref/bind_subqueryref.cpp

@@ -19,10 +19,10 @@ unique_ptr<BoundTableRef> Binder::Bind(SubqueryRef &ref, CommonTableExpressionIn
 	} else {
 		alias = ref.alias;
 	}
-	auto result = make_unique<BoundSubqueryRef>(move(binder), move(subquery));
+	auto result = make_unique<BoundSubqueryRef>(std::move(binder), std::move(subquery));
 	bind_context.AddSubquery(bind_index, alias, ref, *result->subquery);
 	MoveCorrelatedExpressions(*result->binder);
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb