duckdb 0.4.1-dev723.0 → 0.4.1-dev752.0

package/src/duckdb.cpp

@@ -978,8 +978,10 @@ LogicalType Catalog::GetType(ClientContext &context, const string &schema, const
 
 void Catalog::Alter(ClientContext &context, AlterInfo *info) {
 	ModifyCatalog();
-	auto lookup = LookupEntry(context, info->GetCatalogType(), info->schema, info->name);
-	D_ASSERT(lookup.Found()); // It must have thrown otherwise.
+	auto lookup = LookupEntry(context, info->GetCatalogType(), info->schema, info->name, info->if_exists);
+	if (!lookup.Found()) {
+		return;
+	}
 	return lookup.schema->Alter(context, info);
 }
 
@@ -20486,7 +20488,7 @@ std::string NumericHelper::ToString(hugeint_t value);
 
 struct DecimalToString {
 	template <class SIGNED, class UNSIGNED>
-	static int DecimalLength(SIGNED value, uint8_t scale) {
+	static int DecimalLength(SIGNED value, uint8_t width, uint8_t scale) {
 		if (scale == 0) {
 			// scale is 0: regular number
 			return NumericHelper::SignedLength<SIGNED, UNSIGNED>(value);
@@ -20498,11 +20500,13 @@ struct DecimalToString {
 		// in that case we print "0.XXX", which is the scale, plus "0." (2 chars)
 		// integer length + 1 happens when the number is outside of that range
 		// in that case we print the integer number, but with one extra character ('.')
-		return MaxValue(scale + 2 + (value < 0 ? 1 : 0), NumericHelper::SignedLength<SIGNED, UNSIGNED>(value) + 1);
+		auto extra_characters = width > scale ? 2 : 1;
+		return MaxValue(scale + extra_characters + (value < 0 ? 1 : 0),
+		                NumericHelper::SignedLength<SIGNED, UNSIGNED>(value) + 1);
 	}
 
 	template <class SIGNED, class UNSIGNED>
-	static void FormatDecimal(SIGNED value, uint8_t scale, char *dst, idx_t len) {
+	static void FormatDecimal(SIGNED value, uint8_t width, uint8_t scale, char *dst, idx_t len) {
 		char *end = dst + len;
 		if (value < 0) {
 			value = -value;
@@ -20525,14 +20529,18 @@ struct DecimalToString {
 		}
 		*--dst = '.';
 		// now write the part before the decimal
-		dst = NumericHelper::FormatUnsigned<UNSIGNED>(major, dst);
+		D_ASSERT(width > scale || major == 0);
+		if (width > scale) {
+			// there are numbers after the comma
+			dst = NumericHelper::FormatUnsigned<UNSIGNED>(major, dst);
+		}
 	}
 
 	template <class SIGNED, class UNSIGNED>
-	static string_t Format(SIGNED value, uint8_t scale, Vector &vector) {
-		int len = DecimalLength<SIGNED, UNSIGNED>(value, scale);
+	static string_t Format(SIGNED value, uint8_t width, uint8_t scale, Vector &vector) {
+		int len = DecimalLength<SIGNED, UNSIGNED>(value, width, scale);
 		string_t result = StringVector::EmptyString(vector, len);
-		FormatDecimal<SIGNED, UNSIGNED>(value, scale, result.GetDataWriteable(), len);
+		FormatDecimal<SIGNED, UNSIGNED>(value, width, scale, result.GetDataWriteable(), len);
 		result.Finalize();
 		return result;
 	}
@@ -20655,7 +20663,7 @@ struct HugeintToStringCast {
 		return result;
 	}
 
-	static int DecimalLength(hugeint_t value, uint8_t scale) {
+	static int DecimalLength(hugeint_t value, uint8_t width, uint8_t scale) {
 		int negative;
 		if (value.upper < 0) {
 			Hugeint::NegateInPlace(value);
@@ -20674,10 +20682,11 @@ struct HugeintToStringCast {
 		// in that case we print "0.XXX", which is the scale, plus "0." (2 chars)
 		// integer length + 1 happens when the number is outside of that range
 		// in that case we print the integer number, but with one extra character ('.')
-		return MaxValue(scale + 2, UnsignedLength(value) + 1) + negative;
+		auto extra_numbers = width > scale ? 2 : 1;
+		return MaxValue(scale + extra_numbers, UnsignedLength(value) + 1) + negative;
 	}
 
-	static void FormatDecimal(hugeint_t value, uint8_t scale, char *dst, int len) {
+	static void FormatDecimal(hugeint_t value, uint8_t width, uint8_t scale, char *dst, int len) {
 		auto endptr = dst + len;
 
 		int negative = value.upper < 0;
@@ -20706,16 +20715,19 @@ struct HugeintToStringCast {
 		}
 		*--dst = '.';
 		// now write the part before the decimal
-		dst = FormatUnsigned(major, dst);
+		D_ASSERT(width > scale || major == 0);
+		if (width > scale) {
+			dst = FormatUnsigned(major, dst);
+		}
 	}
 
-	static string_t FormatDecimal(hugeint_t value, uint8_t scale, Vector &vector) {
-		int length = DecimalLength(value, scale);
+	static string_t FormatDecimal(hugeint_t value, uint8_t width, uint8_t scale, Vector &vector) {
+		int length = DecimalLength(value, width, scale);
 		string_t result = StringVector::EmptyString(vector, length);
 
 		auto dst = result.GetDataWriteable();
 
-		FormatDecimal(value, scale, dst, length);
+		FormatDecimal(value, width, scale, dst, length);
 
 		result.Finalize();
 		return result;
@@ -24984,22 +24996,22 @@ bool TryCastToDecimal::Operation(string_t input, hugeint_t &result, string *erro
 
 template <>
 string_t StringCastFromDecimal::Operation(int16_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return DecimalToString::Format<int16_t, uint16_t>(input, scale, result);
+	return DecimalToString::Format<int16_t, uint16_t>(input, width, scale, result);
 }
 
 template <>
 string_t StringCastFromDecimal::Operation(int32_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return DecimalToString::Format<int32_t, uint32_t>(input, scale, result);
+	return DecimalToString::Format<int32_t, uint32_t>(input, width, scale, result);
 }
 
 template <>
 string_t StringCastFromDecimal::Operation(int64_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return DecimalToString::Format<int64_t, uint64_t>(input, scale, result);
+	return DecimalToString::Format<int64_t, uint64_t>(input, width, scale, result);
 }
 
 template <>
 string_t StringCastFromDecimal::Operation(hugeint_t input, uint8_t width, uint8_t scale, Vector &result) {
-	return HugeintToStringCast::FormatDecimal(input, scale, result);
+	return HugeintToStringCast::FormatDecimal(input, width, scale, result);
 }
 
 //===--------------------------------------------------------------------===//
@@ -39884,29 +39896,29 @@ date_t Date::GetMondayOfCurrentWeek(date_t date) {
 namespace duckdb {
 
 template <class SIGNED, class UNSIGNED>
-string TemplatedDecimalToString(SIGNED value, uint8_t scale) {
-	auto len = DecimalToString::DecimalLength<SIGNED, UNSIGNED>(value, scale);
+string TemplatedDecimalToString(SIGNED value, uint8_t width, uint8_t scale) {
+	auto len = DecimalToString::DecimalLength<SIGNED, UNSIGNED>(value, width, scale);
 	auto data = unique_ptr<char[]>(new char[len + 1]);
-	DecimalToString::FormatDecimal<SIGNED, UNSIGNED>(value, scale, data.get(), len);
+	DecimalToString::FormatDecimal<SIGNED, UNSIGNED>(value, width, scale, data.get(), len);
 	return string(data.get(), len);
 }
 
-string Decimal::ToString(int16_t value, uint8_t scale) {
-	return TemplatedDecimalToString<int16_t, uint16_t>(value, scale);
+string Decimal::ToString(int16_t value, uint8_t width, uint8_t scale) {
+	return TemplatedDecimalToString<int16_t, uint16_t>(value, width, scale);
 }
 
-string Decimal::ToString(int32_t value, uint8_t scale) {
-	return TemplatedDecimalToString<int32_t, uint32_t>(value, scale);
+string Decimal::ToString(int32_t value, uint8_t width, uint8_t scale) {
+	return TemplatedDecimalToString<int32_t, uint32_t>(value, width, scale);
 }
 
-string Decimal::ToString(int64_t value, uint8_t scale) {
-	return TemplatedDecimalToString<int64_t, uint64_t>(value, scale);
+string Decimal::ToString(int64_t value, uint8_t width, uint8_t scale) {
+	return TemplatedDecimalToString<int64_t, uint64_t>(value, width, scale);
 }
 
-string Decimal::ToString(hugeint_t value, uint8_t scale) {
-	auto len = HugeintToStringCast::DecimalLength(value, scale);
+string Decimal::ToString(hugeint_t value, uint8_t width, uint8_t scale) {
+	auto len = HugeintToStringCast::DecimalLength(value, width, scale);
 	auto data = unique_ptr<char[]>(new char[len + 1]);
-	HugeintToStringCast::FormatDecimal(value, scale, data.get(), len);
+	HugeintToStringCast::FormatDecimal(value, width, scale, data.get(), len);
 	return string(data.get(), len);
 }
 
@@ -44714,16 +44726,17 @@ string Value::ToString() const {
 		return duckdb_fmt::format("{}", value_.double_);
 	case LogicalTypeId::DECIMAL: {
 		auto internal_type = type_.InternalType();
+		auto width = DecimalType::GetWidth(type_);
 		auto scale = DecimalType::GetScale(type_);
 		if (internal_type == PhysicalType::INT16) {
-			return Decimal::ToString(value_.smallint, scale);
+			return Decimal::ToString(value_.smallint, width, scale);
 		} else if (internal_type == PhysicalType::INT32) {
-			return Decimal::ToString(value_.integer, scale);
+			return Decimal::ToString(value_.integer, width, scale);
 		} else if (internal_type == PhysicalType::INT64) {
-			return Decimal::ToString(value_.bigint, scale);
+			return Decimal::ToString(value_.bigint, width, scale);
 		} else {
 			D_ASSERT(internal_type == PhysicalType::INT128);
-			return Decimal::ToString(value_.hugeint, scale);
+			return Decimal::ToString(value_.hugeint, width, scale);
 		}
 	}
 	case LogicalTypeId::DATE:
@@ -50705,9 +50718,9 @@ struct DecimalScaleInput {
 	DecimalScaleInput(Vector &result_p, FACTOR_TYPE factor_p) : result(result_p), factor(factor_p) {
 	}
 	DecimalScaleInput(Vector &result_p, LIMIT_TYPE limit_p, FACTOR_TYPE factor_p, string *error_message_p,
-	                  uint8_t source_scale_p)
+	                  uint8_t source_width_p, uint8_t source_scale_p)
 	    : result(result_p), limit(limit_p), factor(factor_p), error_message(error_message_p),
-	      source_scale(source_scale_p) {
+	      source_width(source_width_p), source_scale(source_scale_p) {
 	}
 
 	Vector &result;
@@ -50715,6 +50728,7 @@ struct DecimalScaleInput {
 	FACTOR_TYPE factor;
 	bool all_converted = true;
 	string *error_message;
+	uint8_t source_width;
 	uint8_t source_scale;
 };
 
@@ -50731,9 +50745,9 @@ struct DecimalScaleUpCheckOperator {
 	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
 		auto data = (DecimalScaleInput<INPUT_TYPE, RESULT_TYPE> *)dataptr;
 		if (input >= data->limit || input <= -data->limit) {
-			auto error =
-			    StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!",
-			                       Decimal::ToString(input, data->source_scale), data->result.GetType().ToString());
+			auto error = StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!",
+			                                Decimal::ToString(input, data->source_width, data->source_scale),
+			                                data->result.GetType().ToString());
 			return HandleVectorCastError::Operation<RESULT_TYPE>(move(error), mask, idx, data->error_message,
 			                                                     data->all_converted);
 		}
@@ -50759,7 +50773,8 @@ bool TemplatedDecimalScaleUp(Vector &source, Vector &result, idx_t count, string
 	} else {
 		// type might not fit: check limit
 		auto limit = POWERS_SOURCE::POWERS_OF_TEN[target_width];
-		DecimalScaleInput<SOURCE, DEST> input(result, limit, multiply_factor, error_message, source_scale);
+		DecimalScaleInput<SOURCE, DEST> input(result, limit, multiply_factor, error_message, source_width,
+		                                      source_scale);
 		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleUpCheckOperator>(source, result, count, &input,
 		                                                                         error_message);
 		return input.all_converted;
@@ -50779,9 +50794,9 @@ struct DecimalScaleDownCheckOperator {
 	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
 		auto data = (DecimalScaleInput<INPUT_TYPE> *)dataptr;
 		if (input >= data->limit || input <= -data->limit) {
-			auto error =
-			    StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!",
-			                       Decimal::ToString(input, data->source_scale), data->result.GetType().ToString());
+			auto error = StringUtil::Format("Casting value \"%s\" to type %s failed: value is out of range!",
+			                                Decimal::ToString(input, data->source_width, data->source_scale),
+			                                data->result.GetType().ToString());
 			return HandleVectorCastError::Operation<RESULT_TYPE>(move(error), mask, idx, data->error_message,
 			                                                     data->all_converted);
 		}
@@ -50807,7 +50822,7 @@ bool TemplatedDecimalScaleDown(Vector &source, Vector &result, idx_t count, stri
 	} else {
 		// type might not fit: check limit
 		auto limit = POWERS_SOURCE::POWERS_OF_TEN[target_width];
-		DecimalScaleInput<SOURCE> input(result, limit, divide_factor, error_message, source_scale);
+		DecimalScaleInput<SOURCE> input(result, limit, divide_factor, error_message, source_width, source_scale);
 		UnaryExecutor::GenericExecute<SOURCE, DEST, DecimalScaleDownCheckOperator>(source, result, count, &input,
 		                                                                           error_message);
 		return input.all_converted;
@@ -55199,8 +55214,8 @@ void ExpressionExecutor::ExecuteExpression(idx_t expr_idx, Vector &result) {
 	states[expr_idx]->profiler.EndSample(chunk ? chunk->size() : 0);
 }
 
-Value ExpressionExecutor::EvaluateScalar(const Expression &expr) {
-	D_ASSERT(expr.IsFoldable());
+Value ExpressionExecutor::EvaluateScalar(const Expression &expr, bool allow_unfoldable) {
+	D_ASSERT(allow_unfoldable || expr.IsFoldable());
 	D_ASSERT(expr.IsScalar());
 	// use an ExpressionExecutor to execute the expression
 	ExpressionExecutor executor(Allocator::DefaultAllocator(), expr);
@@ -55208,7 +55223,7 @@ Value ExpressionExecutor::EvaluateScalar(const Expression &expr) {
 	Vector result(expr.return_type);
 	executor.ExecuteExpression(result);
 
-	D_ASSERT(result.GetVectorType() == VectorType::CONSTANT_VECTOR);
+	D_ASSERT(allow_unfoldable || result.GetVectorType() == VectorType::CONSTANT_VECTOR);
 	auto result_value = result.GetValue(0);
 	D_ASSERT(result_value.type().InternalType() == expr.return_type.InternalType());
 	return result_value;
@@ -62938,7 +62953,15 @@ void PhysicalLimitPercent::GetData(ExecutionContext &context, DataChunk &chunk,
 		if (count > 0) {
 			count += offset;
 		}
-		limit = MinValue((idx_t)(limit_percent / 100 * count), count);
+		if (limit_percent < 0 || limit_percent > 100) {
+			throw OutOfRangeException("Limit percent out of range, should be between 0% and 100%");
+		}
+		double limit_dbl = limit_percent / 100 * count;
+		if (limit_dbl > count) {
+			limit = count;
+		} else {
+			limit = idx_t(limit_dbl);
+		}
 		if (limit == 0) {
 			return;
 		}
@@ -63920,9 +63943,6 @@ public:
 
 	unique_ptr<VacuumInfo> info;
 
-private:
-	unordered_map<idx_t, idx_t> column_id_map;
-
 public:
 	// Source interface
 	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
@@ -64065,12 +64085,6 @@ namespace duckdb {
 PhysicalVacuum::PhysicalVacuum(unique_ptr<VacuumInfo> info_p, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::VACUUM, {LogicalType::BOOLEAN}, estimated_cardinality),
       info(move(info_p)) {
-	if (info->has_table) {
-		auto &get = (LogicalGet &)*info->bound_ref->get;
-		for (idx_t i = 0; i < get.column_ids.size(); i++) {
-			column_id_map[i] = get.column_ids[i];
-		}
-	}
 }
 
 class VacuumLocalSinkState : public LocalSinkState {
@@ -64107,7 +64121,7 @@ unique_ptr<GlobalSinkState> PhysicalVacuum::GetGlobalSinkState(ClientContext &co
 SinkResultType PhysicalVacuum::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
                                     DataChunk &input) const {
 	auto &lstate = (VacuumLocalSinkState &)lstate_p;
-	D_ASSERT(lstate.column_distinct_stats.size() == column_id_map.size());
+	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++) {
 		lstate.column_distinct_stats[col_idx]->Update(input.data[col_idx], input.size(), false);
@@ -64131,9 +64145,9 @@ SinkFinalizeType PhysicalVacuum::Finalize(Pipeline &pipeline, Event &event, Clie
                                           GlobalSinkState &gstate) const {
 	auto &sink = (VacuumGlobalSinkState &)gstate;
 
-	auto table = info->bound_ref->table;
+	auto table = info->table;
 	for (idx_t col_idx = 0; col_idx < sink.column_distinct_stats.size(); col_idx++) {
-		table->storage->SetStatistics(column_id_map.at(col_idx), [&](BaseStatistics &stats) {
+		table->storage->SetStatistics(info->column_id_map.at(col_idx), [&](BaseStatistics &stats) {
 			stats.distinct_stats = move(sink.column_distinct_stats[col_idx]);
 		});
 	}
@@ -76551,6 +76565,16 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	if (op.join_stats.empty()) {
 		return;
 	}
+	for (auto &type : op.children[1]->types) {
+		switch (type.id()) {
+		case LogicalTypeId::STRUCT:
+		case LogicalTypeId::LIST:
+		case LogicalTypeId::MAP:
+			return;
+		default:
+			break;
+		}
+	}
 	// with equality condition and null values not equal
 	for (auto &&condition : op.conditions) {
 		if (condition.comparison != ExpressionType::COMPARE_EQUAL) {
@@ -79202,16 +79226,12 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSimple &op
 		return make_unique<PhysicalTransaction>(unique_ptr_cast<ParseInfo, TransactionInfo>(move(op.info)),
 		                                        op.estimated_cardinality);
 	case LogicalOperatorType::LOGICAL_VACUUM: {
-		auto &info = (VacuumInfo &)*op.info;
-		if (!info.has_table) {
-			return make_unique<PhysicalVacuum>(unique_ptr_cast<ParseInfo, VacuumInfo>(move(op.info)),
-			                                   op.estimated_cardinality);
-		}
-		info.bound_ref->get->ResolveOperatorTypes();
-		auto child = CreatePlan(*info.bound_ref->get);
 		auto result = make_unique<PhysicalVacuum>(unique_ptr_cast<ParseInfo, VacuumInfo>(move(op.info)),
 		                                          op.estimated_cardinality);
-		result->children.push_back(move(child));
+		if (!op.children.empty()) {
+			auto child = CreatePlan(*op.children[0]);
+			result->children.push_back(move(child));
+		}
 		return move(result);
 	}
 	case LogicalOperatorType::LOGICAL_LOAD:
@@ -79471,21 +79491,18 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalWindow &op
 	types.resize(output_idx);
 
 	// Identify streaming windows
-	vector<idx_t> blocking_windows;
-	vector<idx_t> streaming_windows;
+	vector<idx_t> window_expressions;
+	bool process_streaming = true;
 	for (idx_t expr_idx = 0; expr_idx < op.expressions.size(); expr_idx++) {
-		if (IsStreamingWindow(op.expressions[expr_idx])) {
-			streaming_windows.push_back(expr_idx);
-		} else {
-			blocking_windows.push_back(expr_idx);
+		window_expressions.push_back(expr_idx);
+		if (!IsStreamingWindow(op.expressions[expr_idx])) {
+			process_streaming = false;
 		}
 	}
-
 	// Process the window functions by sharing the partition/order definitions
 	vector<idx_t> evaluation_order;
-	while (!blocking_windows.empty() || !streaming_windows.empty()) {
-		const bool process_streaming = blocking_windows.empty();
-		auto &remaining = process_streaming ? streaming_windows : blocking_windows;
+	while (!window_expressions.empty()) {
+		auto &remaining = window_expressions;
 
 		// Find all functions that share the partitioning of the first remaining expression
 		const auto over_idx = remaining[0];
@@ -80067,7 +80084,7 @@ void RadixPartitionedHashTable::GetData(ExecutionContext &context, DataChunk &ch
 	// special case hack to sort out aggregating from empty intermediates
 	// for aggregations without groups
 	if (gstate.is_empty && grouping_set.empty()) {
-		D_ASSERT(chunk.ColumnCount() == null_groups.size() + op.aggregates.size());
+		D_ASSERT(chunk.ColumnCount() == null_groups.size() + op.aggregates.size() + op.grouping_functions.size());
 		// for each column in the aggregates, set to initial state
 		chunk.SetCardinality(1);
 		for (auto null_group : null_groups) {
@@ -80087,6 +80104,9 @@ void RadixPartitionedHashTable::GetData(ExecutionContext &context, DataChunk &ch
 				aggr.function.destructor(state_vector, 1);
 			}
 		}
+		for (idx_t i = 0; i < op.grouping_functions.size(); i++) {
+			chunk.data[null_groups.size() + op.aggregates.size() + i].Reference(grouping_values[i]);
+		}
 		state.finished = true;
 		return;
 	}
@@ -103472,6 +103492,9 @@ static unique_ptr<FunctionData> LikeBindFunction(ClientContext &context, ScalarF
 	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
 	if (arguments[1]->IsFoldable()) {
 		Value pattern_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
+		if (pattern_str.IsNull()) {
+			return nullptr;
+		}
 		return LikeMatcher::CreateLikeMatcher(pattern_str.ToString());
 	}
 	return nullptr;
@@ -105818,6 +105841,9 @@ static void StructExtractFunction(DataChunk &args, ExpressionState &state, Vecto
 static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, ScalarFunction &bound_function,
                                                   vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(bound_function.arguments.size() == 2);
+	if (arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
+		throw ParameterNotResolvedException();
+	}
 	D_ASSERT(LogicalTypeId::STRUCT == arguments[0]->return_type.id());
 	auto &struct_children = StructType::GetChildTypes(arguments[0]->return_type);
 	if (struct_children.empty()) {
@@ -117754,7 +117780,14 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementInternal(ClientCon
                                                                        unique_ptr<SQLStatement> statement,
                                                                        PendingQueryParameters parameters) {
 	// prepare the query for execution
-	auto prepared = CreatePreparedStatement(lock, query, move(statement));
+	auto prepared = CreatePreparedStatement(lock, query, move(statement), parameters.parameters);
+	if (prepared->properties.parameter_count > 0 && !parameters.parameters) {
+		return make_unique<PendingQueryResult>(StringUtil::Format("Expected %lld parameters, but none were supplied",
+		                                                          prepared->properties.parameter_count));
+	}
+	if (!prepared->properties.bound_all_parameters) {
+		return make_unique<PendingQueryResult>("Not all parameters were bound");
+	}
 	// execute the prepared statement
 	return PendingPreparedStatement(lock, move(prepared), parameters);
 }
@@ -138716,7 +138749,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownCrossProduct(unique_ptr<Logi
 				// bindings match right side: push into right
 				right_pushdown.filters.push_back(move(f));
 			} else {
-				D_ASSERT(side == JoinSide::BOTH);
+				D_ASSERT(side == JoinSide::BOTH || side == JoinSide::NONE);
 				// bindings match both: turn into join condition
 				join_conditions.push_back(move(f->filter));
 			}
@@ -139604,23 +139637,6 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 		everything_referenced = true;
 		break;
 	}
-	case LogicalOperatorType::LOGICAL_VACUUM: {
-		auto &vacuum = (LogicalSimple &)op;
-		auto &info = (VacuumInfo &)*vacuum.info;
-		if (!info.bound_ref) {
-			break;
-		}
-
-		auto &get = (LogicalGet &)*info.bound_ref->get;
-		for (auto &col : info.columns) {
-			for (idx_t col_idx = 0; col_idx < get.names.size(); col_idx++) {
-				if (get.names[col_idx] == col) {
-					get.column_ids.push_back(col_idx);
-					break;
-				}
-			}
-		}
-	}
 	default:
 		break;
 	}
@@ -150987,7 +151003,7 @@ string KeywordHelper::WriteOptionallyQuoted(const string &text, char quote) {
 namespace duckdb {
 
 AlterInfo::AlterInfo(AlterType type, string schema_p, string name_p)
-    : type(type), schema(move(schema_p)), name(move(name_p)) {
+    : type(type), if_exists(false), schema(move(schema_p)), name(move(name_p)) {
 }
 
 AlterInfo::~AlterInfo() {
@@ -160794,6 +160810,8 @@ unique_ptr<ParsedExpression> Transformer::TransformLambda(duckdb_libpgquery::PGL
 
 	auto lhs = TransformExpression(node->lhs);
 	auto rhs = TransformExpression(node->rhs);
+	D_ASSERT(lhs);
+	D_ASSERT(rhs);
 	return make_unique<LambdaExpression>(move(lhs), move(rhs));
 }
 
@@ -162398,7 +162416,9 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 	LogicalTypeId base_type = TransformStringToLogicalTypeId(name);
 
 	LogicalType result_type;
-	if (base_type == LogicalTypeId::STRUCT) {
+	if (base_type == LogicalTypeId::LIST) {
+		throw ParserException("LIST is not valid as a stand-alone type");
+	} else if (base_type == LogicalTypeId::STRUCT) {
 		if (!type_name->typmods || type_name->typmods->length == 0) {
 			throw ParserException("Struct needs a name and entries");
 		}
@@ -162666,6 +162686,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 			throw NotImplementedException("ALTER TABLE option not supported yet!");
 		}
 	}
+	result->info->if_exists = stmt->missing_ok;
 
 	return result;
 }
@@ -166421,7 +166442,7 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 	if (!is_lambda) {
 		// this is for binding JSON
 		auto lhs_expr = expr.lhs->Copy();
-		OperatorExpression arrow_expr(ExpressionType::ARROW, move(lhs_expr), move(expr.expr));
+		OperatorExpression arrow_expr(ExpressionType::ARROW, move(lhs_expr), expr.expr->Copy());
 		return BindExpression(arrow_expr, depth);
 	}
 
@@ -168020,12 +168041,16 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	SelectBinder select_binder(*this, context, *result, info);
 	vector<LogicalType> internal_sql_types;
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
+		bool is_window = statement.select_list[i]->IsWindow();
 		LogicalType result_type;
 		auto expr = select_binder.Bind(statement.select_list[i], &result_type);
 		if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES && select_binder.HasBoundColumns()) {
 			if (select_binder.BoundAggregates()) {
 				throw BinderException("Cannot mix aggregates with non-aggregated columns!");
 			}
+			if (is_window) {
+				throw BinderException("Cannot group on a window clause");
+			}
 			// we are forcing aggregates, and the node has columns bound
 			// this entry becomes a group
 			auto group_ref = make_unique<BoundColumnRefExpression>(
@@ -169487,33 +169512,70 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, const st
 	}
 }
 
-static void FindMatchingPrimaryKeyColumns(vector<unique_ptr<Constraint>> &constraints, ForeignKeyConstraint &fk) {
-	if (!fk.pk_columns.empty()) {
-		return;
-	}
+static void FindMatchingPrimaryKeyColumns(const vector<ColumnDefinition> &columns,
+                                          const vector<unique_ptr<Constraint>> &constraints, ForeignKeyConstraint &fk) {
 	// find the matching primary key constraint
+	bool found_constraint = false;
+	// if no columns are defined, we will automatically try to bind to the primary key
+	bool find_primary_key = fk.pk_columns.empty();
 	for (auto &constr : constraints) {
 		if (constr->type != ConstraintType::UNIQUE) {
 			continue;
 		}
 		auto &unique = (UniqueConstraint &)*constr;
-		if (!unique.is_primary_key) {
+		if (find_primary_key && !unique.is_primary_key) {
 			continue;
 		}
-		idx_t column_count;
+		found_constraint = true;
+
+		vector<string> pk_names;
 		if (unique.index != DConstants::INVALID_INDEX) {
-			fk.info.pk_keys.push_back(unique.index);
-			column_count = 1;
+			pk_names.push_back(columns[unique.index].Name());
 		} else {
-			fk.pk_columns = unique.columns;
-			column_count = unique.columns.size();
+			pk_names = unique.columns;
 		}
-		if (column_count != fk.fk_columns.size()) {
-			throw BinderException("The number of referencing and referenced columns for foreign keys must be the same");
+		if (pk_names.size() != fk.fk_columns.size()) {
+			// the number of referencing and referenced columns for foreign keys must be the same
+			continue;
+		}
+		if (find_primary_key) {
+			// found matching primary key
+			fk.pk_columns = pk_names;
+			return;
 		}
+		if (fk.pk_columns != pk_names) {
+			// Name mismatch
+			continue;
+		}
+		// found match
 		return;
 	}
-	throw BinderException("there is no primary key for referenced table \"%s\"", fk.info.table);
+	// no match found! examine why
+	if (!found_constraint) {
+		// no unique constraint or primary key
+		string search_term = find_primary_key ? "primary key" : "primary key or unique constraint";
+		throw BinderException("Failed to create foreign key: there is no %s for referenced table \"%s\"", search_term,
+		                      fk.info.table);
+	}
+	// check if all the columns exist
+	for (auto &name : fk.pk_columns) {
+		bool found = false;
+		for (auto &col : columns) {
+			if (col.Name() == name) {
+				found = true;
+				break;
+			}
+		}
+		if (!found) {
+			throw BinderException(
+			    "Failed to create foreign key: referenced table \"%s\" does not have a column named \"%s\"",
+			    fk.info.table, name);
+		}
+	}
+	auto fk_names = StringUtil::Join(fk.pk_columns, ",");
+	throw BinderException("Failed to create foreign key: referenced table \"%s\" does not have a primary key or unique "
+	                      "constraint on the columns %s",
+	                      fk.info.table, fk_names);
 }
 
 void ExpressionContainsGeneratedColumn(const ParsedExpression &expr, const unordered_set<string> &gcols,
@@ -169678,13 +169740,13 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			D_ASSERT(fk.info.pk_keys.empty());
 			if (create_info.table == fk.info.table) {
 				fk.info.type = ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE;
-				FindMatchingPrimaryKeyColumns(create_info.constraints, fk);
+				FindMatchingPrimaryKeyColumns(create_info.columns, create_info.constraints, fk);
 			} else {
 				// have to resolve referenced table
 				auto pk_table_entry_ptr = catalog.GetEntry<TableCatalogEntry>(context, fk.info.schema, fk.info.table);
 				fk_schemas.insert(pk_table_entry_ptr->schema);
 				D_ASSERT(fk.info.pk_keys.empty());
-				FindMatchingPrimaryKeyColumns(pk_table_entry_ptr->constraints, fk);
+				FindMatchingPrimaryKeyColumns(pk_table_entry_ptr->columns, pk_table_entry_ptr->constraints, fk);
 				for (auto &keyname : fk.pk_columns) {
 					auto entry = pk_table_entry_ptr->name_map.find(keyname);
 					if (entry == pk_table_entry_ptr->name_map.end()) {
@@ -170301,7 +170363,7 @@ BoundStatement Binder::Bind(ExecuteStatement &stmt) {
 		ConstantBinder cbinder(*constant_binder, context, "EXECUTE statement");
 		auto bound_expr = cbinder.Bind(stmt.values[i]);
 
-		Value value = ExpressionExecutor::EvaluateScalar(*bound_expr);
+		Value value = ExpressionExecutor::EvaluateScalar(*bound_expr, true);
 		bind_values.push_back(move(value));
 	}
 	unique_ptr<LogicalOperator> rebound_plan;
@@ -170967,7 +171029,8 @@ BoundStatement Binder::Bind(AlterStatement &stmt) {
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
 	Catalog &catalog = Catalog::GetCatalog(context);
-	auto entry = catalog.GetEntry(context, stmt.info->GetCatalogType(), stmt.info->schema, stmt.info->name, true);
+	auto entry = catalog.GetEntry(context, stmt.info->GetCatalogType(), stmt.info->schema, stmt.info->name,
+	                              stmt.info->if_exists);
 	if (entry && !entry->temporary) {
 		// we can only alter temporary tables/views in read-only mode
 		properties.read_only = false;
@@ -171428,29 +171491,58 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 
 
 
+
+
 namespace duckdb {
 
 BoundStatement Binder::Bind(VacuumStatement &stmt) {
 	BoundStatement result;
 
+	unique_ptr<LogicalOperator> root;
+
 	if (stmt.info->has_table) {
+		D_ASSERT(!stmt.info->table);
+		D_ASSERT(stmt.info->column_id_map.empty());
 		auto bound_table = Bind(*stmt.info->ref);
 		if (bound_table->type != TableReferenceType::BASE_TABLE) {
 			throw InvalidInputException("Can only vacuum/analyze base tables!");
 		}
-		stmt.info->bound_ref = unique_ptr_cast<BoundTableRef, BoundBaseTableRef>(move(bound_table));
+		auto ref = unique_ptr_cast<BoundTableRef, BoundBaseTableRef>(move(bound_table));
+		stmt.info->table = ref->table;
 
 		auto &columns = stmt.info->columns;
+		vector<unique_ptr<Expression>> select_list;
 		if (columns.empty()) {
 			// Empty means ALL columns should be vacuumed/analyzed
-			auto &get = (LogicalGet &)*stmt.info->bound_ref->get;
+			auto &get = (LogicalGet &)*ref->get;
 			columns.insert(columns.end(), get.names.begin(), get.names.end());
 		}
+		for (auto &col_name : columns) {
+			ColumnRefExpression colref(col_name, ref->table->name);
+			auto result = bind_context.BindColumn(colref, 0);
+			D_ASSERT(!result.HasError());
+			select_list.push_back(move(result.expression));
+		}
+		auto table_scan = CreatePlan(*ref);
+		D_ASSERT(table_scan->type == LogicalOperatorType::LOGICAL_GET);
+		auto &get = (LogicalGet &)*table_scan;
+		for (idx_t i = 0; i < get.column_ids.size(); i++) {
+			stmt.info->column_id_map[i] = get.column_ids[i];
+		}
+
+		auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(select_list));
+		projection->children.push_back(move(table_scan));
+
+		root = move(projection);
+	}
+	auto vacuum = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_VACUUM, move(stmt.info));
+	if (root) {
+		vacuum->children.push_back(move(root));
 	}
 
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_VACUUM, move(stmt.info));
+	result.plan = move(vacuum);
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }
@@ -174466,8 +174558,11 @@ BindResult ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, Colu
 		return BindResult(StringUtil::Format("Alias %s is not found.", expr.ToString()));
 	}
 
+	if (in_alias) {
+		return BindResult("Cannot resolve self-referential alias");
+	}
+
 	// found an alias: bind the alias expression
-	D_ASSERT(!in_alias);
 	auto expression = node.original_expressions[alias_entry->second]->Copy();
 	in_alias = true;
 	auto result = enclosing_binder.BindExpression(&expression, depth, root_expression);
@@ -176779,6 +176874,15 @@ namespace duckdb {
 Planner::Planner(ClientContext &context) : binder(Binder::CreateBinder(context)), context(context) {
 }
 
+static void CheckTreeDepth(const LogicalOperator &op, idx_t max_depth, idx_t depth = 0) {
+	if (depth >= max_depth) {
+		throw ParserException("Maximum tree depth of %lld exceeded in logical planner", max_depth);
+	}
+	for (auto &child : op.children) {
+		CheckTreeDepth(*child, max_depth, depth + 1);
+	}
+}
+
 void Planner::CreatePlan(SQLStatement &statement) {
 	auto &profiler = QueryProfiler::Get(context);
 	auto parameter_count = statement.n_param;
@@ -176797,6 +176901,8 @@ void Planner::CreatePlan(SQLStatement &statement) {
 		this->types = bound_statement.types;
 		this->plan = move(bound_statement.plan);
 
+		auto max_tree_depth = ClientConfig::GetConfig(context).max_expression_depth;
+		CheckTreeDepth(*plan, max_tree_depth);
 	} catch (ParameterNotResolvedException &ex) {
 		// parameter types could not be resolved
 		this->names = {"unknown"};