duckdb 0.7.1-dev14.0 → 0.7.1-dev157.0

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/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;
 }
 

package/src/duckdb/src/planner/logical_operator.cpp

@@ -57,6 +57,7 @@ void LogicalOperator::ResolveOperatorTypes() {
 
 vector<ColumnBinding> LogicalOperator::GenerateColumnBindings(idx_t table_idx, idx_t column_count) {
 	vector<ColumnBinding> result;
+	result.reserve(column_count);
 	for (idx_t i = 0; i < column_count; i++) {
 		result.emplace_back(table_idx, i);
 	}
@@ -84,6 +85,7 @@ vector<ColumnBinding> LogicalOperator::MapBindings(const vector<ColumnBinding> &
 		vector<ColumnBinding> result_bindings;
 		result_bindings.reserve(projection_map.size());
 		for (auto index : projection_map) {
+			D_ASSERT(index < bindings.size());
 			result_bindings.push_back(bindings[index]);
 		}
 		return result_bindings;
@@ -338,6 +340,8 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_DROP:
 		result = LogicalSimple::Deserialize(state, reader);
 		break;
+	case LogicalOperatorType::LOGICAL_DETACH:
+		throw SerializationException("Logical Detach does not support serialization");
 	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
 		result = LogicalExtensionOperator::Deserialize(state, reader);
 		break;

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

@@ -133,6 +133,7 @@ void Planner::CreatePlan(unique_ptr<SQLStatement> statement) {
 	case StatementType::EXECUTE_STATEMENT:
 	case StatementType::LOGICAL_PLAN_STATEMENT:
 	case StatementType::ATTACH_STATEMENT:
+	case StatementType::DETACH_STATEMENT:
 		CreatePlan(*statement);
 		break;
 	default:

package/src/duckdb/src/storage/storage_info.cpp

@@ -9,7 +9,8 @@ struct StorageVersionInfo {
 	idx_t storage_version;
 };
 
-static StorageVersionInfo storage_version_info[] = {{"v0.6.0 or v0.6.1", 39},
+static StorageVersionInfo storage_version_info[] = {{"v0.7.0", 43},
+                                                    {"v0.6.0 or v0.6.1", 39},
                                                     {"v0.5.0 or v0.5.1", 38},
                                                     {"v0.3.3, v0.3.4 or v0.4.0", 33},
                                                     {"v0.3.2", 31},

package/src/duckdb/src/storage/table/column_data.cpp

@@ -27,8 +27,10 @@ ColumnData::ColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t c
 
 ColumnData::ColumnData(ColumnData &other, idx_t start, ColumnData *parent)
     : block_manager(other.block_manager), info(other.info), column_index(other.column_index), start(start),
-      type(std::move(other.type)), parent(parent), updates(std::move(other.updates)),
-      version(parent ? parent->version + 1 : 0) {
+      type(std::move(other.type)), parent(parent), version(parent ? parent->version + 1 : 0) {
+	if (other.updates) {
+		updates = make_unique<UpdateSegment>(*other.updates, *this);
+	}
 	idx_t offset = 0;
 	for (auto segment = other.data.GetRootSegment(); segment; segment = segment->Next()) {
 		auto &other = (ColumnSegment &)*segment;

package/src/duckdb/src/storage/table/update_segment.cpp

@@ -36,6 +36,21 @@ UpdateSegment::UpdateSegment(ColumnData &column_data)
 	this->statistics_update_function = GetStatisticsUpdateFunction(physical_type);
 }
 
+UpdateSegment::UpdateSegment(UpdateSegment &other, ColumnData &owner)
+    : column_data(owner), root(std::move(other.root)), stats(std::move(other.stats)), type_size(other.type_size) {
+
+	this->heap.Move(other.heap);
+
+	initialize_update_function = other.initialize_update_function;
+	merge_update_function = other.merge_update_function;
+	fetch_update_function = other.fetch_update_function;
+	fetch_committed_function = other.fetch_committed_function;
+	fetch_committed_range = other.fetch_committed_range;
+	fetch_row_function = other.fetch_row_function;
+	rollback_update_function = other.rollback_update_function;
+	statistics_update_function = other.statistics_update_function;
+}
+
 UpdateSegment::~UpdateSegment() {
 }
 

package/src/duckdb/third_party/libpg_query/include/nodes/nodes.hpp

@@ -422,6 +422,7 @@ typedef enum PGNodeTag {
 	T_PGExportStmt,
 	T_PGImportStmt,
 	T_PGAttachStmt,
+	T_PGDetachStmt,
 	T_PGCreateDatabaseStmt,
 	T_PGUseStmt,
 

package/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp

@@ -2070,6 +2070,20 @@ typedef struct PGAttachStmt
     PGNode *query;
 } PGAttachStmt;
 
+/* ----------------------
+ *		Dettach Statement
+ * ----------------------
+ */
+
+typedef struct PGDetachStmt
+{
+	PGNodeTag		type;
+	char *db_name;         /* list of names of attached databases */
+	bool missing_ok;
+} PGDetachStmt;
+
+
+
 /* ----------------------
  *		CREATE DATABASE Statement
  * ----------------------