duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/function/scalar/string/length.cpp

@@ -25,23 +25,6 @@ struct GraphemeCountOperator {
 	}
 };
 
-struct ArrayLengthOperator {
-	template <class TA, class TR>
-	static inline TR Operation(TA input) {
-		return input.length;
-	}
-};
-
-struct ArrayLengthBinaryOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA input, TB dimension) {
-		if (dimension != 1) {
-			throw NotImplementedException("array_length for dimensions other than 1 not implemented");
-		}
-		return input.length;
-	}
-};
-
 // strlen returns the size in bytes
 struct StrLenOperator {
 	template <class TA, class TR>
@@ -84,19 +67,137 @@ static unique_ptr<BaseStatistics> LengthPropagateStats(ClientContext &context, F
 	return nullptr;
 }
 
-static unique_ptr<FunctionData> ListLengthBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
+//------------------------------------------------------------------
+// ARRAY / LIST LENGTH
+//------------------------------------------------------------------
+
+static void ListLengthFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &input = args.data[0];
+	D_ASSERT(input.GetType().id() == LogicalTypeId::LIST);
+	UnaryExecutor::Execute<list_entry_t, int64_t>(input, result, args.size(),
+	                                              [](list_entry_t input) { return input.length; });
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+static void ArrayLengthFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &input = args.data[0];
+	// If the input is an array, the length is constant
+	result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	ConstantVector::GetData<int64_t>(result)[0] = static_cast<int64_t>(ArrayType::GetSize(input.GetType()));
+}
+
+static unique_ptr<FunctionData> ArrayOrListLengthBind(ClientContext &context, ScalarFunction &bound_function,
+                                                      vector<unique_ptr<Expression>> &arguments) {
 	if (arguments[0]->HasParameter()) {
 		throw ParameterNotResolvedException();
 	}
+	if (arguments[0]->return_type.id() == LogicalTypeId::ARRAY) {
+		bound_function.function = ArrayLengthFunction;
+	} else if (arguments[0]->return_type.id() == LogicalTypeId::LIST) {
+		bound_function.function = ListLengthFunction;
+	} else {
+		// Unreachable
+		throw BinderException("length can only be used on arrays or lists");
+	}
 	bound_function.arguments[0] = arguments[0]->return_type;
 	return nullptr;
 }
 
+//------------------------------------------------------------------
+// ARRAY / LIST WITH DIMENSION
+//------------------------------------------------------------------
+static void ListLengthBinaryFunction(DataChunk &args, ExpressionState &, Vector &result) {
+	auto type = args.data[0].GetType();
+	auto &input = args.data[0];
+	auto &dimension = args.data[1];
+	BinaryExecutor::Execute<list_entry_t, int64_t, int64_t>(
+	    input, dimension, result, args.size(), [](list_entry_t input, int64_t dimension) {
+		    if (dimension != 1) {
+			    throw NotImplementedException("array_length for lists with dimensions other than 1 not implemented");
+		    }
+		    return input.length;
+	    });
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+struct ArrayLengthBinaryFunctionData : public FunctionData {
+	vector<int64_t> dimensions;
+
+	unique_ptr<FunctionData> Copy() const override {
+		auto copy = make_uniq<ArrayLengthBinaryFunctionData>();
+		copy->dimensions = dimensions;
+		return std::move(copy);
+	}
+
+	bool Equals(const FunctionData &other) const override {
+		auto &other_data = other.Cast<const ArrayLengthBinaryFunctionData>();
+		return dimensions == other_data.dimensions;
+	}
+};
+
+static void ArrayLengthBinaryFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto type = args.data[0].GetType();
+	auto &dimension = args.data[1];
+
+	auto &expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &data = expr.bind_info->Cast<ArrayLengthBinaryFunctionData>();
+	auto &dimensions = data.dimensions;
+	auto max_dimension = static_cast<int64_t>(dimensions.size());
+
+	UnaryExecutor::Execute<int64_t, int64_t>(dimension, result, args.size(), [&](int64_t dimension) {
+		if (dimension < 1 || dimension > max_dimension) {
+			throw OutOfRangeException(StringUtil::Format(
+			    "array_length dimension '%lld' out of range (min: '1', max: '%lld')", dimension, max_dimension));
+		}
+		return dimensions[dimension - 1];
+	});
+
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+static unique_ptr<FunctionData> ArrayOrListLengthBinaryBind(ClientContext &context, ScalarFunction &bound_function,
+                                                            vector<unique_ptr<Expression>> &arguments) {
+	if (arguments[0]->HasParameter()) {
+		throw ParameterNotResolvedException();
+	}
+	auto type = arguments[0]->return_type;
+	if (type.id() == LogicalTypeId::ARRAY) {
+		bound_function.arguments[0] = type;
+		bound_function.function = ArrayLengthBinaryFunction;
+
+		// If the input is an array, the dimensions are constant, so we can calculate them at bind time
+		vector<int64_t> dimensions;
+		while (true) {
+			if (type.id() == LogicalTypeId::ARRAY) {
+				dimensions.push_back(ArrayType::GetSize(type));
+				type = ArrayType::GetChildType(type);
+			} else {
+				break;
+			}
+		}
+		auto data = make_uniq<ArrayLengthBinaryFunctionData>();
+		data->dimensions = dimensions;
+		return std::move(data);
+
+	} else if (type.id() == LogicalTypeId::LIST) {
+		bound_function.function = ListLengthBinaryFunction;
+		bound_function.arguments[0] = type;
+		return nullptr;
+	} else {
+		// Unreachable
+		throw BinderException("array_length can only be used on arrays or lists");
+	}
+}
+
 void LengthFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunction array_length_unary =
-	    ScalarFunction({LogicalType::LIST(LogicalType::ANY)}, LogicalType::BIGINT,
-	                   ScalarFunction::UnaryFunction<list_entry_t, int64_t, ArrayLengthOperator>, ListLengthBind);
+	    ScalarFunction({LogicalType::LIST(LogicalType::ANY)}, LogicalType::BIGINT, nullptr, ArrayOrListLengthBind);
 	ScalarFunctionSet length("length");
 	length.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BIGINT,
 	                                  ScalarFunction::UnaryFunction<string_t, int64_t, StringLengthOperator>, nullptr,
@@ -116,9 +217,8 @@ void LengthFun::RegisterFunction(BuiltinFunctions &set) {
 
 	ScalarFunctionSet array_length("array_length");
 	array_length.AddFunction(array_length_unary);
-	array_length.AddFunction(ScalarFunction(
-	    {LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT}, LogicalType::BIGINT,
-	    ScalarFunction::BinaryFunction<list_entry_t, int64_t, int64_t, ArrayLengthBinaryOperator>, ListLengthBind));
+	array_length.AddFunction(ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT},
+	                                        LogicalType::BIGINT, nullptr, ArrayOrListLengthBinaryBind));
 	set.AddFunction(array_length);
 
 	set.AddFunction(ScalarFunction("strlen", {LogicalType::VARCHAR}, LogicalType::BIGINT,

package/src/duckdb/src/function/scalar/string/regexp.cpp

@@ -55,7 +55,7 @@ RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, s
 	if (constant_pattern) {
 		auto pattern = make_uniq<RE2>(constant_string, options);
 		if (!pattern->ok()) {
-			throw Exception(pattern->error());
+			throw InvalidInputException(pattern->error());
 		}
 
 		range_success = pattern->PossibleMatchRange(&range_min, &range_max, 1000);
@@ -122,7 +122,7 @@ static void RegexpMatchesFunction(DataChunk &args, ExpressionState &state, Vecto
 		                                                  [&](string_t input, string_t pattern) {
 			                                                  RE2 re(CreateStringPiece(pattern), info.options);
 			                                                  if (!re.ok()) {
-				                                                  throw Exception(re.error());
+				                                                  throw InvalidInputException(re.error());
 			                                                  }
 			                                                  return OP::Operation(CreateStringPiece(input), re);
 		                                                  });
@@ -382,24 +382,24 @@ static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarF
 
 void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet regexp_full_match("regexp_full_match");
-	regexp_full_match.AddFunction(ScalarFunction(
-	    {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN, RegexpMatchesFunction<RegexFullMatch>,
-	    RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
-	    FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
-	regexp_full_match.AddFunction(ScalarFunction(
-	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	    RegexpMatchesFunction<RegexFullMatch>, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState,
-	    LogicalType::INVALID, FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	regexp_full_match.AddFunction(
+	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
+	                   RegexpMatchesFunction<RegexFullMatch>, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState,
+	                   LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
+	regexp_full_match.AddFunction(
+	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
+	                   RegexpMatchesFunction<RegexFullMatch>, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState,
+	                   LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
 
 	ScalarFunctionSet regexp_partial_match("regexp_matches");
 	regexp_partial_match.AddFunction(ScalarFunction(
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN, RegexpMatchesFunction<RegexPartialMatch>,
-	    RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
-	    FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	    RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID, FunctionStability::CONSISTENT,
+	    FunctionNullHandling::SPECIAL_HANDLING));
 	regexp_partial_match.AddFunction(ScalarFunction(
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
 	    RegexpMatchesFunction<RegexPartialMatch>, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState,
-	    LogicalType::INVALID, FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	    LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
 
 	ScalarFunctionSet regexp_replace("regexp_replace");
 	regexp_replace.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
@@ -410,43 +410,43 @@ void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	    RegexReplaceFunction, RegexReplaceBind, nullptr, nullptr, RegexInitLocalState));
 
 	ScalarFunctionSet regexp_extract("regexp_extract");
-	regexp_extract.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR, RegexExtractFunction,
-	                   RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
-	                   FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
-	regexp_extract.AddFunction(ScalarFunction(
-	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::VARCHAR, RegexExtractFunction,
-	    RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
-	    FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	regexp_extract.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	                                          RegexExtractFunction, RegexExtractBind, nullptr, nullptr,
+	                                          RegexInitLocalState, LogicalType::INVALID, FunctionStability::CONSISTENT,
+	                                          FunctionNullHandling::SPECIAL_HANDLING));
+	regexp_extract.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER},
+	                                          LogicalType::VARCHAR, RegexExtractFunction, RegexExtractBind, nullptr,
+	                                          nullptr, RegexInitLocalState, LogicalType::INVALID,
+	                                          FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
 	regexp_extract.AddFunction(ScalarFunction(
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	    RegexExtractFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
-	    FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	    FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
 	// REGEXP_EXTRACT(<string>, <pattern>, [<group 1 name>[, <group n name>]...])
 	regexp_extract.AddFunction(ScalarFunction(
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::LIST(LogicalType::VARCHAR)}, LogicalType::VARCHAR,
 	    RegexExtractStructFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
-	    FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	    FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
 	// REGEXP_EXTRACT(<string>, <pattern>, [<group 1 name>[, <group n name>]...], <options>)
 	regexp_extract.AddFunction(ScalarFunction(
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::LIST(LogicalType::VARCHAR), LogicalType::VARCHAR},
 	    LogicalType::VARCHAR, RegexExtractStructFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState,
-	    LogicalType::INVALID, FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	    LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
 
 	ScalarFunctionSet regexp_extract_all("regexp_extract_all");
 	regexp_extract_all.AddFunction(ScalarFunction(
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::LIST(LogicalType::VARCHAR),
 	    RegexpExtractAll::Execute, RegexpExtractAll::Bind, nullptr, nullptr, RegexpExtractAll::InitLocalState,
-	    LogicalType::INVALID, FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	    LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
 	regexp_extract_all.AddFunction(ScalarFunction(
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::LIST(LogicalType::VARCHAR),
 	    RegexpExtractAll::Execute, RegexpExtractAll::Bind, nullptr, nullptr, RegexpExtractAll::InitLocalState,
-	    LogicalType::INVALID, FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	    LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
 	regexp_extract_all.AddFunction(
 	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR},
 	                   LogicalType::LIST(LogicalType::VARCHAR), RegexpExtractAll::Execute, RegexpExtractAll::Bind,
 	                   nullptr, nullptr, RegexpExtractAll::InitLocalState, LogicalType::INVALID,
-	                   FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	                   FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING));
 
 	set.AddFunction(regexp_full_match);
 	set.AddFunction(regexp_partial_match);

package/src/duckdb/src/function/scalar/struct/struct_extract.cpp

@@ -8,21 +8,18 @@
 namespace duckdb {
 
 struct StructExtractBindData : public FunctionData {
-	StructExtractBindData(string key, idx_t index, LogicalType type)
-	    : key(std::move(key)), index(index), type(std::move(type)) {
+	explicit StructExtractBindData(idx_t index) : index(index) {
 	}
 
-	string key;
 	idx_t index;
-	LogicalType type;
 
 public:
 	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<StructExtractBindData>(key, index, type);
+		return make_uniq<StructExtractBindData>(index);
 	}
 	bool Equals(const FunctionData &other_p) const override {
 		auto &other = other_p.Cast<StructExtractBindData>();
-		return key == other.key && index == other.index && type == other.type;
+		return index == other.index;
 	}
 };
 
@@ -44,15 +41,20 @@ 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) {
+	auto &child_type = arguments[0]->return_type;
+	if (child_type.id() == LogicalTypeId::UNKNOWN) {
 		throw ParameterNotResolvedException();
 	}
-	D_ASSERT(LogicalTypeId::STRUCT == arguments[0]->return_type.id());
-	auto &struct_children = StructType::GetChildTypes(arguments[0]->return_type);
+	D_ASSERT(LogicalTypeId::STRUCT == child_type.id());
+	auto &struct_children = StructType::GetChildTypes(child_type);
 	if (struct_children.empty()) {
 		throw InternalException("Can't extract something from an empty struct");
 	}
-	bound_function.arguments[0] = arguments[0]->return_type;
+	if (StructType::IsUnnamed(child_type)) {
+		throw BinderException(
+		    "struct_extract with a string key cannot be used on an unnamed struct, use a numeric index instead");
+	}
+	bound_function.arguments[0] = child_type;
 
 	auto &key_child = arguments[1];
 	if (key_child->HasParameter()) {
@@ -95,8 +97,44 @@ static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, Scalar
 		throw BinderException("Could not find key \"%s\" in struct\n%s", key, message);
 	}
 
-	bound_function.return_type = return_type;
-	return make_uniq<StructExtractBindData>(std::move(key), key_index, std::move(return_type));
+	bound_function.return_type = std::move(return_type);
+	return make_uniq<StructExtractBindData>(key_index);
+}
+
+static unique_ptr<FunctionData> StructExtractBindIndex(ClientContext &context, ScalarFunction &bound_function,
+                                                       vector<unique_ptr<Expression>> &arguments) {
+	D_ASSERT(bound_function.arguments.size() == 2);
+	auto &child_type = arguments[0]->return_type;
+	if (child_type.id() == LogicalTypeId::UNKNOWN) {
+		throw ParameterNotResolvedException();
+	}
+	D_ASSERT(LogicalTypeId::STRUCT == child_type.id());
+	auto &struct_children = StructType::GetChildTypes(child_type);
+	if (struct_children.empty()) {
+		throw InternalException("Can't extract something from an empty struct");
+	}
+	if (!StructType::IsUnnamed(child_type)) {
+		throw BinderException(
+		    "struct_extract with an integer key can only be used on unnamed structs, use a string key instead");
+	}
+	bound_function.arguments[0] = child_type;
+
+	auto &key_child = arguments[1];
+	if (key_child->HasParameter()) {
+		throw ParameterNotResolvedException();
+	}
+
+	if (!key_child->IsFoldable()) {
+		throw BinderException("Key index for struct_extract needs to be a constant value");
+	}
+	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child);
+	auto index = key_val.GetValue<int64_t>();
+	if (index <= 0 || idx_t(index) > struct_children.size()) {
+		throw BinderException("Key index %lld for struct_extract out of range - expected an index between 1 and %llu",
+		                      index, struct_children.size());
+	}
+	bound_function.return_type = struct_children[index - 1].second;
+	return make_uniq<StructExtractBindData>(index - 1);
 }
 
 static unique_ptr<BaseStatistics> PropagateStructExtractStats(ClientContext &context, FunctionStatisticsInput &input) {
@@ -108,15 +146,26 @@ static unique_ptr<BaseStatistics> PropagateStructExtractStats(ClientContext &con
 	return struct_child_stats[info.index].ToUnique();
 }
 
-ScalarFunction StructExtractFun::GetFunction() {
+ScalarFunction StructExtractFun::KeyExtractFunction() {
 	return ScalarFunction("struct_extract", {LogicalTypeId::STRUCT, LogicalType::VARCHAR}, LogicalType::ANY,
 	                      StructExtractFunction, StructExtractBind, nullptr, PropagateStructExtractStats);
 }
 
+ScalarFunction StructExtractFun::IndexExtractFunction() {
+	return ScalarFunction("struct_extract", {LogicalTypeId::STRUCT, LogicalType::BIGINT}, LogicalType::ANY,
+	                      StructExtractFunction, StructExtractBindIndex);
+}
+
+ScalarFunctionSet StructExtractFun::GetFunctions() {
+	ScalarFunctionSet functions("struct_extract");
+	functions.AddFunction(KeyExtractFunction());
+	functions.AddFunction(IndexExtractFunction());
+	return functions;
+}
+
 void StructExtractFun::RegisterFunction(BuiltinFunctions &set) {
 	// the arguments and return types are actually set in the binder function
-	auto fun = GetFunction();
-	set.AddFunction(fun);
+	set.AddFunction(GetFunctions());
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -171,7 +171,7 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 		memcpy(local_state.state_buffer0.get(), state0.GetData(), bind_data.state_size);
 		memcpy(local_state.state_buffer1.get(), state1.GetData(), bind_data.state_size);
 
-		AggregateInputData aggr_input_data(nullptr, local_state.allocator);
+		AggregateInputData aggr_input_data(nullptr, local_state.allocator, AggregateCombineType::ALLOW_DESTRUCTIVE);
 		bind_data.aggr.combine(local_state.state_vector0, local_state.state_vector1, aggr_input_data, 1);
 
 		result_ptr[i] = StringVector::AddStringOrBlob(result, const_char_ptr_cast(local_state.state_buffer1.get()),
@@ -213,13 +213,14 @@ static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, Scala
 	}
 	auto &aggr = func.Cast<AggregateFunctionCatalogEntry>();
 
-	string error;
+	ErrorData error;
 
 	FunctionBinder function_binder(context);
 	idx_t best_function =
 	    function_binder.BindFunction(aggr.name, aggr.functions, state_type.bound_argument_types, error);
 	if (best_function == DConstants::INVALID_INDEX) {
-		throw InternalException("Could not re-bind exported aggregate %s: %s", state_type.function_name, error);
+		throw InternalException("Could not re-bind exported aggregate %s: %s", state_type.function_name,
+		                        error.Message());
 	}
 	auto bound_aggr = aggr.functions.GetFunctionByOffset(best_function);
 	if (bound_aggr.bind) {

package/src/duckdb/src/function/scalar_function.cpp

@@ -8,26 +8,27 @@ FunctionLocalState::~FunctionLocalState() {
 ScalarFunction::ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
                                scalar_function_t function, bind_scalar_function_t bind,
                                dependency_function_t dependency, function_statistics_t statistics,
-                               init_local_state_t init_local_state, LogicalType varargs,
-                               FunctionSideEffects side_effects, FunctionNullHandling null_handling)
+                               init_local_state_t init_local_state, LogicalType varargs, FunctionStability side_effects,
+                               FunctionNullHandling null_handling, bind_lambda_function_t bind_lambda)
     : BaseScalarFunction(std::move(name), std::move(arguments), std::move(return_type), side_effects,
                          std::move(varargs), null_handling),
       function(std::move(function)), bind(bind), init_local_state(init_local_state), dependency(dependency),
-      statistics(statistics), serialize(nullptr), deserialize(nullptr) {
+      statistics(statistics), bind_lambda(bind_lambda), serialize(nullptr), deserialize(nullptr) {
 }
 
 ScalarFunction::ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
                                bind_scalar_function_t bind, dependency_function_t dependency,
                                function_statistics_t statistics, init_local_state_t init_local_state,
-                               LogicalType varargs, FunctionSideEffects side_effects,
-                               FunctionNullHandling null_handling)
+                               LogicalType varargs, FunctionStability side_effects, FunctionNullHandling null_handling,
+                               bind_lambda_function_t bind_lambda)
     : ScalarFunction(string(), std::move(arguments), std::move(return_type), std::move(function), bind, dependency,
-                     statistics, init_local_state, std::move(varargs), side_effects, null_handling) {
+                     statistics, init_local_state, std::move(varargs), side_effects, null_handling, bind_lambda) {
 }
 
 bool ScalarFunction::operator==(const ScalarFunction &rhs) const {
 	return name == rhs.name && arguments == rhs.arguments && return_type == rhs.return_type && varargs == rhs.varargs &&
-	       bind == rhs.bind && dependency == rhs.dependency && statistics == rhs.statistics;
+	       bind == rhs.bind && dependency == rhs.dependency && statistics == rhs.statistics &&
+	       bind_lambda == rhs.bind_lambda;
 }
 
 bool ScalarFunction::operator!=(const ScalarFunction &rhs) const {

package/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp

@@ -36,6 +36,18 @@ const ArrowType &ArrowType::GetDictionary() const {
 	return *dictionary_type;
 }
 
+void ArrowType::SetRunEndEncoded() {
+	D_ASSERT(children.size() == 2);
+	auto actual_type = children[1]->GetDuckType();
+	// Override the duckdb type to the actual type
+	type = actual_type;
+	run_end_encoded = true;
+}
+
+bool ArrowType::RunEndEncoded() const {
+	return run_end_encoded;
+}
+
 LogicalType ArrowType::GetDuckType(bool use_dictionary) const {
 	if (use_dictionary && dictionary_type) {
 		return dictionary_type->GetDuckType();

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

@@ -137,6 +137,23 @@ static unique_ptr<ArrowType> GetArrowLogicalTypeNoDictionary(ArrowSchema &schema
 		auto union_type = make_uniq<ArrowType>(LogicalType::UNION(members));
 		union_type->AssignChildren(std::move(children));
 		return union_type;
+	} else if (format == "+r") {
+		child_list_t<LogicalType> members;
+		vector<unique_ptr<ArrowType>> children;
+		idx_t n_children = idx_t(schema.n_children);
+		D_ASSERT(n_children == 2);
+		D_ASSERT(string(schema.children[0]->name) == "run_ends");
+		D_ASSERT(string(schema.children[1]->name) == "values");
+		for (idx_t i = 0; i < n_children; i++) {
+			auto type = schema.children[i];
+			children.emplace_back(ArrowTableFunction::GetArrowLogicalType(*type));
+			members.emplace_back(type->name, children.back()->GetDuckType());
+		}
+
+		auto struct_type = make_uniq<ArrowType>(LogicalType::STRUCT(members));
+		struct_type->AssignChildren(std::move(children));
+		struct_type->SetRunEndEncoded();
+		return struct_type;
 	} else if (format == "+m") {
 		auto &arrow_struct_type = *schema.children[0];
 		D_ASSERT(arrow_struct_type.n_children == 2);
@@ -193,30 +210,6 @@ unique_ptr<ArrowType> ArrowTableFunction::GetArrowLogicalType(ArrowSchema &schem
 	return arrow_type;
 }
 
-void ArrowTableFunction::RenameArrowColumns(vector<string> &names) {
-	unordered_map<string, idx_t> name_map;
-	for (auto &column_name : names) {
-		// put it all lower_case
-		auto low_column_name = StringUtil::Lower(column_name);
-		if (name_map.find(low_column_name) == name_map.end()) {
-			// Name does not exist yet
-			name_map[low_column_name]++;
-		} else {
-			// Name already exists, we add _x where x is the repetition number
-			string new_column_name = column_name + "_" + std::to_string(name_map[low_column_name]);
-			auto new_column_name_low = StringUtil::Lower(new_column_name);
-			while (name_map.find(new_column_name_low) != name_map.end()) {
-				// This name is already here due to a previous definition
-				name_map[low_column_name]++;
-				new_column_name = column_name + "_" + std::to_string(name_map[low_column_name]);
-				new_column_name_low = StringUtil::Lower(new_column_name);
-			}
-			column_name = new_column_name;
-			name_map[new_column_name_low]++;
-		}
-	}
-}
-
 void ArrowTableFunction::PopulateArrowTableType(ArrowTableType &arrow_table, ArrowSchemaWrapper &schema_p,
                                                 vector<string> &names, vector<LogicalType> &return_types) {
 	for (idx_t col_idx = 0; col_idx < (idx_t)schema_p.arrow_schema.n_children; col_idx++) {
@@ -249,9 +242,9 @@ unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &contex
 	auto res = make_uniq<ArrowScanFunctionData>(stream_factory_produce, stream_factory_ptr);
 
 	auto &data = *res;
-	stream_factory_get_schema(stream_factory_ptr, data.schema_root);
+	stream_factory_get_schema(reinterpret_cast<ArrowArrayStream *>(stream_factory_ptr), data.schema_root.arrow_schema);
 	PopulateArrowTableType(res->arrow_table, data.schema_root, names, return_types);
-	RenameArrowColumns(names);
+	QueryResult::DeduplicateColumns(names);
 	res->all_types = return_types;
 	return std::move(res);
 }
@@ -284,7 +277,7 @@ bool ArrowTableFunction::ArrowScanParallelStateNext(ClientContext &context, cons
 	if (parallel_state.done) {
 		return false;
 	}
-	state.chunk_offset = 0;
+	state.Reset();
 	state.batch_index = ++parallel_state.batch_index;
 
 	auto current_chunk = parallel_state.stream->GetNextChunk();