duckdb 0.7.2-dev586.0 → 0.7.2-dev654.0

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

@@ -335,6 +335,16 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		ReplaceColumnBindings(*insert.on_conflict_condition, table_index, projection_index);
 	}
 
+	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;
+	}
+	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;
+	}
 	if (insert.action_type == OnConflictAction::NOTHING) {
 		if (!insert.on_conflict_condition) {
 			return;
@@ -346,15 +356,9 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		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) {

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

@@ -195,11 +195,13 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	AddCTEMap(stmt.cte_map);
 
 	if (stmt.from_table) {
+		auto from_binder = Binder::CreateBinder(context, this);
 		BoundJoinRef bound_crossproduct(JoinRefType::CROSS);
 		bound_crossproduct.left = std::move(bound_table);
-		bound_crossproduct.right = Bind(*stmt.from_table);
+		bound_crossproduct.right = from_binder->Bind(*stmt.from_table);
 		root = CreatePlan(bound_crossproduct);
 		get = (LogicalGet *)root->children[0].get();
+		bind_context.AddContext(std::move(from_binder->bind_context));
 	} else {
 		root = CreatePlan(*bound_table);
 		get = (LogicalGet *)root.get();

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

@@ -271,6 +271,7 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 	vector<vector<unique_ptr<ParsedExpression>>> unpivot_expressions;
 	for (idx_t v_idx = 0; v_idx < unpivot.entries[0].values.size(); v_idx++) {
 		vector<unique_ptr<ParsedExpression>> expressions;
+		expressions.reserve(unpivot.entries.size());
 		for (auto &entry : unpivot.entries) {
 			expressions.push_back(make_unique<ColumnRefExpression>(entry.values[v_idx].ToString()));
 		}

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

@@ -8,6 +8,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTERef &ref) {
 	auto index = ref.bind_index;
 
 	vector<LogicalType> types;
+	types.reserve(ref.types.size());
 	for (auto &type : ref.types) {
 		types.push_back(type);
 	}

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

@@ -19,6 +19,9 @@ BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, i
 	auto &expr = (ColumnRefExpression &)**expr_ptr;
 	auto alias_result = column_alias_binder.BindAlias(*this, expr, depth, root_expression);
 	if (!alias_result.HasError()) {
+		if (depth > 0) {
+			throw BinderException("Having clause cannot reference alias in correlated subquery");
+		}
 		return alias_result;
 	}
 	if (aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {

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

@@ -157,7 +157,7 @@ LogicalType ExpressionBinder::ExchangeType(const LogicalType &type, LogicalTypeI
 		for (auto &child_type : child_types) {
 			child_type.second = ExchangeType(child_type.second, target, new_type);
 		}
-		return LogicalType::STRUCT(std::move(child_types));
+		return LogicalType::STRUCT(child_types);
 	}
 	case LogicalTypeId::UNION: {
 		auto member_types = UnionType::CopyMemberTypes(type);

package/src/duckdb/src/storage/statistics/column_statistics.cpp

@@ -4,8 +4,7 @@
 namespace duckdb {
 
 ColumnStatistics::ColumnStatistics(BaseStatistics stats_p) : stats(std::move(stats_p)) {
-	auto type = stats.GetType().InternalType();
-	if (type != PhysicalType::LIST && type != PhysicalType::STRUCT) {
+	if (DistinctStatistics::TypeIsSupported(stats.GetType())) {
 		distinct_stats = make_unique<DistinctStatistics>();
 	}
 }

package/src/duckdb/src/storage/statistics/distinct_statistics.cpp

@@ -94,4 +94,8 @@ idx_t DistinctStatistics::GetCount() const {
 	return MinValue<idx_t>(estimate, total_count);
 }
 
+bool DistinctStatistics::TypeIsSupported(const LogicalType &type) {
+	return type.InternalType() != PhysicalType::LIST && type.InternalType() != PhysicalType::STRUCT;
+}
+
 } // namespace duckdb

package/src/duckdb/src/storage/statistics/list_stats.cpp

@@ -34,12 +34,16 @@ void ListStats::Copy(BaseStatistics &stats, const BaseStatistics &other) {
 }
 
 const BaseStatistics &ListStats::GetChildStats(const BaseStatistics &stats) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::LIST_STATS);
+	if (stats.GetStatsType() != StatisticsType::LIST_STATS) {
+		throw InternalException("ListStats::GetChildStats called on stats that is not a list");
+	}
 	D_ASSERT(stats.child_stats);
 	return stats.child_stats[0];
 }
 BaseStatistics &ListStats::GetChildStats(BaseStatistics &stats) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::LIST_STATS);
+	if (stats.GetStatsType() != StatisticsType::LIST_STATS) {
+		throw InternalException("ListStats::GetChildStats called on stats that is not a list");
+	}
 	D_ASSERT(stats.child_stats);
 	return stats.child_stats[0];
 }

package/src/duckdb/src/storage/statistics/struct_stats.cpp

@@ -34,7 +34,9 @@ BaseStatistics StructStats::CreateEmpty(LogicalType type) {
 }
 
 const BaseStatistics *StructStats::GetChildStats(const BaseStatistics &stats) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::STRUCT_STATS);
+	if (stats.GetStatsType() != StatisticsType::STRUCT_STATS) {
+		throw InternalException("Calling StructStats::GetChildStats on stats that is not a struct");
+	}
 	return stats.child_stats.get();
 }
 

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

@@ -156,7 +156,11 @@ unique_ptr<RowGroup> RowGroup::AlterType(const LogicalType &target_type, idx_t c
 	// scan the original table, and fill the new column with the transformed value
 	InitializeScan(scan_state);
 
-	Vector append_vector(target_type);
+	DataChunk append_chunk;
+	vector<LogicalType> append_types;
+	append_types.push_back(target_type);
+	append_chunk.Initialize(Allocator::DefaultAllocator(), append_types);
+	auto &append_vector = append_chunk.data[0];
 	SegmentStatistics altered_col_stats(target_type);
 	while (true) {
 		// scan the table
@@ -166,6 +170,7 @@ unique_ptr<RowGroup> RowGroup::AlterType(const LogicalType &target_type, idx_t c
 			break;
 		}
 		// execute the expression
+		append_chunk.Reset();
 		executor.ExecuteExpression(scan_chunk, append_vector);
 		column_data->Append(altered_col_stats.statistics, append_state, append_vector, scan_chunk.size());
 	}

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

@@ -38,7 +38,17 @@ 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);
-
+	// update the segment links
+	if (root) {
+		for (idx_t i = 0; i < RowGroup::ROW_GROUP_VECTOR_COUNT; i++) {
+			if (!root->info[i]) {
+				continue;
+			}
+			for (auto info = root->info[i]->info.get(); info; info = info->next) {
+				info->segment = this;
+			}
+		}
+	}
 	initialize_update_function = other.initialize_update_function;
 	merge_update_function = other.merge_update_function;
 	fetch_update_function = other.fetch_update_function;
@@ -52,12 +62,6 @@ UpdateSegment::UpdateSegment(UpdateSegment &other, ColumnData &owner)
 UpdateSegment::~UpdateSegment() {
 }
 
-void UpdateSegment::ClearUpdates() {
-	stats.statistics.Copy(BaseStatistics::CreateEmpty(stats.statistics.GetType()));
-	root.reset();
-	heap.Destroy();
-}
-
 //===--------------------------------------------------------------------===//
 // Update Info Helpers
 //===--------------------------------------------------------------------===//