duckdb 0.7.1-dev7.0 → 0.7.1

package/src/duckdb/src/main/settings/settings.cpp

@@ -531,6 +531,22 @@ Value ExplainOutputSetting::GetSetting(ClientContext &context) {
 	}
 }
 
+//===--------------------------------------------------------------------===//
+// Extension Directory Setting
+//===--------------------------------------------------------------------===//
+void ExtensionDirectorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
+	auto new_directory = input.ToString();
+	config.options.extension_directory = input.ToString();
+}
+
+void ExtensionDirectorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.extension_directory = DBConfig().options.extension_directory;
+}
+
+Value ExtensionDirectorySetting::GetSetting(ClientContext &context) {
+	return Value(DBConfig::GetConfig(context).options.extension_directory);
+}
+
 //===--------------------------------------------------------------------===//
 // External Threads Setting
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/optimizer/statistics/operator/propagate_join.cpp

@@ -83,12 +83,8 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 						*node_ptr = std::move(cross_product);
 						return;
 					}
-					case JoinType::INNER:
-					case JoinType::LEFT:
-					case JoinType::RIGHT:
-					case JoinType::OUTER: {
-						// inner/left/right/full outer join, replace with cross product
-						// since the condition is always true, left/right/outer join are equivalent to inner join here
+					case JoinType::INNER: {
+						// inner, replace with cross product
 						auto cross_product =
 						    LogicalCrossProduct::Create(std::move(join.children[0]), std::move(join.children[1]));
 						*node_ptr = std::move(cross_product);

package/src/duckdb/src/parallel/pipeline_executor.cpp

@@ -114,52 +114,6 @@ OperatorResultType PipelineExecutor::ExecutePushInternal(DataChunk &input, idx_t
 	}
 }
 
-// Pull a single DataChunk from the pipeline by flushing any operators holding cached output
-void PipelineExecutor::FlushCachingOperatorsPull(DataChunk &result) {
-	idx_t start_idx = IsFinished() ? idx_t(finished_processing_idx) : 0;
-	idx_t op_idx = start_idx;
-	while (op_idx < pipeline.operators.size()) {
-		if (!pipeline.operators[op_idx]->RequiresFinalExecute()) {
-			op_idx++;
-			continue;
-		}
-
-		OperatorFinalizeResultType finalize_result;
-		DataChunk &curr_chunk =
-		    op_idx + 1 >= intermediate_chunks.size() ? final_chunk : *intermediate_chunks[op_idx + 1];
-
-		if (pending_final_execute) {
-			// Still have a cached chunk from a last pull, reuse chunk
-			finalize_result = cached_final_execute_result;
-		} else {
-			// Flush the current operator
-			auto current_operator = pipeline.operators[op_idx];
-			StartOperator(current_operator);
-			finalize_result = current_operator->FinalExecute(context, curr_chunk, *current_operator->op_state,
-			                                                 *intermediate_states[op_idx]);
-			EndOperator(current_operator, &curr_chunk);
-		}
-
-		auto execute_result = Execute(curr_chunk, result, op_idx + 1);
-
-		if (execute_result == OperatorResultType::HAVE_MORE_OUTPUT) {
-			pending_final_execute = true;
-			cached_final_execute_result = finalize_result;
-		} else {
-			pending_final_execute = false;
-			if (finalize_result == OperatorFinalizeResultType::FINISHED) {
-				FinishProcessing(op_idx);
-				op_idx++;
-			}
-		}
-
-		// Some non-empty result was pulled from some caching operator, we're done for this pull
-		if (result.size() > 0) {
-			break;
-		}
-	}
-}
-
 // Push all remaining cached operator output through the pipeline
 void PipelineExecutor::FlushCachingOperatorsPush() {
 	idx_t start_idx = IsFinished() ? idx_t(finished_processing_idx) : 0;
@@ -223,21 +177,13 @@ void PipelineExecutor::ExecutePull(DataChunk &result) {
 		D_ASSERT(!pipeline.sink);
 		auto &source_chunk = pipeline.operators.empty() ? result : *intermediate_chunks[0];
 		while (result.size() == 0) {
-			if (source_empty) {
-				FlushCachingOperatorsPull(result);
-				break;
-			}
-
 			if (in_process_operators.empty()) {
 				source_chunk.Reset();
 				FetchFromSource(source_chunk);
-
 				if (source_chunk.size() == 0) {
-					source_empty = true;
-					continue;
+					break;
 				}
 			}
-
 			if (!pipeline.operators.empty()) {
 				auto state = Execute(source_chunk, result);
 				if (state == OperatorResultType::FINISHED) {

package/src/duckdb/src/parser/parsed_data/create_index_info.cpp

@@ -16,6 +16,9 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 	for (auto &expr : expressions) {
 		result->expressions.push_back(expr->Copy());
 	}
+	for (auto &expr : parsed_expressions) {
+		result->parsed_expressions.push_back(expr->Copy());
+	}
 
 	result->scan_types = scan_types;
 	result->names = names;

package/src/duckdb/src/parser/statement/copy_statement.cpp

@@ -11,16 +11,6 @@ CopyStatement::CopyStatement(const CopyStatement &other) : SQLStatement(other),
 	}
 }
 
-string ConvertOptionValueToString(const Value &val) {
-	auto type = val.type().id();
-	switch (type) {
-	case LogicalTypeId::VARCHAR:
-		return KeywordHelper::WriteOptionallyQuoted(val.ToString());
-	default:
-		return val.ToString();
-	}
-}
-
 string CopyStatement::CopyOptionsToString(const string &format,
                                           const case_insensitive_map_t<vector<Value>> &options) const {
 	if (format.empty() && options.empty()) {
@@ -45,15 +35,14 @@ string CopyStatement::CopyOptionsToString(const string &format,
 			// Options like HEADER don't need an explicit value
 			// just providing the name already sets it to true
 		} else if (values.size() == 1) {
-			result += ConvertOptionValueToString(values[0]);
+			result += values[0].ToSQLString();
 		} else {
 			result += "( ";
 			for (idx_t i = 0; i < values.size(); i++) {
-				auto &value = values[i];
 				if (i) {
 					result += ", ";
 				}
-				result += KeywordHelper::WriteOptionallyQuoted(value.ToString());
+				result += values[i].ToSQLString();
 			}
 			result += " )";
 		}

package/src/duckdb/src/parser/statement/delete_statement.cpp

@@ -13,6 +13,9 @@ DeleteStatement::DeleteStatement(const DeleteStatement &other) : SQLStatement(ot
 	for (const auto &using_clause : other.using_clauses) {
 		using_clauses.push_back(using_clause->Copy());
 	}
+	for (auto &expr : other.returning_list) {
+		returning_list.emplace_back(expr->Copy());
+	}
 	cte_map = other.cte_map.Copy();
 }
 

package/src/duckdb/src/parser/statement/detach_statement.cpp

@@ -0,0 +1,15 @@
+#include "duckdb/parser/statement/detach_statement.hpp"
+
+namespace duckdb {
+
+DetachStatement::DetachStatement() : SQLStatement(StatementType::DETACH_STATEMENT) {
+}
+
+DetachStatement::DetachStatement(const DetachStatement &other) : SQLStatement(other), info(other.info->Copy()) {
+}
+
+unique_ptr<SQLStatement> DetachStatement::Copy() const {
+	return unique_ptr<DetachStatement>(new DetachStatement(*this));
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/statement/insert_statement.cpp

@@ -13,6 +13,9 @@ OnConflictInfo::OnConflictInfo(const OnConflictInfo &other)
 	if (other.set_info) {
 		set_info = other.set_info->Copy();
 	}
+	if (other.condition) {
+		condition = other.condition->Copy();
+	}
 }
 
 unique_ptr<OnConflictInfo> OnConflictInfo::Copy() const {
@@ -28,6 +31,12 @@ InsertStatement::InsertStatement(const InsertStatement &other)
       select_statement(unique_ptr_cast<SQLStatement, SelectStatement>(other.select_statement->Copy())),
       columns(other.columns), table(other.table), schema(other.schema), catalog(other.catalog) {
 	cte_map = other.cte_map.Copy();
+	for (auto &expr : other.returning_list) {
+		returning_list.emplace_back(expr->Copy());
+	}
+	if (other.table_ref) {
+		table_ref = other.table_ref->Copy();
+	}
 	if (other.on_conflict_info) {
 		on_conflict_info = other.on_conflict_info->Copy();
 	}

package/src/duckdb/src/parser/statement/update_statement.cpp

@@ -27,6 +27,9 @@ UpdateStatement::UpdateStatement(const UpdateStatement &other)
 	if (other.from_table) {
 		from_table = other.from_table->Copy();
 	}
+	for (auto &expr : other.returning_list) {
+		returning_list.emplace_back(expr->Copy());
+	}
 	cte_map = other.cte_map.Copy();
 }
 

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

@@ -9,16 +9,16 @@ unique_ptr<ParsedExpression> Transformer::TransformCase(duckdb_libpgquery::PGCas
 	D_ASSERT(root);
 
 	auto case_node = make_unique<CaseExpression>();
+	auto root_arg = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->arg));
 	for (auto cell = root->args->head; cell != nullptr; cell = cell->next) {
 		CaseCheck case_check;
 
 		auto w = reinterpret_cast<duckdb_libpgquery::PGCaseWhen *>(cell->data.ptr_value);
 		auto test_raw = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(w->expr));
 		unique_ptr<ParsedExpression> test;
-		auto arg = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->arg));
-		if (arg) {
+		if (root_arg) {
 			case_check.when_expr =
-			    make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, std::move(arg), std::move(test_raw));
+			    make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, root_arg->Copy(), std::move(test_raw));
 		} else {
 			case_check.when_expr = std::move(test_raw);
 		}

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

@@ -11,7 +11,6 @@ unique_ptr<CreateStatement> Transformer::TransformCreateDatabase(duckdb_libpgque
 	auto result = make_unique<CreateStatement>();
 	auto info = make_unique<CreateDatabaseInfo>();
 
-	info->extension_name = stmt->extension ? stmt->extension : string();
 	info->path = stmt->path ? stmt->path : string();
 
 	auto qualified_name = TransformQualifiedName(stmt->name);

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

@@ -0,0 +1,19 @@
+#include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/statement/detach_statement.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/common/string_util.hpp"
+
+namespace duckdb {
+
+unique_ptr<DetachStatement> Transformer::TransformDetach(duckdb_libpgquery::PGNode *node) {
+	auto stmt = reinterpret_cast<duckdb_libpgquery::PGDetachStmt *>(node);
+	auto result = make_unique<DetachStatement>();
+	auto info = make_unique<DetachInfo>();
+	info->name = stmt->db_name;
+	info->if_exists = stmt->missing_ok;
+
+	result->info = std::move(info);
+	return result;
+}
+
+} // namespace duckdb

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

@@ -145,6 +145,8 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 		return TransformAlterSequence(stmt);
 	case duckdb_libpgquery::T_PGAttachStmt:
 		return TransformAttach(stmt);
+	case duckdb_libpgquery::T_PGDetachStmt:
+		return TransformDetach(stmt);
 	case duckdb_libpgquery::T_PGUseStmt:
 		return TransformUse(stmt);
 	case duckdb_libpgquery::T_PGCreateDatabaseStmt:

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

@@ -44,7 +44,7 @@ vector<string> BindContext::GetSimilarBindings(const string &column_name) {
 	for (auto &kv : bindings) {
 		auto binding = kv.second.get();
 		for (auto &name : binding->names) {
-			idx_t distance = StringUtil::LevenshteinDistance(name, column_name);
+			idx_t distance = StringUtil::SimilarityScore(name, column_name);
 			scores.emplace_back(binding->alias + "." + name, distance);
 		}
 	}

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

@@ -72,6 +72,9 @@ static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedE
 		for (const auto &element_val : ListValue::GetChildren(value)) {
 			values.push_back(NegatePercentileValue(element_val, desc));
 		}
+		if (values.empty()) {
+			throw BinderException("Empty list in percentile not allowed");
+		}
 		bound.expr = make_unique<BoundConstantExpression>(Value::LIST(values));
 	} else {
 		bound.expr = make_unique<BoundConstantExpression>(NegatePercentileValue(value, desc));

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

@@ -23,16 +23,6 @@
 
 namespace duckdb {
 
-static vector<idx_t> ColumnListToIndices(const vector<bool> &vec) {
-	vector<idx_t> ret;
-	for (idx_t i = 0; i < vec.size(); i++) {
-		if (vec[i]) {
-			ret.push_back(i);
-		}
-	}
-	return ret;
-}
-
 vector<string> GetUniqueNames(const vector<string> &original_names) {
 	unordered_set<string> name_set;
 	vector<string> unique_names;
@@ -97,22 +87,25 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	for (auto &option : original_options) {
 		auto loption = StringUtil::Lower(option.first);
 		if (loption == "use_tmp_file") {
-			use_tmp_file = option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
+			use_tmp_file =
+			    option.second.empty() || option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
 			user_set_use_tmp_file = true;
 			continue;
 		}
 		if (loption == "allow_overwrite") {
-			allow_overwrite = option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
+			allow_overwrite =
+			    option.second.empty() || option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
 			continue;
 		}
 
 		if (loption == "per_thread_output") {
-			per_thread_output = option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
+			per_thread_output =
+			    option.second.empty() || option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
 			continue;
 		}
 		if (loption == "partition_by") {
 			auto converted = ConvertVectorToValue(std::move(option.second));
-			partition_cols = ColumnListToIndices(ParseColumnList(converted, select_node.names, loption));
+			partition_cols = ParseColumnsOrdered(converted, select_node.names, loption);
 			continue;
 		}
 		stmt.info->options[option.first] = option.second;

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

@@ -12,13 +12,11 @@
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
 #include "duckdb/parser/parsed_data/create_database_info.hpp"
-#include "duckdb/function/create_database_extension.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/statement/create_statement.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
 #include "duckdb/planner/expression_binder/index_binder.hpp"
 #include "duckdb/planner/expression_binder/select_binder.hpp"
 #include "duckdb/planner/operator/logical_create.hpp"
@@ -26,13 +24,13 @@
 #include "duckdb/planner/operator/logical_create_table.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
-#include "duckdb/planner/parsed_data/bound_create_function_info.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/planner/tableref/bound_basetableref.hpp"
 #include "duckdb/parser/constraints/foreign_key_constraint.hpp"
 #include "duckdb/function/scalar_macro_function.hpp"
 #include "duckdb/storage/data_table.hpp"
+#include "duckdb/storage/storage_extension.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/parser/constraints/unique_constraint.hpp"
 #include "duckdb/parser/constraints/list.hpp"
@@ -651,23 +649,27 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	case CatalogType::DATABASE_ENTRY: {
 		// not supported in DuckDB yet but allow extensions to intercept and implement this functionality
 		auto &base = (CreateDatabaseInfo &)*stmt.info;
-		string extension_name = base.extension_name;
 		string database_name = base.name;
 		string source_path = base.path;
 
 		auto &config = DBConfig::GetConfig(context);
-		for (auto &extension : config.create_database_extensions) {
-			auto create_database_function_ref =
-			    extension.function(context, extension_name, database_name, source_path, extension.data.get());
-			if (create_database_function_ref) {
-				auto bound_create_database_func = Bind(*create_database_function_ref);
-				result.plan = CreatePlan(*bound_create_database_func);
-				break;
-			}
-		}
-		if (!result.plan) {
+
+		if (config.storage_extensions.empty()) {
 			throw NotImplementedException("CREATE DATABASE not supported in DuckDB yet");
 		}
+		// for now assume only one storage extension provides the custom create_database impl
+		for (auto &extension_entry : config.storage_extensions) {
+			if (extension_entry.second->create_database != nullptr) {
+				auto &storage_extension = extension_entry.second;
+				auto create_database_function_ref = storage_extension->create_database(
+				    storage_extension->storage_info.get(), context, database_name, source_path);
+				if (create_database_function_ref) {
+					auto bound_create_database_func = Bind(*create_database_function_ref);
+					result.plan = CreatePlan(*bound_create_database_func);
+					break;
+				}
+			}
+		}
 		break;
 	}
 	default:

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

@@ -16,6 +16,8 @@
 #include "duckdb/parser/expression/list.hpp"
 #include "duckdb/common/index_map.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
+#include "duckdb/planner/expression_binder/index_binder.hpp"
+#include "duckdb/parser/parsed_data/create_index_info.hpp"
 
 #include <algorithm>
 
@@ -300,4 +302,15 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 	return BindCreateTableInfo(std::move(info), schema);
 }
 
+vector<unique_ptr<Expression>> Binder::BindCreateIndexExpressions(TableCatalogEntry *table, CreateIndexInfo *info) {
+	vector<unique_ptr<Expression>> expressions;
+
+	auto index_binder = IndexBinder(*this, this->context, table, info);
+	for (auto &expr : info->expressions) {
+		expressions.push_back(index_binder.Bind(expr));
+	}
+
+	return expressions;
+}
+
 } // namespace duckdb

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

@@ -0,0 +1,19 @@
+#include "duckdb/parser/statement/detach_statement.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/operator/logical_simple.hpp"
+#include "duckdb/main/config.hpp"
+
+namespace duckdb {
+
+BoundStatement Binder::Bind(DetachStatement &stmt) {
+	BoundStatement result;
+
+	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_DETACH, std::move(stmt.info));
+	result.names = {"Success"};
+	result.types = {LogicalType::BOOLEAN};
+	properties.allow_stream_result = false;
+	properties.return_type = StatementReturnType::NOTHING;
+	return result;
+}
+
+} // namespace duckdb

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

@@ -1,9 +1,13 @@
 #include "duckdb/parser/statement/drop_statement.hpp"
 #include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/bound_tableref.hpp"
 #include "duckdb/planner/operator/logical_simple.hpp"
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/standard_entry.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/parser/parsed_data/drop_info.hpp"
+#include "duckdb/main/config.hpp"
+#include "duckdb/storage/storage_extension.hpp"
 
 namespace duckdb {
 
@@ -43,10 +47,31 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 		stmt.info->schema = entry->schema->name;
 		break;
 	}
-	case CatalogType::DATABASE_ENTRY:
-		// attaching and detaching is read-only
-		stmt.info->catalog = SYSTEM_CATALOG;
-		break;
+	case CatalogType::DATABASE_ENTRY: {
+		auto &base = (DropInfo &)*stmt.info;
+		string database_name = base.name;
+
+		auto &config = DBConfig::GetConfig(context);
+		// for now assume only one storage extension provides the custom drop_database impl
+		for (auto &extension_entry : config.storage_extensions) {
+			if (extension_entry.second->drop_database == nullptr) {
+				continue;
+			}
+			auto &storage_extension = extension_entry.second;
+			auto drop_database_function_ref =
+			    storage_extension->drop_database(storage_extension->storage_info.get(), context, database_name);
+			if (drop_database_function_ref) {
+				auto bound_drop_database_func = Bind(*drop_database_function_ref);
+				result.plan = CreatePlan(*bound_drop_database_func);
+				result.names = {"Success"};
+				result.types = {LogicalType::BIGINT};
+				properties.allow_stream_result = false;
+				properties.return_type = StatementReturnType::NOTHING;
+				return result;
+			}
+		}
+		throw BinderException("Drop is not supported for this database!");
+	}
 	default:
 		throw BinderException("Unknown catalog type for drop statement!");
 	}

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

@@ -301,7 +301,28 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		insert.on_conflict_condition = std::move(condition);
 	}
 
-	auto projection_index = insert.children[0]->GetTableIndex()[0];
+	auto bindings = insert.children[0]->GetColumnBindings();
+	idx_t projection_index = DConstants::INVALID_INDEX;
+	std::vector<unique_ptr<LogicalOperator>> *insert_child_operators;
+	insert_child_operators = &insert.children;
+	while (projection_index == DConstants::INVALID_INDEX) {
+		if (insert_child_operators->empty()) {
+			// No further children to visit
+			break;
+		}
+		D_ASSERT(insert_child_operators->size() >= 1);
+		auto &current_child = (*insert_child_operators)[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;
+		}
+		projection_index = table_indices[0];
+	}
+	if (projection_index == DConstants::INVALID_INDEX) {
+		throw InternalException("Could not locate a table_index from the children of the insert");
+	}
 
 	string unused;
 	auto original_binding = bind_context.GetBinding(table_alias, unused);

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

@@ -128,6 +128,8 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 	{
 		LateralBinder binder(left_binder, context);
 		result->right = right_binder.Bind(*ref.right);
+		result->correlated_columns = binder.ExtractCorrelatedColumns(right_binder);
+
 		result->lateral = binder.HasCorrelatedColumns();
 		if (result->lateral) {
 			// lateral join: can only be an INNER or LEFT join
@@ -135,7 +137,6 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 				throw BinderException("The combining JOIN type must be INNER or LEFT for a LATERAL reference");
 			}
 		}
-		result->correlated_columns = binder.ExtractCorrelatedColumns(right_binder);
 	}
 
 	vector<unique_ptr<ParsedExpression>> extra_conditions;

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

@@ -90,6 +90,8 @@ BoundStatement Binder::Bind(SQLStatement &statement) {
 		return Bind((LogicalPlanStatement &)statement);
 	case StatementType::ATTACH_STATEMENT:
 		return Bind((AttachStatement &)statement);
+	case StatementType::DETACH_STATEMENT:
+		return Bind((DetachStatement &)statement);
 	default: // LCOV_EXCL_START
 		throw NotImplementedException("Unimplemented statement type \"%s\" for Bind",
 		                              StatementTypeToString(statement.type));

package/src/duckdb/src/planner/expression_binder/index_binder.cpp

@@ -1,8 +1,14 @@
 #include "duckdb/planner/expression_binder/index_binder.hpp"
 
+#include "duckdb/parser/parsed_data/create_index_info.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/column_binding.hpp"
+
 namespace duckdb {
 
-IndexBinder::IndexBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
+IndexBinder::IndexBinder(Binder &binder, ClientContext &context, TableCatalogEntry *table, CreateIndexInfo *info)
+    : ExpressionBinder(binder, context), table(table), info(info) {
 }
 
 BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
@@ -12,6 +18,31 @@ BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, i
 		return BindResult("window functions are not allowed in index expressions");
 	case ExpressionClass::SUBQUERY:
 		return BindResult("cannot use subquery in index expressions");
+	case ExpressionClass::COLUMN_REF: {
+		if (table) {
+			// WAL replay
+			// we assume that the parsed expressions have qualified column names
+			// and that the columns exist in the table
+			auto &col_ref = (ColumnRefExpression &)expr;
+			auto col_idx = table->GetColumnIndex(col_ref.column_names.back());
+			auto col_type = table->GetColumn(col_idx).GetType();
+
+			// find the col_idx in the index.column_ids
+			auto col_id_idx = DConstants::INVALID_INDEX;
+			for (idx_t i = 0; i < info->column_ids.size(); i++) {
+				if (col_idx.index == info->column_ids[i]) {
+					col_id_idx = i;
+				}
+			}
+
+			if (col_id_idx == DConstants::INVALID_INDEX) {
+				throw InternalException("failed to replay CREATE INDEX statement - column id not found");
+			}
+			return BindResult(
+			    make_unique<BoundColumnRefExpression>(col_ref.alias, col_type, ColumnBinding(0, col_id_idx)));
+		}
+		return ExpressionBinder::BindExpression(expr_ptr, depth);
+	}
 	default:
 		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	}

package/src/duckdb/src/planner/expression_binder/lateral_binder.cpp

@@ -39,14 +39,30 @@ BindResult LateralBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr,
 }
 
 vector<CorrelatedColumnInfo> LateralBinder::ExtractCorrelatedColumns(Binder &binder) {
+
+	if (correlated_columns.empty()) {
+		return binder.correlated_columns;
+	}
+
+	// clear outer
+	correlated_columns.clear();
 	auto all_correlated_columns = binder.correlated_columns;
-	for (auto &correlated : correlated_columns) {
-		auto entry = std::find(binder.correlated_columns.begin(), binder.correlated_columns.end(), correlated);
-		if (entry == binder.correlated_columns.end()) {
-			throw InternalException("Lateral Binder: could not find correlated column in binder");
+
+	// remove outer from inner
+	for (auto &corr_column : correlated_columns) {
+		auto entry = std::find(binder.correlated_columns.begin(), binder.correlated_columns.end(), corr_column);
+		if (entry != binder.correlated_columns.end()) {
+			binder.correlated_columns.erase(entry);
 		}
-		binder.correlated_columns.erase(entry);
 	}
+
+	// add inner to outer
+	for (auto &corr_column : binder.correlated_columns) {
+		correlated_columns.push_back(corr_column);
+	}
+
+	// clear inner
+	binder.correlated_columns.clear();
 	return all_correlated_columns;
 }