duckdb 1.3.4 → 1.4.1-dev2.0

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

@@ -1,7 +1,10 @@
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/parser/expression/comparison_expression.hpp"
+#include "duckdb/parser/expression/conjunction_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/statement/insert_statement.hpp"
+#include "duckdb/parser/statement/merge_into_statement.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/tableref/expressionlistref.hpp"
 #include "duckdb/planner/binder.hpp"
@@ -25,11 +28,13 @@
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/storage/table_storage_info.hpp"
 #include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/parser/tableref/emptytableref.hpp"
+#include "duckdb/parser/tableref/subqueryref.hpp"
 
 namespace duckdb {
 
-static void CheckInsertColumnCountMismatch(idx_t expected_columns, idx_t result_columns, bool columns_provided,
-                                           const char *tname) {
+void Binder::CheckInsertColumnCountMismatch(idx_t expected_columns, idx_t result_columns, bool columns_provided,
+                                            const string &tname) {
 	if (result_columns != expected_columns) {
 		string msg = StringUtil::Format(!columns_provided ? "table %s has %lld columns but %lld values were supplied"
 		                                                  : "Column name/value mismatch for insert on %s: "
@@ -47,13 +52,53 @@ unique_ptr<ParsedExpression> ExpandDefaultExpression(const ColumnDefinition &col
 	}
 }
 
-void ReplaceDefaultExpression(unique_ptr<ParsedExpression> &expr, const ColumnDefinition &column) {
-	D_ASSERT(expr->GetExpressionType() == ExpressionType::VALUE_DEFAULT);
+void Binder::TryReplaceDefaultExpression(unique_ptr<ParsedExpression> &expr, const ColumnDefinition &column) {
+	if (expr->GetExpressionType() != ExpressionType::VALUE_DEFAULT) {
+		return;
+	}
 	expr = ExpandDefaultExpression(column);
 }
 
-void ExpressionBinder::DoUpdateSetQualifyInLambda(FunctionExpression &function, const string &table_name,
-                                                  vector<unordered_set<string>> &lambda_params) {
+void Binder::ExpandDefaultInValuesList(InsertStatement &stmt, TableCatalogEntry &table,
+                                       optional_ptr<ExpressionListRef> values_list,
+                                       const vector<LogicalIndex> &named_column_map) {
+	if (!values_list) {
+		return;
+	}
+	idx_t expected_columns = stmt.columns.empty() ? table.GetColumns().PhysicalColumnCount() : stmt.columns.size();
+
+	// special case: check if we are inserting from a VALUES statement
+	if (values_list) {
+		auto &expr_list = values_list->Cast<ExpressionListRef>();
+		expr_list.expected_types.resize(expected_columns);
+		expr_list.expected_names.resize(expected_columns);
+
+		D_ASSERT(!expr_list.values.empty());
+		CheckInsertColumnCountMismatch(expected_columns, expr_list.values[0].size(), !stmt.columns.empty(), table.name);
+
+		// VALUES list!
+		for (idx_t col_idx = 0; col_idx < expected_columns; 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.GetColumn(table_col_idx);
+			expr_list.expected_types[col_idx] = column.Type();
+			expr_list.expected_names[col_idx] = column.Name();
+
+			// now replace any DEFAULT values with the corresponding default expression
+			for (idx_t list_idx = 0; list_idx < expr_list.values.size(); list_idx++) {
+				TryReplaceDefaultExpression(expr_list.values[list_idx][col_idx], column);
+			}
+		}
+	}
+}
+
+void DoUpdateSetQualify(unique_ptr<ParsedExpression> &expr, const string &table_name,
+                        vector<unordered_set<string>> &lambda_params);
+
+void DoUpdateSetQualifyInLambda(FunctionExpression &function, const string &table_name,
+                                vector<unordered_set<string>> &lambda_params) {
 
 	for (auto &child : function.children) {
 		if (child->GetExpressionClass() != ExpressionClass::LAMBDA) {
@@ -94,8 +139,8 @@ void ExpressionBinder::DoUpdateSetQualifyInLambda(FunctionExpression &function,
 	}
 }
 
-void ExpressionBinder::DoUpdateSetQualify(unique_ptr<ParsedExpression> &expr, const string &table_name,
-                                          vector<unordered_set<string>> &lambda_params) {
+void DoUpdateSetQualify(unique_ptr<ParsedExpression> &expr, const string &table_name,
+                        vector<unordered_set<string>> &lambda_params) {
 
 	// We avoid ambiguity with EXCLUDED columns by qualifying all column references.
 	switch (expr->GetExpressionClass()) {
@@ -133,85 +178,6 @@ void ExpressionBinder::DoUpdateSetQualify(unique_ptr<ParsedExpression> &expr, co
 	    *expr, [&](unique_ptr<ParsedExpression> &child) { DoUpdateSetQualify(child, table_name, lambda_params); });
 }
 
-// Replace binding.table_index with 'dest' if it's 'source'
-void ReplaceColumnBindings(Expression &expr, idx_t source, idx_t dest) {
-	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_columnref = expr.Cast<BoundColumnRefExpression>();
-		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, TableStorageInfo &storage_info) {
-	D_ASSERT(insert.children.size() == 1);
-
-	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);
-		}
-
-		if (!column.Type().SupportsRegularUpdate()) {
-			insert.update_is_del_and_insert = true;
-		}
-
-		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->GetExpressionType() == ExpressionType::VALUE_DEFAULT) {
-			expr = ExpandDefaultExpression(column);
-		}
-
-		// Qualify and bind the ON CONFLICT DO UPDATE SET expression.
-		UpdateBinder update_binder(*this, context);
-		update_binder.target_type = column.Type();
-
-		// Avoid ambiguity between existing table columns and EXCLUDED columns.
-		vector<unordered_set<string>> lambda_params;
-		update_binder.DoUpdateSetQualify(expr, table_alias, lambda_params);
-
-		auto bound_expr = update_binder.Bind(expr);
-		D_ASSERT(bound_expr);
-		insert.expressions.push_back(std::move(bound_expr));
-	}
-
-	// Figure out which columns are indexed on
-	unordered_set<column_t> indexed_columns;
-	for (auto &index : storage_info.index_info) {
-		for (auto &column_id : index.column_set) {
-			indexed_columns.insert(column_id);
-		}
-	}
-
-	// If any column targeted by a SET expression has an index, then
-	// we need to rewrite this to an DELETE + INSERT.
-	for (idx_t i = 0; i < logical_column_ids.size(); i++) {
-		auto &column = logical_column_ids[i];
-		if (indexed_columns.count(column)) {
-			insert.update_is_del_and_insert = true;
-			break;
-		}
-	}
-}
-
 unique_ptr<UpdateSetInfo> CreateSetInfoForReplace(TableCatalogEntry &table, InsertStatement &insert,
                                                   TableStorageInfo &storage_info) {
 	auto set_info = make_uniq<UpdateSetInfo>();
@@ -255,47 +221,129 @@ unique_ptr<UpdateSetInfo> CreateSetInfoForReplace(TableCatalogEntry &table, Inse
 	return set_info;
 }
 
-vector<column_t> GetColumnsToFetch(const TableBinding &binding) {
-	auto &bound_columns = binding.GetBoundColumnIds();
-	vector<column_t> result;
-	for (auto &col : bound_columns) {
-		result.push_back(col.GetPrimaryIndex());
-	}
-	return result;
-}
-
-void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &table, InsertStatement &stmt) {
-	if (!stmt.on_conflict_info) {
-		insert.action_type = OnConflictAction::THROW;
-		return;
-	}
-	D_ASSERT(stmt.table_ref->type == TableReferenceType::BASE_TABLE);
+void Binder::BindInsertColumnList(TableCatalogEntry &table, vector<string> &columns, bool default_values,
+                                  vector<LogicalIndex> &named_column_map, vector<LogicalType> &expected_types,
+                                  IndexVector<idx_t, PhysicalIndex> &column_index_map) {
+	if (!columns.empty() || default_values) {
+		// insertion statement specifies column list
 
-	// 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!");
+		// create a mapping of (list index) -> (column index)
+		case_insensitive_map_t<idx_t> column_name_map;
+		for (idx_t i = 0; i < columns.size(); i++) {
+			auto entry = column_name_map.insert(make_pair(columns[i], i));
+			if (!entry.second) {
+				throw BinderException("Duplicate column name \"%s\" in INSERT", columns[i]);
+			}
+			auto column_index = table.GetColumnIndex(columns[i]);
+			if (column_index.index == COLUMN_IDENTIFIER_ROW_ID) {
+				throw BinderException("Cannot explicitly insert values into rowid column");
+			}
+			auto &col = table.GetColumn(column_index);
+			if (col.Generated()) {
+				throw BinderException("Cannot insert into a generated column");
+			}
+			expected_types.push_back(col.Type());
+			named_column_map.push_back(column_index);
+		}
+		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
+				column_index_map.push_back(DConstants::INVALID_INDEX);
+			} else {
+				// column was specified, set to the index
+				column_index_map.push_back(entry->second);
+			}
+		}
+	} else {
+		// insert by position and no columns specified - insertion into all columns of the table
+		// 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());
+			expected_types.push_back(col.Type());
+		}
 	}
+}
 
-	auto &table_ref = stmt.table_ref->Cast<BaseTableRef>();
-	const string &table_alias = !table_ref.alias.empty() ? table_ref.alias : table_ref.table_name;
+unique_ptr<MergeIntoStatement> Binder::GenerateMergeInto(InsertStatement &stmt, TableCatalogEntry &table) {
+	D_ASSERT(stmt.on_conflict_info);
 
-	auto &on_conflict = *stmt.on_conflict_info;
-	D_ASSERT(on_conflict.action_type != OnConflictAction::THROW);
-	insert.action_type = on_conflict.action_type;
+	auto &on_conflict_info = *stmt.on_conflict_info;
+	auto merge_into = make_uniq<MergeIntoStatement>();
+	// set up the target table
+	string table_name = !stmt.table_ref->alias.empty() ? stmt.table_ref->alias : stmt.table;
+	merge_into->target = std::move(stmt.table_ref);
 
-	// obtain the table storage info
 	auto storage_info = table.GetStorageInfo(context);
-
 	auto &columns = table.GetColumns();
-	if (!on_conflict.indexed_columns.empty()) {
-		// Bind the ON CONFLICT (<columns>)
+	// set up the columns on which to join
+	vector<string> distinct_on_columns;
+	if (on_conflict_info.indexed_columns.empty()) {
+		// When omitting the conflict target, we derive the join columns from the primary key/unique constraints
+		// traverse the primary key/unique constraints
 
-		// create a mapping of (list index) -> (column index)
+		vector<unique_ptr<ParsedExpression>> join_conditions;
+		// We check if there are any constraints on the table, if there aren't we throw an error.
+		idx_t found_matching_indexes = 0;
+		for (auto &index : storage_info.index_info) {
+			if (!index.is_unique) {
+				continue;
+			}
+
+			vector<unique_ptr<ParsedExpression>> and_children;
+			auto &indexed_columns = index.column_set;
+			for (auto &column : columns.Physical()) {
+				if (!indexed_columns.count(column.Physical().index)) {
+					continue;
+				}
+				auto lhs = make_uniq<ColumnRefExpression>(column.Name(), table_name);
+				auto rhs = make_uniq<ColumnRefExpression>(column.Name(), "excluded");
+				auto new_condition =
+				    make_uniq<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, std::move(lhs), std::move(rhs));
+				and_children.push_back(std::move(new_condition));
+				distinct_on_columns.push_back(column.Name());
+			}
+			if (and_children.empty()) {
+				continue;
+			}
+			unique_ptr<ParsedExpression> condition;
+			if (and_children.size() == 1) {
+				condition = std::move(and_children[0]);
+			} else {
+				// AND together
+				condition = make_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(and_children));
+			}
+			join_conditions.push_back(std::move(condition));
+			found_matching_indexes++;
+		}
+		unique_ptr<ParsedExpression> join_condition;
+		if (join_conditions.size() == 1) {
+			join_condition = std::move(join_conditions[0]);
+		} else {
+			// OR together
+			join_condition =
+			    make_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_OR, std::move(join_conditions));
+		}
+		merge_into->join_condition = std::move(join_condition);
+
+		if (!found_matching_indexes) {
+			throw BinderException("There are no UNIQUE/PRIMARY KEY constraints that refer to this table, specify ON "
+			                      "CONFLICT columns manually");
+		} else if (found_matching_indexes != 1) {
+			if (on_conflict_info.action_type != OnConflictAction::NOTHING) {
+				// 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");
+			}
+		}
+	} else {
+		// when on conflict columns are explicitly provided - use them directly
+		// first figure out if there is an index on the columns or not
 		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]);
+		for (idx_t i = 0; i < on_conflict_info.indexed_columns.size(); i++) {
+			specified_columns[on_conflict_info.indexed_columns[i]] = i;
+			auto column_index = table.GetColumnIndex(on_conflict_info.indexed_columns[i]);
 			if (column_index.index == COLUMN_IDENTIFIER_ROW_ID) {
 				throw BinderException("Cannot specify ROWID as ON CONFLICT target");
 			}
@@ -304,11 +352,12 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 				throw BinderException("Cannot specify a generated column as ON CONFLICT target");
 			}
 		}
+		unordered_set<column_t> on_conflict_filter;
 		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.Physical().index);
+				on_conflict_filter.insert(col.Physical().index);
 			}
 		}
 		bool index_references_columns = false;
@@ -316,7 +365,7 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 			if (!index.is_unique) {
 				continue;
 			}
-			bool index_matches = insert.on_conflict_filter == index.column_set;
+			bool index_matches = on_conflict_filter == index.column_set;
 			if (index_matches) {
 				index_references_columns = true;
 				break;
@@ -328,150 +377,127 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 			throw BinderException("The specified columns as conflict target are not referenced by a UNIQUE/PRIMARY KEY "
 			                      "CONSTRAINT or INDEX");
 		}
-	} else {
-		// When omitting the conflict target, the ON CONFLICT applies to every UNIQUE/PRIMARY KEY on the table
+		distinct_on_columns = on_conflict_info.indexed_columns;
+		merge_into->using_columns = std::move(on_conflict_info.indexed_columns);
+	}
 
-		// We check if there are any constraints on the table, if there aren't we throw an error.
-		idx_t found_matching_indexes = 0;
-		for (auto &index : storage_info.index_info) {
-			if (!index.is_unique) {
-				continue;
+	// expand any default values
+	auto values_list = stmt.GetValuesList();
+	if (values_list) {
+		vector<LogicalIndex> named_column_map;
+		if (stmt.columns.empty()) {
+			for (auto &col : table.GetColumns().Physical()) {
+				named_column_map.push_back(col.Logical());
 			}
-			auto &indexed_columns = index.column_set;
-			bool matches = false;
-			for (auto &column : table.GetColumns().Physical()) {
-				if (indexed_columns.count(column.Physical().index)) {
-					matches = true;
-					break;
-				}
+		} else {
+			for (auto &col_name : stmt.columns) {
+				auto &col = table.GetColumn(col_name);
+				named_column_map.push_back(col.Logical());
 			}
-			found_matching_indexes += matches;
 		}
-
-		if (!found_matching_indexes) {
-			throw BinderException(
-			    "There are no UNIQUE/PRIMARY KEY Indexes that refer to this table, ON CONFLICT is a no-op");
-		} else if (found_matching_indexes != 1) {
-			if (insert.action_type != OnConflictAction::NOTHING) {
-				// 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;
-	vector<string> table_column_names;
-	vector<LogicalType> table_column_types;
-	for (auto &col : columns.Physical()) {
-		table_column_names.push_back(col.Name());
-		table_column_types.push_back(col.Type());
+		ExpandDefaultInValuesList(stmt, table, values_list, named_column_map);
 	}
-	bind_context.AddGenericBinding(excluded_index, "excluded", table_column_names, table_column_types);
-
-	if (on_conflict.condition) {
-		WhereBinder where_binder(*this, context);
-
-		// Avoid ambiguity between existing table columns and EXCLUDED columns.
-		vector<unordered_set<string>> lambda_params;
-		where_binder.DoUpdateSetQualify(on_conflict.condition, table_alias, lambda_params);
+	// set up the data source
+	unique_ptr<TableRef> source;
+	if (stmt.select_statement) {
+		source = make_uniq<SubqueryRef>(std::move(stmt.select_statement), "excluded");
+	} else {
+		source = make_uniq<EmptyTableRef>();
+	}
+	if (stmt.column_order == InsertColumnOrder::INSERT_BY_POSITION) {
+		// if we are inserting by position add the columns of the target table as an alias to the source
+		if (!stmt.columns.empty() || stmt.default_values) {
+			// we are not emitting all columns - set the column set as the set of aliases
+			source->column_name_alias = stmt.columns;
+
+			// now push another subquery that adds the default columns
+			auto select_stmt = make_uniq<SelectStatement>();
+			auto select_node = make_uniq<SelectNode>();
+			unordered_set<string> set_columns;
+			for (auto &set_col : stmt.columns) {
+				set_columns.insert(set_col);
+			}
 
-		// Bind the ON CONFLICT ... WHERE clause.
-		auto condition = where_binder.Bind(on_conflict.condition);
-		insert.on_conflict_condition = std::move(condition);
-	}
+			for (auto &column : columns.Physical()) {
+				auto &name = column.Name();
+				unique_ptr<ParsedExpression> expr;
+				if (set_columns.find(name) == set_columns.end()) {
+					// column is not specified - at the default value
+					if (column.HasDefaultValue()) {
+						expr = column.DefaultValue().Copy();
+					} else {
+						expr = make_uniq<ConstantExpression>(Value(column.Type()));
+					}
+				} else {
+					// column is specified - add a reference to it
+					expr = make_uniq<ColumnRefExpression>(name);
+				}
+				select_node->select_list.push_back(std::move(expr));
+			}
+			select_node->from_table = std::move(source);
+			select_stmt->node = std::move(select_node);
 
-	optional_idx projection_index;
-	reference<vector<unique_ptr<LogicalOperator>>> insert_child_operators = insert.children;
-	while (!projection_index.IsValid()) {
-		if (insert_child_operators.get().empty()) {
-			// No further children to visit
-			break;
+			source = make_uniq<SubqueryRef>(std::move(select_stmt), "excluded");
 		}
-		auto &current_child = insert_child_operators.get()[0];
-		auto table_indices = current_child->GetTableIndex();
-		if (table_indices.empty()) {
-			// This operator does not have a table index to refer to, we have to visit its children
-			insert_child_operators = current_child->children;
-			continue;
+		// push all columns of the table as an alias
+		for (auto &column : columns.Physical()) {
+			source->column_name_alias.push_back(column.Name());
 		}
-		projection_index = table_indices[0];
 	}
-	if (!projection_index.IsValid()) {
-		throw InternalException("Could not locate a table_index from the children of the insert");
+	// push DISTINCT ON(unique_columns)
+	auto distinct_stmt = make_uniq<SelectStatement>();
+	auto select_node = make_uniq<SelectNode>();
+	auto distinct = make_uniq<DistinctModifier>();
+	for (auto &col : distinct_on_columns) {
+		distinct->distinct_on_targets.push_back(make_uniq<ColumnRefExpression>(col));
 	}
+	select_node->modifiers.push_back(std::move(distinct));
+	select_node->select_list.push_back(make_uniq<StarExpression>());
+	select_node->from_table = std::move(source);
+	distinct_stmt->node = std::move(select_node);
+	source = make_uniq<SubqueryRef>(std::move(distinct_stmt), "excluded");
 
-	ErrorData unused;
-	auto original_binding = bind_context.GetBinding(table_alias, unused);
-	D_ASSERT(original_binding && !unused.HasError());
-
-	auto table_index = original_binding->index;
+	merge_into->source = std::move(source);
 
-	// 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.GetIndex());
+	if (on_conflict_info.action_type == OnConflictAction::REPLACE) {
+		D_ASSERT(!on_conflict_info.set_info);
+		on_conflict_info.set_info = CreateSetInfoForReplace(table, stmt, storage_info);
+		on_conflict_info.action_type = OnConflictAction::UPDATE;
 	}
+	// now set up the merge actions
+	// first set up the base (insert) action when not matched
+	auto insert_action = make_uniq<MergeIntoAction>();
+	insert_action->action_type = MergeActionType::MERGE_INSERT;
+	insert_action->column_order = stmt.column_order;
 
-	if (insert.action_type == OnConflictAction::REPLACE) {
-		D_ASSERT(on_conflict.set_info == nullptr);
-		on_conflict.set_info = CreateSetInfoForReplace(table, stmt, storage_info);
-		insert.action_type = OnConflictAction::UPDATE;
-	}
-	if (on_conflict.set_info && on_conflict.set_info->columns.empty()) {
-		// if we are doing INSERT OR REPLACE on a table with no columns outside of the primary key column
-		// convert to INSERT OR IGNORE
-		insert.action_type = OnConflictAction::NOTHING;
+	merge_into->actions[MergeActionCondition::WHEN_NOT_MATCHED_BY_TARGET].push_back(std::move(insert_action));
+
+	if (on_conflict_info.condition) {
+		throw BinderException("ON CONFLICT WHERE clause is only supported in DO UPDATE SET ... WHERE ...\nThe WHERE "
+		                      "clause after the conflict columns is used for partial indexes which are not supported.");
 	}
-	if (insert.action_type == OnConflictAction::NOTHING) {
-		if (!insert.on_conflict_condition) {
-			return;
+	if (on_conflict_info.action_type == OnConflictAction::UPDATE) {
+		// when doing UPDATE set up the when matched action
+		auto update_action = make_uniq<MergeIntoAction>();
+		update_action->action_type = MergeActionType::MERGE_UPDATE;
+		for (auto &col : on_conflict_info.set_info->expressions) {
+			vector<unordered_set<string>> lambda_params;
+			DoUpdateSetQualify(col, table_name, lambda_params);
 		}
-		// 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 = original_binding->Cast<TableBinding>();
-		insert.columns_to_fetch = GetColumnsToFetch(table_binding);
-		return;
-	}
-
-	D_ASSERT(on_conflict.set_info);
-	auto &set_info = *on_conflict.set_info;
-	D_ASSERT(set_info.columns.size() == set_info.expressions.size());
-
-	if (set_info.condition) {
-		WhereBinder where_binder(*this, context);
-
-		// Avoid ambiguity between existing table columns and EXCLUDED columns.
-		vector<unordered_set<string>> lambda_params;
-		where_binder.DoUpdateSetQualify(set_info.condition, table_alias, lambda_params);
+		if (on_conflict_info.set_info->condition) {
+			vector<unordered_set<string>> lambda_params;
+			DoUpdateSetQualify(on_conflict_info.set_info->condition, table_name, lambda_params);
+			update_action->condition = std::move(on_conflict_info.set_info->condition);
+		}
+		update_action->update_info = std::move(on_conflict_info.set_info);
 
-		// Bind the SET ... WHERE clause.
-		auto condition = where_binder.Bind(set_info.condition);
-		insert.do_update_condition = std::move(condition);
+		merge_into->actions[MergeActionCondition::WHEN_MATCHED].push_back(std::move(update_action));
 	}
 
-	BindDoUpdateSetExpressions(table_alias, insert, set_info, table, storage_info);
-
-	// 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 = original_binding->Cast<TableBinding>();
-	insert.columns_to_fetch = GetColumnsToFetch(table_binding);
-
-	// 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.GetIndex());
-	}
-	// Do the same for the (optional) DO UPDATE condition
-	if (insert.do_update_condition) {
-		ReplaceColumnBindings(*insert.do_update_condition, table_index, projection_index.GetIndex());
-	}
+	// move over extra properties
+	merge_into->cte_map = std::move(stmt.cte_map);
+	merge_into->returning_list = std::move(stmt.returning_list);
+	return merge_into;
 }
 
 BoundStatement Binder::Bind(InsertStatement &stmt) {
@@ -481,6 +507,11 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 
 	BindSchemaOrCatalog(stmt.catalog, stmt.schema);
 	auto &table = Catalog::GetEntry<TableCatalogEntry>(context, stmt.catalog, stmt.schema, stmt.table);
+	if (stmt.on_conflict_info) {
+		// generate a MERGE INTO statement and bind it instead
+		auto merge_into = GenerateMergeInto(stmt, table);
+		return Bind(*merge_into);
+	}
 	if (!table.temporary) {
 		// inserting into a non-temporary table: alters underlying database
 		auto &properties = GetStatementProperties();
@@ -515,45 +546,8 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	}
 
 	vector<LogicalIndex> named_column_map;
-	if (!stmt.columns.empty() || stmt.default_values) {
-		// insertion statement specifies column list
-
-		// create a mapping of (list index) -> (column index)
-		case_insensitive_map_t<idx_t> column_name_map;
-		for (idx_t i = 0; i < stmt.columns.size(); i++) {
-			auto entry = column_name_map.insert(make_pair(stmt.columns[i], i));
-			if (!entry.second) {
-				throw BinderException("Duplicate column name \"%s\" in INSERT", stmt.columns[i]);
-			}
-			auto column_index = table.GetColumnIndex(stmt.columns[i]);
-			if (column_index.index == COLUMN_IDENTIFIER_ROW_ID) {
-				throw BinderException("Cannot explicitly insert values into rowid column");
-			}
-			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.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
-				insert->column_index_map.push_back(DConstants::INVALID_INDEX);
-			} else {
-				// column was specified, set to the index
-				insert->column_index_map.push_back(entry->second);
-			}
-		}
-	} else {
-		// insert by position and no columns specified - insertion into all columns of the table
-		// 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());
-		}
-	}
+	BindInsertColumnList(table, stmt.columns, stmt.default_values, named_column_map, insert->expected_types,
+	                     insert->column_index_map);
 
 	// bind the default values
 	auto &catalog_name = table.ParentCatalog().GetName();
@@ -566,36 +560,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	}
 	// Exclude the generated columns from this amount
 	idx_t expected_columns = stmt.columns.empty() ? table.GetColumns().PhysicalColumnCount() : stmt.columns.size();
-
-	// special case: check if we are inserting from a VALUES statement
-	if (values_list) {
-		auto &expr_list = values_list->Cast<ExpressionListRef>();
-		expr_list.expected_types.resize(expected_columns);
-		expr_list.expected_names.resize(expected_columns);
-
-		D_ASSERT(!expr_list.values.empty());
-		CheckInsertColumnCountMismatch(expected_columns, expr_list.values[0].size(), !stmt.columns.empty(),
-		                               table.name.c_str());
-
-		// VALUES list!
-		for (idx_t col_idx = 0; col_idx < expected_columns; 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.GetColumn(table_col_idx);
-			expr_list.expected_types[col_idx] = column.Type();
-			expr_list.expected_names[col_idx] = column.Name();
-
-			// now replace any DEFAULT values with the corresponding default expression
-			for (idx_t list_idx = 0; list_idx < expr_list.values.size(); list_idx++) {
-				if (expr_list.values[list_idx][col_idx]->GetExpressionType() == ExpressionType::VALUE_DEFAULT) {
-					// DEFAULT value! replace the entry
-					ReplaceDefaultExpression(expr_list.values[list_idx][col_idx], column);
-				}
-			}
-		}
-	}
+	ExpandDefaultInValuesList(stmt, table, values_list, named_column_map);
 
 	// parse select statement and add to logical plan
 	unique_ptr<LogicalOperator> root;
@@ -606,27 +571,22 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 			MoveCorrelatedExpressions(*select_binder);
 		}
 		// inserting from a select - check if the column count matches
-		CheckInsertColumnCountMismatch(expected_columns, root_select.types.size(), !stmt.columns.empty(),
-		                               table.name.c_str());
+		CheckInsertColumnCountMismatch(expected_columns, root_select.types.size(), !stmt.columns.empty(), table.name);
 
 		root = CastLogicalOperatorToTypes(root_select.types, insert->expected_types, std::move(root_select.plan));
 	} else {
 		root = make_uniq<LogicalDummyScan>(GenerateTableIndex());
 	}
-	insert->AddChild(std::move(root));
-
-	BindOnConflictClause(*insert, table, stmt);
 
+	insert->AddChild(std::move(root));
 	if (!stmt.returning_list.empty()) {
 		insert->return_chunk = true;
-		result.types.clear();
-		result.names.clear();
 		auto insert_table_index = GenerateTableIndex();
 		insert->table_index = insert_table_index;
 		unique_ptr<LogicalOperator> index_as_logicaloperator = std::move(insert);
 
 		return BindReturning(std::move(stmt.returning_list), table, stmt.table_ref ? stmt.table_ref->alias : string(),
-		                     insert_table_index, std::move(index_as_logicaloperator), std::move(result));
+		                     insert_table_index, std::move(index_as_logicaloperator));
 	}
 
 	D_ASSERT(result.types.size() == result.names.size());