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

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

@@ -3,6 +3,7 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/operator/logical_export.hpp"
 #include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/parser/statement/copy_statement.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"
@@ -54,8 +55,9 @@ void ScanForeignKeyTable(vector<TableCatalogEntry *> &ordered, vector<TableCatal
 	for (auto i = unordered.begin(); i != unordered.end();) {
 		auto table_entry = *i;
 		bool move_to_ordered = true;
-		for (idx_t j = 0; j < table_entry->constraints.size(); j++) {
-			auto &cond = table_entry->constraints[j];
+		auto &constraints = table_entry->GetConstraints();
+		for (idx_t j = 0; j < constraints.size(); j++) {
+			auto &cond = constraints[j];
 			if (cond->type == ConstraintType::FOREIGN_KEY) {
 				auto &fk = (ForeignKeyConstraint &)*cond;
 				if ((move_only_pk_table && fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) ||
@@ -85,6 +87,15 @@ void ReorderTableEntries(vector<TableCatalogEntry *> &tables) {
 	tables = ordered;
 }
 
+string CreateFileName(const string &id_suffix, TableCatalogEntry *table, const string &extension) {
+	auto name = SanitizeExportIdentifier(table->name);
+	if (table->schema->name == DEFAULT_SCHEMA) {
+		return StringUtil::Format("%s%s.%s", name, id_suffix, extension);
+	}
+	auto schema = SanitizeExportIdentifier(table->schema->name);
+	return StringUtil::Format("%s_%s%s.%s", schema, name, id_suffix, extension);
+}
+
 BoundStatement Binder::Bind(ExportStatement &stmt) {
 	// COPY TO a file
 	auto &config = DBConfig::GetConfig(context);
@@ -98,7 +109,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 	// lookup the format in the catalog
 	auto copy_function =
 	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->format);
-	if (!copy_function->function.copy_to_bind) {
+	if (!copy_function->function.copy_to_bind && !copy_function->function.plan) {
 		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 
@@ -135,20 +146,13 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		idx_t id = 0;
 		while (true) {
 			string id_suffix = id == 0 ? string() : "_" + to_string(id);
-			if (table->schema->name == DEFAULT_SCHEMA) {
-				info->file_path = fs.JoinPath(stmt.info->file_path,
-				                              StringUtil::Format("%s%s.%s", SanitizeExportIdentifier(table->name),
-				                                                 id_suffix, copy_function->function.extension));
-			} else {
-				info->file_path =
-				    fs.JoinPath(stmt.info->file_path,
-				                StringUtil::Format("%s_%s%s.%s", SanitizeExportIdentifier(table->schema->name),
-				                                   SanitizeExportIdentifier(table->name), id_suffix,
-				                                   copy_function->function.extension));
-			}
-			if (table_name_index.find(info->file_path) == table_name_index.end()) {
+			auto name = CreateFileName(id_suffix, table, copy_function->function.extension);
+			auto directory = stmt.info->file_path;
+			auto full_path = fs.JoinPath(directory, name);
+			info->file_path = full_path;
+			auto insert_result = table_name_index.insert(info->file_path);
+			if (insert_result.second == true) {
 				// this name was not yet taken: take it
-				table_name_index.insert(info->file_path);
 				break;
 			}
 			id++;
@@ -159,13 +163,14 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		info->table = table->name;
 
 		// We can not export generated columns
-		for (auto &col : table->columns.Physical()) {
+		for (auto &col : table->GetColumns().Physical()) {
 			info->select_list.push_back(col.GetName());
 		}
 
 		exported_data.database_name = catalog;
 		exported_data.table_name = info->table;
 		exported_data.schema_name = info->schema;
+
 		exported_data.file_path = info->file_path;
 
 		ExportedTableInfo table_info;
@@ -176,18 +181,18 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 
 		// generate the copy statement and bind it
 		CopyStatement copy_stmt;
-		copy_stmt.info = move(info);
+		copy_stmt.info = std::move(info);
 
 		auto copy_binder = Binder::CreateBinder(context, this);
 		auto bound_statement = copy_binder->Bind(copy_stmt);
 		if (child_operator) {
 			// use UNION ALL to combine the individual copy statements into a single node
 			auto copy_union =
-			    make_unique<LogicalSetOperation>(GenerateTableIndex(), 1, move(child_operator),
-			                                     move(bound_statement.plan), LogicalOperatorType::LOGICAL_UNION);
-			child_operator = move(copy_union);
+			    make_unique<LogicalSetOperation>(GenerateTableIndex(), 1, std::move(child_operator),
+			                                     std::move(bound_statement.plan), LogicalOperatorType::LOGICAL_UNION);
+			child_operator = std::move(copy_union);
 		} else {
-			child_operator = move(bound_statement.plan);
+			child_operator = std::move(bound_statement.plan);
 		}
 	}
 
@@ -198,13 +203,13 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 	}
 
 	// create the export node
-	auto export_node = make_unique<LogicalExport>(copy_function->function, move(stmt.info), exported_tables);
+	auto export_node = make_unique<LogicalExport>(copy_function->function, std::move(stmt.info), exported_tables);
 
 	if (child_operator) {
-		export_node->children.push_back(move(child_operator));
+		export_node->children.push_back(std::move(child_operator));
 	}
 
-	result.plan = move(export_node);
+	result.plan = std::move(export_node);
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;

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

@@ -9,14 +9,15 @@ BoundStatement Binder::Bind(ExtensionStatement &stmt) {
 
 	// perform the planning of the function
 	D_ASSERT(stmt.extension.plan_function);
-	auto parse_result = stmt.extension.plan_function(stmt.extension.parser_info.get(), context, move(stmt.parse_data));
+	auto parse_result =
+	    stmt.extension.plan_function(stmt.extension.parser_info.get(), context, std::move(stmt.parse_data));
 
 	properties.modified_databases = parse_result.modified_databases;
 	properties.requires_valid_transaction = parse_result.requires_valid_transaction;
 	properties.return_type = parse_result.return_type;
 
 	// create the plan as a scan of the given table function
-	result.plan = BindTableFunction(parse_result.function, move(parse_result.parameters));
+	result.plan = BindTableFunction(parse_result.function, std::move(parse_result.parameters));
 	D_ASSERT(result.plan->type == LogicalOperatorType::LOGICAL_GET);
 	auto &get = (LogicalGet &)*result.plan;
 	result.names = get.names;

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

@@ -6,11 +6,24 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression_binder/insert_binder.hpp"
 #include "duckdb/planner/operator/logical_insert.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/function/table/table_scan.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/expression_binder/returning_binder.hpp"
+#include "duckdb/planner/expression_binder/where_binder.hpp"
+#include "duckdb/planner/expression_binder/update_binder.hpp"
+#include "duckdb/planner/operator/logical_filter.hpp"
+#include "duckdb/parser/statement/update_statement.hpp"
+#include "duckdb/planner/expression/bound_default_expression.hpp"
+#include "duckdb/storage/data_table.hpp"
+#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/planner/bound_tableref.hpp"
+#include "duckdb/planner/tableref/bound_basetableref.hpp"
+#include "duckdb/planner/tableref/bound_dummytableref.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
 
 namespace duckdb {
 
@@ -25,6 +38,335 @@ static void CheckInsertColumnCountMismatch(int64_t expected_columns, int64_t res
 	}
 }
 
+unique_ptr<ParsedExpression> ExpandDefaultExpression(const ColumnDefinition &column) {
+	if (column.DefaultValue()) {
+		return column.DefaultValue()->Copy();
+	} else {
+		return make_unique<ConstantExpression>(Value(column.Type()));
+	}
+}
+
+void ReplaceDefaultExpression(unique_ptr<ParsedExpression> &expr, const ColumnDefinition &column) {
+	D_ASSERT(expr->type == ExpressionType::VALUE_DEFAULT);
+	expr = ExpandDefaultExpression(column);
+}
+
+void QualifyColumnReferences(unique_ptr<ParsedExpression> &expr, const string &table_name) {
+	// To avoid ambiguity with 'excluded', we explicitly qualify all column references
+	if (expr->type == ExpressionType::COLUMN_REF) {
+		auto &column_ref = (ColumnRefExpression &)*expr;
+		if (column_ref.IsQualified()) {
+			return;
+		}
+		auto column_name = column_ref.GetColumnName();
+		expr = make_unique<ColumnRefExpression>(column_name, table_name);
+	}
+	ParsedExpressionIterator::EnumerateChildren(
+	    *expr, [&](unique_ptr<ParsedExpression> &child) { QualifyColumnReferences(child, table_name); });
+}
+
+// Replace binding.table_index with 'dest' if it's 'source'
+void ReplaceColumnBindings(Expression &expr, idx_t source, idx_t dest) {
+	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
+		auto &bound_columnref = (BoundColumnRefExpression &)expr;
+		if (bound_columnref.binding.table_index == source) {
+			bound_columnref.binding.table_index = dest;
+		}
+	}
+	ExpressionIterator::EnumerateChildren(
+	    expr, [&](unique_ptr<Expression> &child) { ReplaceColumnBindings(*child, source, dest); });
+}
+
+void Binder::BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert *insert, UpdateSetInfo &set_info,
+                                        TableCatalogEntry &table) {
+	D_ASSERT(insert->children.size() == 1);
+	D_ASSERT(insert->children[0]->type == LogicalOperatorType::LOGICAL_PROJECTION);
+
+	vector<column_t> logical_column_ids;
+	vector<string> column_names;
+	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(insert->set_columns.begin(), insert->set_columns.end(), column.Physical()) !=
+		    insert->set_columns.end()) {
+			throw BinderException("Multiple assignments to same column \"%s\"", colname);
+		}
+		insert->set_columns.push_back(column.Physical());
+		logical_column_ids.push_back(column.Oid());
+		insert->set_types.push_back(column.Type());
+		column_names.push_back(colname);
+		if (expr->type == ExpressionType::VALUE_DEFAULT) {
+			expr = ExpandDefaultExpression(column);
+		}
+		UpdateBinder binder(*this, context);
+		binder.target_type = column.Type();
+
+		// Avoid ambiguity issues
+		QualifyColumnReferences(expr, table_alias);
+
+		auto bound_expr = binder.Bind(expr);
+		D_ASSERT(bound_expr);
+		if (bound_expr->expression_class == ExpressionClass::BOUND_SUBQUERY) {
+			throw BinderException("Expression in the DO UPDATE SET clause can not be a subquery");
+		}
+
+		insert->expressions.push_back(std::move(bound_expr));
+	}
+
+	// Figure out which columns are indexed on
+	unordered_set<column_t> indexed_columns;
+	auto &indexes = table.GetStorage().info->indexes.Indexes();
+	for (auto &index : indexes) {
+		for (auto &column_id : index->column_id_set) {
+			indexed_columns.insert(column_id);
+		}
+	}
+
+	// Verify that none of the columns that are targeted with a SET expression are indexed on
+	for (idx_t i = 0; i < logical_column_ids.size(); i++) {
+		auto &column = logical_column_ids[i];
+		if (indexed_columns.count(column)) {
+			throw BinderException("Can not assign to column '%s' because it has a UNIQUE/PRIMARY KEY constraint",
+			                      column_names[i]);
+		}
+	}
+}
+
+unique_ptr<UpdateSetInfo> CreateSetInfoForReplace(TableCatalogEntry &table, InsertStatement &insert) {
+	auto set_info = make_unique<UpdateSetInfo>();
+
+	auto &columns = set_info->columns;
+	// Figure out which columns are indexed on
+
+	unordered_set<column_t> indexed_columns;
+	auto &indexes = table.GetStorage().info->indexes.Indexes();
+	for (auto &index : indexes) {
+		for (auto &column_id : index->column_id_set) {
+			indexed_columns.insert(column_id);
+		}
+	}
+
+	auto &column_list = table.GetColumns();
+	if (insert.columns.empty()) {
+		for (auto &column : column_list.Physical()) {
+			auto &name = column.Name();
+			// FIXME: can these column names be aliased somehow?
+			if (indexed_columns.count(column.Oid())) {
+				continue;
+			}
+			columns.push_back(name);
+		}
+	} else {
+		// a list of columns was explicitly supplied, only update those
+		for (auto &name : insert.columns) {
+			auto &column = column_list.GetColumn(name);
+			if (indexed_columns.count(column.Oid())) {
+				continue;
+			}
+			columns.push_back(name);
+		}
+	}
+
+	// Create 'excluded' qualified column references of these columns
+	for (auto &column : columns) {
+		set_info->expressions.push_back(make_unique<ColumnRefExpression>(column, "excluded"));
+	}
+
+	return set_info;
+}
+
+void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &table, InsertStatement &stmt) {
+	if (!stmt.on_conflict_info) {
+		insert.action_type = OnConflictAction::THROW;
+		return;
+	}
+	if (!table.IsDuckTable()) {
+		throw BinderException("ON CONFLICT clause is not yet supported for non-DuckDB tables");
+	}
+	D_ASSERT(stmt.table_ref->type == TableReferenceType::BASE_TABLE);
+
+	// visit the table reference
+	auto bound_table = Bind(*stmt.table_ref);
+	if (bound_table->type != TableReferenceType::BASE_TABLE) {
+		throw BinderException("Can only update base table!");
+	}
+
+	auto &table_ref = (BaseTableRef &)*stmt.table_ref;
+	const string &table_alias = !table_ref.alias.empty() ? table_ref.alias : table_ref.table_name;
+
+	auto &on_conflict = *stmt.on_conflict_info;
+	D_ASSERT(on_conflict.action_type != OnConflictAction::THROW);
+	insert.action_type = on_conflict.action_type;
+
+	auto &columns = table.GetColumns();
+	if (!on_conflict.indexed_columns.empty()) {
+		// Bind the ON CONFLICT (<columns>)
+
+		// create a mapping of (list index) -> (column index)
+		case_insensitive_map_t<idx_t> specified_columns;
+		for (idx_t i = 0; i < on_conflict.indexed_columns.size(); i++) {
+			specified_columns[on_conflict.indexed_columns[i]] = i;
+			auto column_index = table.GetColumnIndex(on_conflict.indexed_columns[i]);
+			if (column_index.index == COLUMN_IDENTIFIER_ROW_ID) {
+				throw BinderException("Cannot specify ROWID as ON CONFLICT target");
+			}
+			auto &col = columns.GetColumn(column_index);
+			if (col.Generated()) {
+				throw BinderException("Cannot specify a generated column as ON CONFLICT target");
+			}
+		}
+		for (auto &col : columns.Physical()) {
+			auto entry = specified_columns.find(col.Name());
+			if (entry != specified_columns.end()) {
+				// column was specified, set to the index
+				insert.on_conflict_filter.insert(col.Oid());
+			}
+		}
+		auto &indexes = table.GetStorage().info->indexes;
+		bool index_references_columns = false;
+		indexes.Scan([&](Index &index) {
+			if (!index.IsUnique()) {
+				return false;
+			}
+			bool index_matches = insert.on_conflict_filter == index.column_id_set;
+			if (index_matches) {
+				index_references_columns = true;
+			}
+			return index_matches;
+		});
+		if (!index_references_columns) {
+			// Same as before, this is essentially a no-op, turning this into a DO THROW instead
+			// But since this makes no logical sense, it's probably better to throw an error
+			throw BinderException(
+			    "The specified columns as conflict target are not referenced by a UNIQUE/PRIMARY KEY CONSTRAINT");
+		}
+	} else {
+		// When omitting the conflict target, the ON CONFLICT applies to every UNIQUE/PRIMARY KEY on the table
+
+		// We check if there are any constraints on the table, if there aren't we throw an error.
+		auto &indexes = table.GetStorage().info->indexes;
+		idx_t found_matching_indexes = 0;
+		indexes.Scan([&](Index &index) {
+			if (!index.IsUnique()) {
+				return false;
+			}
+			// does this work with multi-column indexes?
+			auto &indexed_columns = index.column_id_set;
+			for (auto &column : table.GetColumns().Physical()) {
+				if (indexed_columns.count(column.Physical().index)) {
+					found_matching_indexes++;
+				}
+			}
+			return false;
+		});
+		if (!found_matching_indexes) {
+			throw BinderException(
+			    "There are no UNIQUE/PRIMARY KEY Indexes that refer to this table, ON CONFLICT is a no-op");
+		}
+		if (insert.action_type != OnConflictAction::NOTHING && found_matching_indexes != 1) {
+			// When no conflict target is provided, and the action type is UPDATE,
+			// we only allow the operation when only a single Index exists
+			throw BinderException("Conflict target has to be provided for a DO UPDATE operation when the table has "
+			                      "multiple UNIQUE/PRIMARY KEY constraints");
+		}
+	}
+
+	// add the 'excluded' dummy table binding
+	AddTableName("excluded");
+	// add a bind context entry for it
+	auto excluded_index = GenerateTableIndex();
+	insert.excluded_table_index = excluded_index;
+	auto table_column_names = columns.GetColumnNames();
+	auto table_column_types = columns.GetColumnTypes();
+	bind_context.AddGenericBinding(excluded_index, "excluded", table_column_names, table_column_types);
+
+	if (on_conflict.condition) {
+		// Avoid ambiguity between <table_name> binding and 'excluded'
+		QualifyColumnReferences(on_conflict.condition, table_alias);
+		// Bind the ON CONFLICT ... WHERE clause
+		WhereBinder where_binder(*this, context);
+		auto condition = where_binder.Bind(on_conflict.condition);
+		if (condition && condition->expression_class == ExpressionClass::BOUND_SUBQUERY) {
+			throw BinderException("conflict_target WHERE clause can not be a subquery");
+		}
+		insert.on_conflict_condition = std::move(condition);
+	}
+
+	auto projection_index = insert.children[0]->GetTableIndex()[0];
+
+	string unused;
+	auto original_binding = bind_context.GetBinding(table_alias, unused);
+	D_ASSERT(original_binding);
+
+	auto table_index = original_binding->index;
+
+	// Replace any column bindings to refer to the projection table_index, rather than the source table
+	if (insert.on_conflict_condition) {
+		ReplaceColumnBindings(*insert.on_conflict_condition, table_index, projection_index);
+	}
+
+	if (insert.action_type == OnConflictAction::NOTHING) {
+		if (!insert.on_conflict_condition) {
+			return;
+		}
+		// Get the column_ids we need to fetch later on from the conflicting tuples
+		// of the original table, to execute the expressions
+		D_ASSERT(original_binding->binding_type == BindingType::TABLE);
+		auto table_binding = (TableBinding *)original_binding;
+		insert.columns_to_fetch = table_binding->GetBoundColumnIds();
+		return;
+	}
+	if (insert.action_type == OnConflictAction::REPLACE) {
+		D_ASSERT(on_conflict.set_info == nullptr);
+		on_conflict.set_info = CreateSetInfoForReplace(table, stmt);
+		insert.action_type = OnConflictAction::UPDATE;
+	}
+
+	D_ASSERT(on_conflict.set_info);
+	auto &set_info = *on_conflict.set_info;
+	D_ASSERT(!set_info.columns.empty());
+	D_ASSERT(set_info.columns.size() == set_info.expressions.size());
+
+	if (set_info.condition) {
+		// Avoid ambiguity between <table_name> binding and 'excluded'
+		QualifyColumnReferences(set_info.condition, table_alias);
+		// Bind the SET ... WHERE clause
+		WhereBinder where_binder(*this, context);
+		auto condition = where_binder.Bind(set_info.condition);
+		if (condition && condition->expression_class == ExpressionClass::BOUND_SUBQUERY) {
+			throw BinderException("conflict_target WHERE clause can not be a subquery");
+		}
+		insert.do_update_condition = std::move(condition);
+	}
+
+	BindDoUpdateSetExpressions(table_alias, &insert, set_info, table);
+
+	// Get the column_ids we need to fetch later on from the conflicting tuples
+	// of the original table, to execute the expressions
+	D_ASSERT(original_binding->binding_type == BindingType::TABLE);
+	auto table_binding = (TableBinding *)original_binding;
+	insert.columns_to_fetch = table_binding->GetBoundColumnIds();
+
+	// Replace the column bindings to refer to the child operator
+	for (auto &expr : insert.expressions) {
+		// Change the non-excluded column references to refer to the projection index
+		ReplaceColumnBindings(*expr, table_index, projection_index);
+	}
+	// Do the same for the (optional) DO UPDATE condition
+	if (insert.do_update_condition) {
+		ReplaceColumnBindings(*insert.do_update_condition, table_index, projection_index);
+	}
+}
+
 BoundStatement Binder::Bind(InsertStatement &stmt) {
 	BoundStatement result;
 	result.names = {"Count"};
@@ -39,7 +381,6 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	}
 
 	auto insert = make_unique<LogicalInsert>(table, GenerateTableIndex());
-
 	// Add CTEs as bindable
 	AddCTEMap(stmt.cte_map);
 
@@ -55,14 +396,14 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 			if (column_index.index == COLUMN_IDENTIFIER_ROW_ID) {
 				throw BinderException("Cannot explicitly insert values into rowid column");
 			}
-			auto &col = table->columns.GetColumn(column_index);
+			auto &col = table->GetColumn(column_index);
 			if (col.Generated()) {
 				throw BinderException("Cannot insert into a generated column");
 			}
 			insert->expected_types.push_back(col.Type());
 			named_column_map.push_back(column_index);
 		}
-		for (auto &col : table->columns.Physical()) {
+		for (auto &col : table->GetColumns().Physical()) {
 			auto entry = column_name_map.find(col.Name());
 			if (entry == column_name_map.end()) {
 				// column not specified, set index to DConstants::INVALID_INDEX
@@ -73,21 +414,23 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 			}
 		}
 	} else {
-		for (auto &col : table->columns.Physical()) {
+		// No columns specified, assume insertion into all columns
+		// Intentionally don't populate 'column_index_map' as an indication of this
+		for (auto &col : table->GetColumns().Physical()) {
 			named_column_map.push_back(col.Logical());
 			insert->expected_types.push_back(col.Type());
 		}
 	}
 
 	// bind the default values
-	BindDefaultValues(table->columns, insert->bound_defaults);
+	BindDefaultValues(table->GetColumns(), insert->bound_defaults);
 	if (!stmt.select_statement) {
-		result.plan = move(insert);
+		result.plan = std::move(insert);
 		return result;
 	}
 
 	// Exclude the generated columns from this amount
-	idx_t expected_columns = stmt.columns.empty() ? table->columns.PhysicalColumnCount() : stmt.columns.size();
+	idx_t expected_columns = stmt.columns.empty() ? table->GetColumns().PhysicalColumnCount() : stmt.columns.size();
 
 	// special case: check if we are inserting from a VALUES statement
 	auto values_list = stmt.GetValuesList();
@@ -102,10 +445,11 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 
 		// VALUES list!
 		for (idx_t col_idx = 0; col_idx < expected_columns; col_idx++) {
-			auto table_col_idx = named_column_map[col_idx];
+			D_ASSERT(named_column_map.size() >= col_idx);
+			auto &table_col_idx = named_column_map[col_idx];
 
 			// set the expected types as the types for the INSERT statement
-			auto &column = table->columns.GetColumn(table_col_idx);
+			auto &column = table->GetColumn(table_col_idx);
 			expr_list.expected_types[col_idx] = column.Type();
 			expr_list.expected_names[col_idx] = column.Name();
 
@@ -113,11 +457,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 			for (idx_t list_idx = 0; list_idx < expr_list.values.size(); list_idx++) {
 				if (expr_list.values[list_idx][col_idx]->type == ExpressionType::VALUE_DEFAULT) {
 					// DEFAULT value! replace the entry
-					if (column.DefaultValue()) {
-						expr_list.values[list_idx][col_idx] = column.DefaultValue()->Copy();
-					} else {
-						expr_list.values[list_idx][col_idx] = make_unique<ConstantExpression>(Value(column.Type()));
-					}
+					ReplaceDefaultExpression(expr_list.values[list_idx][col_idx], column);
 				}
 			}
 		}
@@ -131,9 +471,10 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	CheckInsertColumnCountMismatch(expected_columns, root_select.types.size(), !stmt.columns.empty(),
 	                               table->name.c_str());
 
-	auto root = CastLogicalOperatorToTypes(root_select.types, insert->expected_types, move(root_select.plan));
+	auto root = CastLogicalOperatorToTypes(root_select.types, insert->expected_types, std::move(root_select.plan));
+	insert->AddChild(std::move(root));
 
-	insert->AddChild(move(root));
+	BindOnConflictClause(*insert, *table, stmt);
 
 	if (!stmt.returning_list.empty()) {
 		insert->return_chunk = true;
@@ -141,14 +482,14 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 		result.names.clear();
 		auto insert_table_index = GenerateTableIndex();
 		insert->table_index = insert_table_index;
-		unique_ptr<LogicalOperator> index_as_logicaloperator = move(insert);
+		unique_ptr<LogicalOperator> index_as_logicaloperator = std::move(insert);
 
-		return BindReturning(move(stmt.returning_list), table, insert_table_index, move(index_as_logicaloperator),
-		                     move(result));
+		return BindReturning(std::move(stmt.returning_list), table, insert_table_index,
+		                     std::move(index_as_logicaloperator), std::move(result));
 	}
 
 	D_ASSERT(result.types.size() == result.names.size());
-	result.plan = move(insert);
+	result.plan = std::move(insert);
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::CHANGED_ROWS;
 	return result;

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

@@ -10,7 +10,7 @@ BoundStatement Binder::Bind(LoadStatement &stmt) {
 	result.types = {LogicalType::BOOLEAN};
 	result.names = {"Success"};
 
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_LOAD, move(stmt.info));
+	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_LOAD, std::move(stmt.info));
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;

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

@@ -10,7 +10,7 @@ BoundStatement Binder::Bind(LogicalPlanStatement &stmt) {
 	for (idx_t i = 0; i < result.types.size(); i++) {
 		result.names.push_back(StringUtil::Format("col%d", i));
 	}
-	result.plan = move(stmt.plan);
+	result.plan = std::move(stmt.plan);
 	properties.allow_stream_result = true;
 	properties.return_type = StatementReturnType::QUERY_RESULT; // TODO could also be something else
 

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

@@ -7,10 +7,10 @@ namespace duckdb {
 
 BoundStatement Binder::Bind(PrepareStatement &stmt) {
 	Planner prepared_planner(context);
-	auto prepared_data = prepared_planner.PrepareSQLStatement(move(stmt.statement));
+	auto prepared_data = prepared_planner.PrepareSQLStatement(std::move(stmt.statement));
 	this->bound_tables = prepared_planner.binder->bound_tables;
 
-	auto prepare = make_unique<LogicalPrepare>(stmt.name, move(prepared_data), move(prepared_planner.plan));
+	auto prepare = make_unique<LogicalPrepare>(stmt.name, std::move(prepared_data), std::move(prepared_planner.plan));
 	// we can always prepare, even if the transaction has been invalidated
 	// this is required because most clients ALWAYS invoke prepared statements
 	properties.requires_valid_transaction = false;
@@ -22,7 +22,7 @@ BoundStatement Binder::Bind(PrepareStatement &stmt) {
 	BoundStatement result;
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
-	result.plan = move(prepare);
+	result.plan = std::move(prepare);
 	return result;
 }
 

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

@@ -14,11 +14,11 @@ BoundStatement Binder::Bind(ShowStatement &stmt) {
 	stmt.info->types = plan.types;
 	stmt.info->aliases = plan.names;
 
-	auto show = make_unique<LogicalShow>(move(plan.plan));
+	auto show = make_unique<LogicalShow>(std::move(plan.plan));
 	show->types_select = plan.types;
 	show->aliases = plan.names;
 
-	result.plan = move(show);
+	result.plan = std::move(show);
 
 	result.names = {"column_name", "column_type", "null", "key", "default", "extra"};
 	result.types = {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR,