duckdb 0.8.2-dev4871.0 → 0.8.2-dev5080.0

package/src/duckdb/src/include/duckdb/core_functions/scalar/random_functions.hpp

@@ -18,7 +18,7 @@ namespace duckdb {
 struct RandomFun {
 	static constexpr const char *Name = "random";
 	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "returns a random number between 0 and 1";
+	static constexpr const char *Description = "Returns a random number between 0 and 1";
 	static constexpr const char *Example = "random()";
 
 	static ScalarFunction GetFunction();
@@ -27,7 +27,7 @@ struct RandomFun {
 struct SetseedFun {
 	static constexpr const char *Name = "setseed";
 	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "sets the seed to be used for the random function";
+	static constexpr const char *Description = "Sets the seed to be used for the random function";
 	static constexpr const char *Example = "setseed(0.42)";
 
 	static ScalarFunction GetFunction();
@@ -36,7 +36,7 @@ struct SetseedFun {
 struct UUIDFun {
 	static constexpr const char *Name = "uuid";
 	static constexpr const char *Parameters = "";
-	static constexpr const char *Description = "Return a random uuid similar to this: eeccb8c5-9943-b2bb-bb5e-222f4e14b687";
+	static constexpr const char *Description = "Returns a random UUID similar to this: eeccb8c5-9943-b2bb-bb5e-222f4e14b687";
 	static constexpr const char *Example = "uuid()";
 
 	static ScalarFunction GetFunction();

package/src/duckdb/src/include/duckdb/core_functions/scalar/string_functions.hpp

@@ -18,7 +18,7 @@ namespace duckdb {
 struct StartsWithOperatorFun {
 	static constexpr const char *Name = "^@";
 	static constexpr const char *Parameters = "string,search_string";
-	static constexpr const char *Description = "Return true if string begins with search_string";
+	static constexpr const char *Description = "Returns true if string begins with search_string";
 	static constexpr const char *Example = "starts_with('abc','a')";
 
 	static ScalarFunction GetFunction();
@@ -33,7 +33,7 @@ struct StartsWithFun {
 struct ASCIIFun {
 	static constexpr const char *Name = "ascii";
 	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Returns an integer that represents the Unicode code point of the first character of the string.";
+	static constexpr const char *Description = "Returns an integer that represents the Unicode code point of the first character of the string";
 	static constexpr const char *Example = "ascii('Ω')";
 
 	static ScalarFunction GetFunction();
@@ -42,7 +42,7 @@ struct ASCIIFun {
 struct BarFun {
 	static constexpr const char *Name = "bar";
 	static constexpr const char *Parameters = "x,min,max,width";
-	static constexpr const char *Description = "Draw a band whose width is proportional to (x - min) and equal to width characters when x = max. width defaults to 80.";
+	static constexpr const char *Description = "Draws a band whose width is proportional to (x - min) and equal to width characters when x = max. width defaults to 80";
 	static constexpr const char *Example = "bar(5, 0, 20, 10)";
 
 	static ScalarFunctionSet GetFunctions();
@@ -66,7 +66,7 @@ struct ToBinaryFun {
 struct ChrFun {
 	static constexpr const char *Name = "chr";
 	static constexpr const char *Parameters = "code_point";
-	static constexpr const char *Description = "returns a character which is corresponding the ASCII code value or Unicode code point";
+	static constexpr const char *Description = "Returns a character which is corresponding the ASCII code value or Unicode code point";
 	static constexpr const char *Example = "chr(65)";
 
 	static ScalarFunction GetFunction();
@@ -75,7 +75,7 @@ struct ChrFun {
 struct DamerauLevenshteinFun {
 	static constexpr const char *Name = "damerau_levenshtein";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "Extension of Levenshtein distance to also include transposition of adjacent characters as an allowed edit operation. In other words, the minimum number of edit operations (insertions, deletions, substitutions or transpositions) required to change one string to another. Different case is considered different.";
+	static constexpr const char *Description = "Extension of Levenshtein distance to also include transposition of adjacent characters as an allowed edit operation. In other words, the minimum number of edit operations (insertions, deletions, substitutions or transpositions) required to change one string to another. Different case is considered different";
 	static constexpr const char *Example = "damerau_levenshtein('hello', 'world')";
 
 	static ScalarFunction GetFunction();
@@ -108,7 +108,7 @@ struct FormatreadabledecimalsizeFun {
 struct HammingFun {
 	static constexpr const char *Name = "hamming";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The number of positions with different characters for 2 strings of equal length. Different case is considered different.";
+	static constexpr const char *Description = "The number of positions with different characters for 2 strings of equal length. Different case is considered different";
 	static constexpr const char *Example = "hamming('duck','luck')";
 
 	static ScalarFunction GetFunction();
@@ -138,7 +138,7 @@ struct ToHexFun {
 struct InstrFun {
 	static constexpr const char *Name = "instr";
 	static constexpr const char *Parameters = "haystack,needle";
-	static constexpr const char *Description = "Return location of first occurrence of needle in haystack, counting from 1. Returns 0 if no match found.";
+	static constexpr const char *Description = "Returns location of first occurrence of needle in haystack, counting from 1. Returns 0 if no match found";
 	static constexpr const char *Example = "instr('test test','es')";
 
 	static ScalarFunction GetFunction();
@@ -159,7 +159,7 @@ struct PositionFun {
 struct JaccardFun {
 	static constexpr const char *Name = "jaccard";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The Jaccard similarity between two strings. Different case is considered different. Returns a number between 0 and 1.";
+	static constexpr const char *Description = "The Jaccard similarity between two strings. Different case is considered different. Returns a number between 0 and 1";
 	static constexpr const char *Example = "jaccard('duck','luck')";
 
 	static ScalarFunction GetFunction();
@@ -168,7 +168,7 @@ struct JaccardFun {
 struct JaroSimilarityFun {
 	static constexpr const char *Name = "jaro_similarity";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The Jaro similarity between two strings. Different case is considered different. Returns a number between 0 and 1.";
+	static constexpr const char *Description = "The Jaro similarity between two strings. Different case is considered different. Returns a number between 0 and 1";
 	static constexpr const char *Example = "jaro_similarity('duck','duckdb')";
 
 	static ScalarFunction GetFunction();
@@ -177,7 +177,7 @@ struct JaroSimilarityFun {
 struct JaroWinklerSimilarityFun {
 	static constexpr const char *Name = "jaro_winkler_similarity";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The Jaro-Winkler similarity between two strings. Different case is considered different. Returns a number between 0 and 1.";
+	static constexpr const char *Description = "The Jaro-Winkler similarity between two strings. Different case is considered different. Returns a number between 0 and 1";
 	static constexpr const char *Example = "jaro_winkler_similarity('duck','duckdb')";
 
 	static ScalarFunction GetFunction();
@@ -204,7 +204,7 @@ struct LeftGraphemeFun {
 struct LevenshteinFun {
 	static constexpr const char *Name = "levenshtein";
 	static constexpr const char *Parameters = "str1,str2";
-	static constexpr const char *Description = "The minimum number of single-character edits (insertions, deletions or substitutions) required to change one string to the other. Different case is considered different.";
+	static constexpr const char *Description = "The minimum number of single-character edits (insertions, deletions or substitutions) required to change one string to the other. Different case is considered different";
 	static constexpr const char *Example = "levenshtein('duck','db')";
 
 	static ScalarFunction GetFunction();
@@ -402,7 +402,7 @@ struct RegexpSplitToArrayFun {
 struct TranslateFun {
 	static constexpr const char *Name = "translate";
 	static constexpr const char *Parameters = "string,from,to";
-	static constexpr const char *Description = "Replaces each character in string that matches a character in the from set with the corresponding character in the to set. If from is longer than to, occurrences of the extra characters in from are deleted.";
+	static constexpr const char *Description = "Replaces each character in string that matches a character in the from set with the corresponding character in the to set. If from is longer than to, occurrences of the extra characters in from are deleted";
 	static constexpr const char *Example = "translate('12345', '143', 'ax')";
 
 	static ScalarFunction GetFunction();

package/src/duckdb/src/include/duckdb/core_functions/scalar/struct_functions.hpp

@@ -18,7 +18,7 @@ namespace duckdb {
 struct StructInsertFun {
 	static constexpr const char *Name = "struct_insert";
 	static constexpr const char *Parameters = "struct,any";
-	static constexpr const char *Description = "Add field(s)/value(s) to an existing STRUCT with the argument values. The entry name(s) will be the bound variable name(s).";
+	static constexpr const char *Description = "Adds field(s)/value(s) to an existing STRUCT with the argument values. The entry name(s) will be the bound variable name(s)";
 	static constexpr const char *Example = "struct_insert({'a': 1}, b := 2)";
 
 	static ScalarFunction GetFunction();
@@ -27,7 +27,7 @@ struct StructInsertFun {
 struct StructPackFun {
 	static constexpr const char *Name = "struct_pack";
 	static constexpr const char *Parameters = "any";
-	static constexpr const char *Description = "Create a STRUCT containing the argument values. The entry name will be the bound variable name";
+	static constexpr const char *Description = "Creates a STRUCT containing the argument values. The entry name will be the bound variable name";
 	static constexpr const char *Example = "struct_pack(i := 4, s := 'string')";
 
 	static ScalarFunction GetFunction();

package/src/duckdb/src/include/duckdb/core_functions/scalar/union_functions.hpp

@@ -27,7 +27,7 @@ struct UnionExtractFun {
 struct UnionTagFun {
 	static constexpr const char *Name = "union_tag";
 	static constexpr const char *Parameters = "union";
-	static constexpr const char *Description = "Retrieve the currently selected tag of the union as an Enum.";
+	static constexpr const char *Description = "Retrieve the currently selected tag of the union as an ENUM";
 	static constexpr const char *Example = "union_tag(union_value(k := 'foo'))";
 
 	static ScalarFunction GetFunction();
@@ -36,7 +36,7 @@ struct UnionTagFun {
 struct UnionValueFun {
 	static constexpr const char *Name = "union_value";
 	static constexpr const char *Parameters = "tag";
-	static constexpr const char *Description = "Create a single member UNION containing the argument value. The tag of the value will be the bound variable name.";
+	static constexpr const char *Description = "Create a single member UNION containing the argument value. The tag of the value will be the bound variable name";
 	static constexpr const char *Example = "union_value(k := 'hello')";
 
 	static ScalarFunction GetFunction();

package/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp

@@ -52,7 +52,8 @@ enum class StrTimeSpecifier : uint8_t {
 	LOCALE_APPROPRIATE_DATE_AND_TIME =
 	    29, // %c - Locale’s appropriate date and time representation. (Mon Sep 30 07:06:05 2013)
 	LOCALE_APPROPRIATE_DATE = 30, // %x - Locale’s appropriate date representation. (09/30/13)
-	LOCALE_APPROPRIATE_TIME = 31  // %X - Locale’s appropriate time representation. (07:06:05)
+	LOCALE_APPROPRIATE_TIME = 31, // %X - Locale’s appropriate time representation. (07:06:05)
+	NANOSECOND_PADDED = 32 // %n - Nanosecond as a decimal number, zero-padded on the left. (000000000 - 999999999)
 };
 
 struct StrTimeFormat {

package/src/duckdb/src/include/duckdb/main/client_config.hpp

@@ -67,6 +67,8 @@ struct ClientConfig {
 	bool enable_caching_operators = true;
 	//! Force parallelism of small tables, used for testing
 	bool verify_parallelism = false;
+	//! Enable the optimizer to consider index joins, which are disabled on default
+	bool enable_index_join = false;
 	//! Force index join independent of table cardinality, used for testing
 	bool force_index_join = false;
 	//! Force out-of-core computation for operators that support it, used for testing

package/src/duckdb/src/include/duckdb/main/prepared_statement_data.hpp

@@ -14,6 +14,7 @@
 #include "duckdb/common/unordered_set.hpp"
 #include "duckdb/common/winapi.hpp"
 #include "duckdb/planner/expression/bound_parameter_data.hpp"
+#include "duckdb/planner/bound_parameter_map.hpp"
 
 namespace duckdb {
 class CatalogEntry;

package/src/duckdb/src/include/duckdb/planner/bound_parameter_map.hpp

@@ -10,12 +10,39 @@
 
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/unordered_map.hpp"
+#include "duckdb/planner/expression/bound_parameter_data.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
 
 namespace duckdb {
 
-struct BoundParameterData;
+class ParameterExpression;
+class BoundParameterExpression;
 
 using bound_parameter_map_t = case_insensitive_map_t<shared_ptr<BoundParameterData>>;
 
+struct BoundParameterMap {
+public:
+	explicit BoundParameterMap(case_insensitive_map_t<BoundParameterData> &parameter_data);
+
+public:
+	LogicalType GetReturnType(const string &identifier);
+
+	bound_parameter_map_t *GetParametersPtr();
+
+	const bound_parameter_map_t &GetParameters();
+
+	const case_insensitive_map_t<BoundParameterData> &GetParameterData();
+
+	unique_ptr<BoundParameterExpression> BindParameterExpression(ParameterExpression &expr);
+
+private:
+	shared_ptr<BoundParameterData> CreateOrGetData(const string &identifier);
+	void CreateNewParameter(const string &id, const shared_ptr<BoundParameterData> &param_data);
+
+private:
+	bound_parameter_map_t parameters;
+	// Pre-provided parameter data if populated
+	case_insensitive_map_t<BoundParameterData> &parameter_data;
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_data.hpp

@@ -9,7 +9,6 @@
 #pragma once
 
 #include "duckdb/common/types/value.hpp"
-#include "duckdb/planner/bound_parameter_map.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
 
 namespace duckdb {
@@ -40,21 +39,4 @@ public:
 	static shared_ptr<BoundParameterData> Deserialize(Deserializer &deserializer);
 };
 
-struct BoundParameterMap {
-	explicit BoundParameterMap(case_insensitive_map_t<BoundParameterData> &parameter_data)
-	    : parameter_data(parameter_data) {
-	}
-
-	bound_parameter_map_t parameters;
-	case_insensitive_map_t<BoundParameterData> &parameter_data;
-
-	LogicalType GetReturnType(const string &identifier) {
-		auto it = parameter_data.find(identifier);
-		if (it == parameter_data.end()) {
-			return LogicalTypeId::UNKNOWN;
-		}
-		return it->second.return_type;
-	}
-};
-
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_expression.hpp

@@ -9,7 +9,7 @@
 #pragma once
 
 #include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_data.hpp"
+#include "duckdb/planner/bound_parameter_map.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/planner/expression_binder/base_select_binder.hpp

@@ -21,6 +21,7 @@ class BoundSelectNode;
 struct BoundGroupInformation {
 	parsed_expression_map_t<idx_t> map;
 	case_insensitive_map_t<idx_t> alias_map;
+	unordered_map<idx_t, idx_t> collated_groups;
 };
 
 //! The BaseSelectBinder is the base binder of the SELECT, HAVING and QUALIFY binders. It can bind aggregates and window

package/src/duckdb/src/include/duckdb/planner/operator/logical_create_table.hpp

@@ -35,7 +35,6 @@ protected:
 	void ResolveTypes() override;
 
 private:
-	LogicalCreateTable(ClientContext &context, const string &catalog, const string &schema,
-	                   unique_ptr<CreateInfo> info);
+	LogicalCreateTable(ClientContext &context, unique_ptr<CreateInfo> info);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_delete.hpp

@@ -37,6 +37,6 @@ protected:
 	void ResolveTypes() override;
 
 private:
-	LogicalDelete(ClientContext &context, const string &catalog, const string &schema, const string &table);
+	LogicalDelete(ClientContext &context, const unique_ptr<CreateInfo> &table_info);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_insert.hpp

@@ -72,6 +72,6 @@ protected:
 	string GetName() const override;
 
 private:
-	LogicalInsert(ClientContext &context, const string &catalog, const string &schema, const string &table);
+	LogicalInsert(ClientContext &context, const unique_ptr<CreateInfo> table_info);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_update.hpp

@@ -42,6 +42,6 @@ protected:
 	void ResolveTypes() override;
 
 private:
-	LogicalUpdate(ClientContext &context, const string &catalog, const string &schema, const string &table);
+	LogicalUpdate(ClientContext &context, const unique_ptr<CreateInfo> &table_info);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/planner.hpp

@@ -11,7 +11,7 @@
 #include "duckdb/parser/sql_statement.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/expression/bound_parameter_data.hpp"
+#include "duckdb/planner/bound_parameter_map.hpp"
 
 namespace duckdb {
 class ClientContext;

package/src/duckdb/src/include/duckdb/storage/data_table.hpp

@@ -144,7 +144,7 @@ public:
 	//! Revert a set of appends made by the given AppendState, used to revert appends in the event of an error during
 	//! commit (e.g. because of an I/O exception)
 	void RevertAppend(idx_t start_row, idx_t count);
-	void RevertAppendInternal(idx_t start_row, idx_t count);
+	void RevertAppendInternal(idx_t start_row);
 
 	void ScanTableSegment(idx_t start_row, idx_t count, const std::function<void(DataChunk &chunk)> &function);
 

package/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp

@@ -73,7 +73,7 @@ public:
 	//! FinalizeAppend flushes an append with a variable number of rows.
 	void FinalizeAppend(TransactionData transaction, TableAppendState &state);
 	void CommitAppend(transaction_t commit_id, idx_t row_start, idx_t count);
-	void RevertAppendInternal(idx_t start_row, idx_t count);
+	void RevertAppendInternal(idx_t start_row);
 
 	void MergeStorage(RowGroupCollection &data);
 

package/src/duckdb/src/main/capi/prepared-c.cpp

@@ -124,10 +124,16 @@ duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_
 	}
 	LogicalType param_type;
 	auto identifier = std::to_string(param_idx);
-	if (!wrapper->statement->data->TryGetType(identifier, param_type)) {
-		return DUCKDB_TYPE_INVALID;
+	if (wrapper->statement->data->TryGetType(identifier, param_type)) {
+		return ConvertCPPTypeToC(param_type);
+	}
+	// The value_map is gone after executing the prepared statement
+	// See if this is the case and we still have a value registered for it
+	auto it = wrapper->values.find(identifier);
+	if (it != wrapper->values.end()) {
+		return ConvertCPPTypeToC(it->second.type());
 	}
-	return ConvertCPPTypeToC(param_type);
+	return DUCKDB_TYPE_INVALID;
 }
 
 duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement) {

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

@@ -119,6 +119,7 @@ BindResult ExpressionBinder::BindExpression(ComparisonExpression &expr, idx_t de
 	if (!error.empty()) {
 		return BindResult(error);
 	}
+
 	// the children have been successfully resolved
 	auto &left = BoundExpression::GetExpression(*expr.left);
 	auto &right = BoundExpression::GetExpression(*expr.right);

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

@@ -7,35 +7,25 @@
 namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(ParameterExpression &expr, idx_t depth) {
-	auto bound_parameter = make_uniq<BoundParameterExpression>(expr.identifier);
-	bound_parameter->alias = expr.alias;
 	if (!binder.parameters) {
 		throw BinderException("Unexpected prepared parameter. This type of statement can't be prepared!");
 	}
 	auto parameter_id = expr.identifier;
-	// check if a parameter value has already been supplied
-	if (binder.parameters->parameter_data.count(parameter_id)) {
+
+	D_ASSERT(binder.parameters);
+	// Check if a parameter value has already been supplied
+	auto &parameter_data = binder.parameters->GetParameterData();
+	auto param_data_it = parameter_data.find(parameter_id);
+	if (param_data_it != parameter_data.end()) {
 		// it has! emit a constant directly
-		auto &data = binder.parameters->parameter_data[parameter_id];
+		auto &data = param_data_it->second;
 		auto constant = make_uniq<BoundConstantExpression>(data.GetValue());
 		constant->alias = expr.alias;
+		constant->return_type = binder.parameters->GetReturnType(parameter_id);
 		return BindResult(std::move(constant));
 	}
 
-	auto entry = binder.parameters->parameters.find(parameter_id);
-	if (entry == binder.parameters->parameters.end()) {
-		// no entry yet: create a new one
-		auto data = make_shared<BoundParameterData>();
-		data->return_type = binder.parameters->GetReturnType(parameter_id);
-		bound_parameter->return_type = data->return_type;
-		bound_parameter->parameter_data = data;
-		binder.parameters->parameters[parameter_id] = std::move(data);
-	} else {
-		// a prepared statement with this parameter index was already there: use it
-		auto &data = entry->second;
-		bound_parameter->parameter_data = data;
-		bound_parameter->return_type = binder.parameters->GetReturnType(parameter_id);
-	}
+	auto bound_parameter = binder.parameters->BindParameterExpression(expr);
 	return BindResult(std::move(bound_parameter));
 }
 

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

@@ -1,25 +1,29 @@
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/function/aggregate/distributive_functions.hpp"
+#include "duckdb/function/function_binder.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/comparison_expression.hpp"
+#include "duckdb/parser/expression/conjunction_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/subquery_expression.hpp"
 #include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/parser/expression/subquery_expression.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/tableref/joinref.hpp"
 #include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression_binder/column_alias_binder.hpp"
 #include "duckdb/planner/expression_binder/constant_binder.hpp"
 #include "duckdb/planner/expression_binder/group_binder.hpp"
 #include "duckdb/planner/expression_binder/having_binder.hpp"
-#include "duckdb/planner/expression_binder/qualify_binder.hpp"
 #include "duckdb/planner/expression_binder/order_binder.hpp"
+#include "duckdb/planner/expression_binder/qualify_binder.hpp"
 #include "duckdb/planner/expression_binder/select_binder.hpp"
 #include "duckdb/planner/expression_binder/where_binder.hpp"
+#include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/parser/expression/conjunction_expression.hpp"
 
 namespace duckdb {
 
@@ -380,10 +384,28 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			auto bound_expr = group_binder.Bind(group_expressions[i], &group_type);
 			D_ASSERT(bound_expr->return_type.id() != LogicalTypeId::INVALID);
 
+			// find out whether the expression contains a subquery, it can't be copied if so
+			auto &bound_expr_ref = *bound_expr;
+			bool contains_subquery = bound_expr_ref.HasSubquery();
+
 			// push a potential collation, if necessary
-			bound_expr = ExpressionBinder::PushCollation(context, std::move(bound_expr),
-			                                             StringType::GetCollation(group_type), true);
-			result->groups.group_expressions.push_back(std::move(bound_expr));
+			auto collated_expr = ExpressionBinder::PushCollation(context, std::move(bound_expr),
+			                                                     StringType::GetCollation(group_type), true);
+			if (!contains_subquery && !collated_expr->Equals(bound_expr_ref)) {
+				// if there is a collation on a group x, we should group by the collated expr,
+				// but also push a first(x) aggregate in case x is selected (uncollated)
+				info.collated_groups[i] = result->aggregates.size();
+
+				auto first_fun = FirstFun::GetFunction(LogicalType::VARCHAR);
+				vector<unique_ptr<Expression>> first_children;
+				// FIXME: would be better to just refer to this expression, but for now we copy
+				first_children.push_back(bound_expr_ref.Copy());
+
+				FunctionBinder function_binder(context);
+				auto function = function_binder.BindAggregateFunction(first_fun, std::move(first_children));
+				result->aggregates.push_back(std::move(function));
+			}
+			result->groups.group_expressions.push_back(std::move(collated_expr));
 
 			// in the unbound expression we DO bind the table names of any ColumnRefs
 			// we do this to make sure that "table.a" and "a" are treated the same

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

@@ -39,6 +39,9 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 		if (!entry) {
 			break;
 		}
+		if (entry->internal) {
+			throw CatalogException("Cannot drop internal catalog entry \"%s\"!", entry->name);
+		}
 		stmt.info->catalog = entry->ParentCatalog().GetName();
 		if (!entry->temporary) {
 			// we can only drop temporary tables in read-only mode

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

@@ -0,0 +1,67 @@
+#include "duckdb/planner/bound_parameter_map.hpp"
+#include "duckdb/parser/expression/parameter_expression.hpp"
+#include "duckdb/planner/expression/bound_parameter_expression.hpp"
+
+namespace duckdb {
+
+BoundParameterMap::BoundParameterMap(case_insensitive_map_t<BoundParameterData> &parameter_data)
+    : parameter_data(parameter_data) {
+}
+
+LogicalType BoundParameterMap::GetReturnType(const string &identifier) {
+	D_ASSERT(!identifier.empty());
+	auto it = parameter_data.find(identifier);
+	if (it == parameter_data.end()) {
+		return LogicalTypeId::UNKNOWN;
+	}
+	return it->second.return_type;
+}
+
+bound_parameter_map_t *BoundParameterMap::GetParametersPtr() {
+	return &parameters;
+}
+
+const bound_parameter_map_t &BoundParameterMap::GetParameters() {
+	return parameters;
+}
+
+const case_insensitive_map_t<BoundParameterData> &BoundParameterMap::GetParameterData() {
+	return parameter_data;
+}
+
+shared_ptr<BoundParameterData> BoundParameterMap::CreateOrGetData(const string &identifier) {
+	auto entry = parameters.find(identifier);
+	if (entry == parameters.end()) {
+		// no entry yet: create a new one
+		auto data = make_shared<BoundParameterData>();
+		data->return_type = GetReturnType(identifier);
+
+		CreateNewParameter(identifier, data);
+		return data;
+	}
+	return entry->second;
+}
+
+unique_ptr<BoundParameterExpression> BoundParameterMap::BindParameterExpression(ParameterExpression &expr) {
+	auto &identifier = expr.identifier;
+	auto return_type = GetReturnType(identifier);
+
+	D_ASSERT(!parameter_data.count(identifier));
+
+	// No value has been supplied yet,
+	// We return a shared pointer to an object that will get populated wtih a Value later
+	// When the BoundParameterExpression get executed, this will be used to get the corresponding value
+	auto param_data = CreateOrGetData(identifier);
+	auto bound_expr = make_uniq<BoundParameterExpression>(identifier);
+	bound_expr->parameter_data = param_data;
+	bound_expr->return_type = return_type;
+	bound_expr->alias = expr.alias;
+	return bound_expr;
+}
+
+void BoundParameterMap::CreateNewParameter(const string &id, const shared_ptr<BoundParameterData> &param_data) {
+	D_ASSERT(!parameters.count(id));
+	parameters.emplace(std::make_pair(id, param_data));
+}
+
+} // namespace duckdb

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

@@ -1,15 +1,15 @@
 #include "duckdb/planner/expression_binder/base_select_binder.hpp"
 
+#include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/operator_expression.hpp"
 #include "duckdb/parser/expression/window_expression.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
+#include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_window_expression.hpp"
 #include "duckdb/planner/expression_binder/aggregate_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/planner/binder.hpp"
 
 namespace duckdb {
 
@@ -138,9 +138,17 @@ BindResult BaseSelectBinder::BindGroupingFunction(OperatorExpression &op, idx_t
 }
 
 BindResult BaseSelectBinder::BindGroup(ParsedExpression &expr, idx_t depth, idx_t group_index) {
-	auto &group = node.groups.group_expressions[group_index];
-	return BindResult(make_uniq<BoundColumnRefExpression>(expr.GetName(), group->return_type,
-	                                                      ColumnBinding(node.group_index, group_index), depth));
+	auto it = info.collated_groups.find(group_index);
+	if (it != info.collated_groups.end()) {
+		// This is an implicitly collated group, so we need to refer to the first() aggregate
+		const auto &aggr_index = it->second;
+		return BindResult(make_uniq<BoundColumnRefExpression>(expr.GetName(), node.aggregates[aggr_index]->return_type,
+		                                                      ColumnBinding(node.aggregate_index, aggr_index), depth));
+	} else {
+		auto &group = node.groups.group_expressions[group_index];
+		return BindResult(make_uniq<BoundColumnRefExpression>(expr.GetName(), group->return_type,
+		                                                      ColumnBinding(node.group_index, group_index), depth));
+	}
 }
 
 bool BaseSelectBinder::QualifyColumnAlias(const ColumnRefExpression &colref) {

package/src/duckdb/src/planner/operator/logical_create_table.cpp

@@ -6,9 +6,9 @@ LogicalCreateTable::LogicalCreateTable(SchemaCatalogEntry &schema, unique_ptr<Bo
     : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(schema), info(std::move(info)) {
 }
 
-LogicalCreateTable::LogicalCreateTable(ClientContext &context, const string &catalog, const string &schema,
-                                       unique_ptr<CreateInfo> unbound_info)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(Catalog::GetSchema(context, catalog, schema)) {
+LogicalCreateTable::LogicalCreateTable(ClientContext &context, unique_ptr<CreateInfo> unbound_info)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE),
+      schema(Catalog::GetSchema(context, unbound_info->catalog, unbound_info->schema)) {
 	D_ASSERT(unbound_info->type == CatalogType::TABLE_ENTRY);
 	auto binder = Binder::CreateBinder(context);
 	info = binder->BindCreateTableInfo(unique_ptr_cast<CreateInfo, CreateTableInfo>(std::move(unbound_info)));