duckdb 0.7.2-dev614.0 → 0.7.2-dev654.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev614.0",
+  "version": "0.7.2-dev654.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -193,14 +193,14 @@ const vector<unique_ptr<Constraint>> &TableCatalogEntry::GetConstraints() {
 }
 
 DataTable &TableCatalogEntry::GetStorage() {
-	throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DTableCatalogEntry");
+	throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DuckTableEntry");
 }
 
 DataTable *TableCatalogEntry::GetStoragePtr() {
-	throw InternalException("Calling GetStoragePtr on a TableCatalogEntry that is not a DTableCatalogEntry");
+	throw InternalException("Calling GetStoragePtr on a TableCatalogEntry that is not a DuckTableEntry");
 }
 
 const vector<unique_ptr<BoundConstraint>> &TableCatalogEntry::GetBoundConstraints() {
-	throw InternalException("Calling GetBoundConstraints on a TableCatalogEntry that is not a DTableCatalogEntry");
+	throw InternalException("Calling GetBoundConstraints on a TableCatalogEntry that is not a DuckTableEntry");
 }
 } // namespace duckdb

package/src/duckdb/src/catalog/dependency_list.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/catalog/catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
 
 namespace duckdb {
 
@@ -10,4 +11,15 @@ void DependencyList::AddDependency(CatalogEntry *entry) {
 	set.insert(entry);
 }
 
+void DependencyList::VerifyDependencies(Catalog *catalog, const string &name) {
+	for (auto &dep : set) {
+		if (dep->catalog != catalog) {
+			throw DependencyException(
+			    "Error adding dependency for object \"%s\" - dependency \"%s\" is in catalog "
+			    "\"%s\", which does not match the catalog \"%s\".\nCross catalog dependencies are not supported.",
+			    name, dep->name, dep->catalog->GetName(), catalog->GetName());
+		}
+	}
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/string_util.cpp

@@ -191,11 +191,14 @@ vector<string> StringUtil::Split(const string &input, const string &split) {
 
 		// Push the substring [last, next) on to splits
 		string substr = input.substr(last, next - last);
-		if (substr.empty() == false) {
+		if (!substr.empty()) {
 			splits.push_back(substr);
 		}
 		last = next + split_len;
 	}
+	if (splits.empty()) {
+		splits.push_back(input);
+	}
 	return splits;
 }
 

package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp

@@ -1559,6 +1559,9 @@ TaskExecutionResult WindowMergeTask::ExecuteTask(TaskExecutionMode mode) {
 	size_t sorted = 0;
 	while (sorted < hash_groups.states.size()) {
 		// First check if there is an unfinished task for this thread
+		if (executor.HasError()) {
+			return TaskExecutionResult::TASK_ERROR;
+		}
 		if (!local_state.TaskFinished()) {
 			local_state.ExecuteTask();
 			continue;

package/src/duckdb/src/execution/operator/helper/physical_vacuum.cpp

@@ -49,6 +49,9 @@ SinkResultType PhysicalVacuum::Sink(ExecutionContext &context, GlobalSinkState &
 	D_ASSERT(lstate.column_distinct_stats.size() == info->column_id_map.size());
 
 	for (idx_t col_idx = 0; col_idx < input.data.size(); col_idx++) {
+		if (!DistinctStatistics::TypeIsSupported(input.data[col_idx].GetType())) {
+			continue;
+		}
 		lstate.column_distinct_stats[col_idx]->Update(input.data[col_idx], input.size(), false);
 	}
 

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -154,6 +154,9 @@ static void CanUseIndexJoin(TableScanBindData *tbl, Expression &expr, Index **re
 
 void TransformIndexJoin(ClientContext &context, LogicalComparisonJoin &op, Index **left_index, Index **right_index,
                         PhysicalOperator *left, PhysicalOperator *right) {
+	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
+		return;
+	}
 	// check if one of the tables has an index on column
 	if (op.join_type == JoinType::INNER && op.conditions.size() == 1) {
 		// check if one of the children are table scans and if they have an index in the join attribute

package/src/duckdb/src/function/aggregate/distributive/bitstring_agg.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
+#include "duckdb/common/operator/subtract.hpp"
 
 namespace duckdb {
 
@@ -93,7 +94,16 @@ struct BitStringAggOperation {
 
 	template <class INPUT_TYPE>
 	static idx_t GetRange(INPUT_TYPE min, INPUT_TYPE max) {
-		return max - min + 1;
+		D_ASSERT(max >= min);
+		INPUT_TYPE result;
+		if (!TrySubtractOperator::Operation(max, min, result)) {
+			return NumericLimits<idx_t>::Maximum();
+		}
+		idx_t val(result);
+		if (val == NumericLimits<idx_t>::Maximum()) {
+			return val;
+		}
+		return val + 1;
 	}
 
 	template <class INPUT_TYPE, class STATE>
@@ -162,12 +172,15 @@ void BitStringAggOperation::Execute(BitAggState<hugeint_t> *state, hugeint_t inp
 
 template <>
 idx_t BitStringAggOperation::GetRange(hugeint_t min, hugeint_t max) {
-	idx_t val;
-	if (Hugeint::TryCast(max - min + 1, val)) {
-		return val;
-	} else {
-		throw OutOfRangeException("Range too large for bitstring aggregation");
+	hugeint_t result;
+	if (!TrySubtractOperator::Operation(max, min, result)) {
+		return NumericLimits<idx_t>::Maximum();
+	}
+	idx_t range;
+	if (!Hugeint::TryCast(result + 1, range)) {
+		return NumericLimits<idx_t>::Maximum();
 	}
+	return range;
 }
 
 unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
@@ -185,8 +198,10 @@ unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, Bound
 
 unique_ptr<FunctionData> BindBitstringAgg(ClientContext &context, AggregateFunction &function,
                                           vector<unique_ptr<Expression>> &arguments) {
-
 	if (arguments.size() == 3) {
+		if (!arguments[1]->IsFoldable() && !arguments[2]->IsFoldable()) {
+			throw BinderException("bitstring_agg requires a constant min and max argument");
+		}
 		auto min = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
 		auto max = ExpressionExecutor::EvaluateScalar(context, *arguments[2]);
 		Function::EraseArgument(function, arguments, 2);

package/src/duckdb/src/function/aggregate/distributive/first.cpp

@@ -79,6 +79,7 @@ struct FirstFunctionString : public FirstFunctionBase {
 			}
 		} else {
 			state->is_set = true;
+			state->is_null = false;
 			if (value.IsInlined()) {
 				state->value = value;
 			} else {

package/src/duckdb/src/function/aggregate/holistic/approximate_quantile.cpp

@@ -70,11 +70,14 @@ struct ApproxQuantileOperation {
 
 	template <class INPUT_TYPE, class STATE, class OP>
 	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
+		auto val = Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(data[idx]);
+		if (!Value::DoubleIsFinite(val)) {
+			return;
+		}
 		if (!state->h) {
 			state->h = new duckdb_tdigest::TDigest(100);
 		}
-
-		state->h->add(Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(data[idx]));
+		state->h->add(val);
 		state->pos++;
 	}
 

package/src/duckdb/src/function/table/checkpoint.cpp

@@ -32,7 +32,11 @@ static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, TableFunc
 	AttachedDatabase *db;
 	auto &db_manager = DatabaseManager::Get(context);
 	if (!input.inputs.empty()) {
-		db = db_manager.GetDatabase(context, StringValue::Get(input.inputs[0]));
+		auto &db_name = StringValue::Get(input.inputs[0]);
+		db = db_manager.GetDatabase(context, db_name);
+		if (!db) {
+			throw BinderException("Database \"%s\" not found", db_name);
+		}
 	} else {
 		db = db_manager.GetDatabase(context, DatabaseManager::GetDefaultDatabase(context));
 	}

package/src/duckdb/src/function/table/system/duckdb_constraints.cpp

@@ -204,8 +204,8 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 					const auto &bound_foreign_key = (const BoundForeignKeyConstraint &)bound_constraint;
 					const auto &info = bound_foreign_key.info;
 					// find the other table
-					auto table_entry =
-					    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, info.schema, info.table, true);
+					auto table_entry = Catalog::GetEntry<TableCatalogEntry>(context, table.catalog->GetName(),
+					                                                        info.schema, info.table, true);
 					if (!table_entry) {
 						throw InternalException("dukdb_constraints: entry %s.%s referenced in foreign key not found",
 						                        info.schema, info.table);

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev614"
+#define DUCKDB_VERSION "0.7.2-dev654"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "40e91c8873"
+#define DUCKDB_SOURCE_ID "6525767cf1"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/dependency_list.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/common/unordered_set.hpp"
 
 namespace duckdb {
+class Catalog;
 class CatalogEntry;
 
 //! The DependencyList
@@ -21,6 +22,8 @@ class DependencyList {
 public:
 	DUCKDB_API void AddDependency(CatalogEntry *entry);
 
+	DUCKDB_API void VerifyDependencies(Catalog *catalog, const string &name);
+
 private:
 	unordered_set<CatalogEntry *> set;
 };

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -71,8 +71,11 @@ private:
 	vector<unique_ptr<CreatePivotEntry>> pivot_entries;
 	//! Sets of stored CTEs, if any
 	vector<CommonTableExpressionMap *> stored_cte_map;
+	//! Whether or not we are currently binding a window definition
+	bool in_window_definition = false;
 
 	void Clear();
+	bool InWindowDefinition();
 
 	void SetParamCount(idx_t new_count) {
 		if (parent) {

package/src/duckdb/src/include/duckdb/storage/statistics/distinct_statistics.hpp

@@ -46,6 +46,8 @@ public:
 	string ToString() const;
 	idx_t GetCount() const;
 
+	static bool TypeIsSupported(const LogicalType &type);
+
 private:
 	//! For distinct statistics we sample the input to speed up insertions
 	static constexpr const double SAMPLE_RATE = 0.1;

package/src/duckdb/src/optimizer/pushdown/pushdown_aggregate.cpp

@@ -9,6 +9,14 @@ namespace duckdb {
 
 using Filter = FilterPushdown::Filter;
 
+static void ExtractFilterBindings(Expression &expr, vector<ColumnBinding> &bindings) {
+	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
+		auto &colref = (BoundColumnRefExpression &)expr;
+		bindings.push_back(colref.binding);
+	}
+	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { ExtractFilterBindings(child, bindings); });
+}
+
 static unique_ptr<Expression> ReplaceGroupBindings(LogicalAggregate &proj, unique_ptr<Expression> expr) {
 	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
 		auto &colref = (BoundColumnRefExpression &)*expr;
@@ -40,14 +48,34 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownAggregate(unique_ptr<Logical
 			// filter on GROUPINGS function: cannot pushdown
 			continue;
 		}
-		// if there are any empty grouping sets, we cannot push down filters
-		bool has_empty_grouping_sets = false;
+		// no aggregate! we are filtering on a group
+		// we can only push this down if the filter is in all grouping sets
+		vector<ColumnBinding> bindings;
+		ExtractFilterBindings(*f.filter, bindings);
+
+		bool can_pushdown_filter = true;
+		if (aggr.grouping_sets.empty()) {
+			// empty grouping set - we cannot pushdown the filter
+			can_pushdown_filter = false;
+		}
 		for (auto &grp : aggr.grouping_sets) {
-			if (grp.empty()) {
-				has_empty_grouping_sets = true;
+			// check for each of the grouping sets if they contain all groups
+			if (bindings.empty()) {
+				// we can never push down empty grouping sets
+				can_pushdown_filter = false;
+				break;
+			}
+			for (auto &binding : bindings) {
+				if (grp.find(binding.column_index) == grp.end()) {
+					can_pushdown_filter = false;
+					break;
+				}
+			}
+			if (!can_pushdown_filter) {
+				break;
 			}
 		}
-		if (has_empty_grouping_sets) {
+		if (!can_pushdown_filter) {
 			continue;
 		}
 		// no aggregate! we can push this down

package/src/duckdb/src/optimizer/rule/move_constants.cpp

@@ -73,7 +73,10 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 			}
 			auto result_value = Value::HUGEINT(outer_value);
 			if (!result_value.DefaultTryCastAs(constant_type)) {
-				// if the cast is not possible then the comparison is not possible
+				// if the cast is not possible then an equality comparison is not possible
+				if (comparison->type != ExpressionType::COMPARE_EQUAL) {
+					return nullptr;
+				}
 				return ExpressionRewriter::ConstantOrNull(std::move(arithmetic->children[arithmetic_child_index]),
 				                                          Value::BOOLEAN(false));
 			}
@@ -86,7 +89,10 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 			}
 			auto result_value = Value::HUGEINT(inner_value);
 			if (!result_value.DefaultTryCastAs(constant_type)) {
-				// if the cast is not possible then the comparison is not possible
+				// if the cast is not possible then an equality comparison is not possible
+				if (comparison->type != ExpressionType::COMPARE_EQUAL) {
+					return nullptr;
+				}
 				return ExpressionRewriter::ConstantOrNull(std::move(arithmetic->children[arithmetic_child_index]),
 				                                          Value::BOOLEAN(false));
 			}

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

@@ -105,6 +105,16 @@ bool Transformer::ExpressionIsEmptyStar(ParsedExpression &expr) {
 	return false;
 }
 
+bool Transformer::InWindowDefinition() {
+	if (in_window_definition) {
+		return true;
+	}
+	if (parent) {
+		return parent->InWindowDefinition();
+	}
+	return false;
+}
+
 unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::PGFuncCall *root) {
 	auto name = root->funcname;
 	string catalog, schema, function_name;
@@ -139,6 +149,10 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 
 	auto lowercase_name = StringUtil::Lower(function_name);
 	if (root->over) {
+		if (InWindowDefinition()) {
+			throw ParserException("window functions are not allowed in window definitions");
+		}
+
 		const auto win_fun_type = WindowToExpressionType(lowercase_name);
 		if (win_fun_type == ExpressionType::INVALID) {
 			throw InternalException("Unknown/unsupported window function");
@@ -218,8 +232,10 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			window_ref = it->second;
 			D_ASSERT(window_ref);
 		}
+		in_window_definition = true;
 		TransformWindowDef(window_ref, expr.get());
 		TransformWindowFrame(window_spec, expr.get());
+		in_window_definition = false;
 		expr->query_location = root->location;
 		return std::move(expr);
 	}

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

@@ -26,8 +26,7 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 				auto window_def = reinterpret_cast<duckdb_libpgquery::PGWindowDef *>(window_ele->data.ptr_value);
 				D_ASSERT(window_def);
 				D_ASSERT(window_def->name);
-				auto window_name = StringUtil::Lower(string(window_def->name));
-
+				string window_name(window_def->name);
 				auto it = window_clauses.find(window_name);
 				if (it != window_clauses.end()) {
 					throw ParserException("window \"%s\" is already defined", window_name);

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

@@ -426,12 +426,16 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	// after that, we bind to the SELECT list
 	SelectBinder select_binder(*this, context, *result, info, alias_map);
 	vector<LogicalType> internal_sql_types;
+	vector<idx_t> group_by_all_indexes;
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		bool is_window = statement.select_list[i]->IsWindow();
 		idx_t unnest_count = result->unnests.size();
 		LogicalType result_type;
 		auto expr = select_binder.Bind(statement.select_list[i], &result_type);
-		if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES && select_binder.HasBoundColumns()) {
+		bool is_original_column = i < result->column_count;
+		bool can_group_by_all =
+		    statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES && is_original_column;
+		if (can_group_by_all && select_binder.HasBoundColumns()) {
 			if (select_binder.BoundAggregates()) {
 				throw BinderException("Cannot mix aggregates with non-aggregated columns!");
 			}
@@ -443,20 +447,25 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			}
 			// we are forcing aggregates, and the node has columns bound
 			// this entry becomes a group
-			auto group_ref = make_unique<BoundColumnRefExpression>(
-			    expr->return_type, ColumnBinding(result->group_index, result->groups.group_expressions.size()));
-			result->groups.group_expressions.push_back(std::move(expr));
-			expr = std::move(group_ref);
+			group_by_all_indexes.push_back(i);
 		}
 		result->select_list.push_back(std::move(expr));
 		if (i < result->column_count) {
 			result->types.push_back(result_type);
 		}
 		internal_sql_types.push_back(result_type);
-		if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
+		if (can_group_by_all) {
 			select_binder.ResetBindings();
 		}
 	}
+	// push the GROUP BY ALL expressions into the group set
+	for (auto &group_by_all_index : group_by_all_indexes) {
+		auto &expr = result->select_list[group_by_all_index];
+		auto group_ref = make_unique<BoundColumnRefExpression>(
+		    expr->return_type, ColumnBinding(result->group_index, result->groups.group_expressions.size()));
+		result->groups.group_expressions.push_back(std::move(expr));
+		expr = std::move(group_ref);
+	}
 	result->need_prune = result->select_list.size() > result->column_count;
 
 	// in the normal select binder, we bind columns as if there is no aggregation
@@ -467,16 +476,19 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	    !result->groups.grouping_sets.empty()) {
 		if (statement.aggregate_handling == AggregateHandling::NO_AGGREGATES_ALLOWED) {
 			throw BinderException("Aggregates cannot be present in a Project relation!");
-		} else if (statement.aggregate_handling == AggregateHandling::STANDARD_HANDLING) {
-			if (select_binder.HasBoundColumns()) {
-				auto &bound_columns = select_binder.GetBoundColumns();
-				string error;
-				error = "column \"%s\" must appear in the GROUP BY clause or must be part of an aggregate function.";
+		} else if (select_binder.HasBoundColumns()) {
+			auto &bound_columns = select_binder.GetBoundColumns();
+			string error;
+			error = "column \"%s\" must appear in the GROUP BY clause or must be part of an aggregate function.";
+			if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
+				error += "\nGROUP BY ALL will only group entries in the SELECT list. Add it to the SELECT list or "
+				         "GROUP BY this entry explicitly.";
+			} else {
 				error += "\nEither add it to the GROUP BY list, or use \"ANY_VALUE(%s)\" if the exact value of \"%s\" "
 				         "is not important.";
-				throw BinderException(FormatError(bound_columns[0].query_location, error, bound_columns[0].name,
-				                                  bound_columns[0].name, bound_columns[0].name));
 			}
+			throw BinderException(FormatError(bound_columns[0].query_location, error, bound_columns[0].name,
+			                                  bound_columns[0].name, bound_columns[0].name));
 		}
 	}
 

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

@@ -185,7 +185,7 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 	vector<string> expected_names;
 	if (!bound_insert.column_index_map.empty()) {
 		expected_names.resize(bound_insert.expected_types.size());
-		for (auto &col : table->GetColumns().Logical()) {
+		for (auto &col : table->GetColumns().Physical()) {
 			auto i = col.Physical();
 			if (bound_insert.column_index_map[i] != DConstants::INVALID_INDEX) {
 				expected_names[bound_insert.column_index_map[i]] = col.Name();
@@ -193,7 +193,7 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 		}
 	} else {
 		expected_names.reserve(bound_insert.expected_types.size());
-		for (auto &col : table->GetColumns().Logical()) {
+		for (auto &col : table->GetColumns().Physical()) {
 			expected_names.push_back(col.Name());
 		}
 	}

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

@@ -119,9 +119,15 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 			         fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE);
 			physical_index_set_t fk_key_set, pk_key_set;
 			for (idx_t i = 0; i < fk.info.pk_keys.size(); i++) {
+				if (pk_key_set.find(fk.info.pk_keys[i]) != pk_key_set.end()) {
+					throw BinderException("Duplicate primary key referenced in FOREIGN KEY constraint");
+				}
 				pk_key_set.insert(fk.info.pk_keys[i]);
 			}
 			for (idx_t i = 0; i < fk.info.fk_keys.size(); i++) {
+				if (fk_key_set.find(fk.info.fk_keys[i]) != fk_key_set.end()) {
+					throw BinderException("Duplicate key specified in FOREIGN KEY constraint");
+				}
 				fk_key_set.insert(fk.info.fk_keys[i]);
 			}
 			info.bound_constraints.push_back(
@@ -292,6 +298,7 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 			result->dependencies.AddDependency(type_dependency);
 		}
 	}
+	result->dependencies.VerifyDependencies(schema->catalog, result->Base().table);
 	properties.allow_stream_result = false;
 	return result;
 }

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