duckdb 0.3.1-dev247.0 → 0.3.1-dev283.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.1-dev247.0",
+  "version": "0.3.1-dev283.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -71414,10 +71414,10 @@ template <class OP, class T>
 AggregateFunction GetArgMinMaxFunctionArg2(LogicalTypeId arg_2, const LogicalType &arg) {
 	switch (arg_2) {
 	case LogicalTypeId::INTEGER:
-		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, int>, T, int, T, OP>(arg, LogicalType::INTEGER,
-		                                                                                 arg);
+		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, int32_t>, T, int32_t, T, OP>(
+		    arg, LogicalType::INTEGER, arg);
 	case LogicalTypeId::BIGINT:
-		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, uint64_t>, T, uint64_t, T, OP>(
+		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, int64_t>, T, int64_t, T, OP>(
 		    arg, LogicalType::BIGINT, arg);
 	case LogicalTypeId::DOUBLE:
 		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, double>, T, double, T, OP>(arg, LogicalType::DOUBLE,
@@ -71426,10 +71426,10 @@ AggregateFunction GetArgMinMaxFunctionArg2(LogicalTypeId arg_2, const LogicalTyp
 		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, string_t>, T, string_t, T, OP>(
 		    arg, LogicalType::VARCHAR, arg);
 	case LogicalTypeId::DATE:
-		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, uint64_t>, T, uint64_t, T, OP>(
-		    arg, LogicalType::DATE, arg);
+		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, date_t>, T, date_t, T, OP>(arg, LogicalType::DATE,
+		                                                                                       arg);
 	case LogicalTypeId::TIMESTAMP:
-		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, uint64_t>, T, uint64_t, T, OP>(
+		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, timestamp_t>, T, timestamp_t, T, OP>(
 		    arg, LogicalType::TIMESTAMP, arg);
 	case LogicalTypeId::BLOB:
 		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, string_t>, T, string_t, T, OP>(
@@ -71443,13 +71443,13 @@ template <class OP>
 void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 	switch (arg_1) {
 	case LogicalTypeId::INTEGER:
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int>(LogicalTypeId::INTEGER, LogicalType::INTEGER));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int>(LogicalTypeId::BIGINT, LogicalType::INTEGER));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int>(LogicalTypeId::DOUBLE, LogicalType::INTEGER));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int>(LogicalTypeId::VARCHAR, LogicalType::INTEGER));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int>(LogicalTypeId::DATE, LogicalType::INTEGER));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int>(LogicalTypeId::TIMESTAMP, LogicalType::INTEGER));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int>(LogicalTypeId::BLOB, LogicalType::INTEGER));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::INTEGER, LogicalType::INTEGER));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::BIGINT, LogicalType::INTEGER));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::DOUBLE, LogicalType::INTEGER));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::VARCHAR, LogicalType::INTEGER));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::DATE, LogicalType::INTEGER));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::TIMESTAMP, LogicalType::INTEGER));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::BLOB, LogicalType::INTEGER));
 		break;
 	case LogicalTypeId::BIGINT:
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::INTEGER, LogicalType::BIGINT));
@@ -71479,22 +71479,22 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::BLOB, LogicalType::VARCHAR));
 		break;
 	case LogicalTypeId::DATE:
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::INTEGER, LogicalType::DATE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::BIGINT, LogicalType::DATE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::DOUBLE, LogicalType::DATE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::VARCHAR, LogicalType::DATE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::DATE, LogicalType::DATE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::TIMESTAMP, LogicalType::DATE));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::BLOB, LogicalType::DATE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::INTEGER, LogicalType::DATE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::BIGINT, LogicalType::DATE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DOUBLE, LogicalType::DATE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::VARCHAR, LogicalType::DATE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DATE, LogicalType::DATE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::TIMESTAMP, LogicalType::DATE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::BLOB, LogicalType::DATE));
 		break;
 	case LogicalTypeId::TIMESTAMP:
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::INTEGER, LogicalType::TIMESTAMP));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::BIGINT, LogicalType::TIMESTAMP));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::DOUBLE, LogicalType::TIMESTAMP));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::VARCHAR, LogicalType::TIMESTAMP));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::DATE, LogicalType::TIMESTAMP));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::TIMESTAMP, LogicalType::TIMESTAMP));
-		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::BLOB, LogicalType::TIMESTAMP));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::INTEGER, LogicalType::TIMESTAMP));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::BIGINT, LogicalType::TIMESTAMP));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DOUBLE, LogicalType::TIMESTAMP));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::VARCHAR, LogicalType::TIMESTAMP));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DATE, LogicalType::TIMESTAMP));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::TIMESTAMP, LogicalType::TIMESTAMP));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::BLOB, LogicalType::TIMESTAMP));
 		break;
 	case LogicalTypeId::BLOB:
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::INTEGER, LogicalType::BLOB));
@@ -74834,9 +74834,15 @@ hugeint_t operator*(const hugeint_t &h, const double &d) {
 
 using FrameBounds = std::pair<idx_t, idx_t>;
 
+template <typename SAVE_TYPE>
 struct QuantileState {
-	data_ptr_t v;
-	idx_t len;
+	using SaveType = SAVE_TYPE;
+
+	// Regular aggregation
+	std::vector<SaveType> v;
+
+	// Windowed Aggregation
+	std::vector<idx_t> w;
 	idx_t pos;
 
 	// List temporaries
@@ -74844,26 +74850,17 @@ struct QuantileState {
 	std::vector<idx_t> lower;
 	std::vector<idx_t> upper;
 
-	QuantileState() : v(nullptr), len(0), pos(0) {
+	QuantileState() : pos(0) {
 	}
 
 	~QuantileState() {
-		if (v) {
-			free(v);
-			v = nullptr;
-		}
 	}
 
-	template <typename T>
-	void Resize(idx_t new_len) {
-		if (new_len <= len) {
-			return;
-		}
-		v = (data_ptr_t)realloc(v, new_len * sizeof(T));
-		if (!v) {
-			throw InternalException("Memory allocation failure");
+	inline void SetPos(size_t pos_p) {
+		pos = pos_p;
+		if (pos >= w.size()) {
+			w.resize(pos);
 		}
-		len = new_len;
 	}
 };
 
@@ -74902,10 +74899,8 @@ void ReuseIndexes(idx_t *index, const FrameBounds &frame, const FrameBounds &pre
 	}
 }
 
-template <class STATE>
-static idx_t ReplaceIndex(STATE *state, const FrameBounds &frame, const FrameBounds &prev) {
-	D_ASSERT(state->v);
-	auto index = (idx_t *)state->v;
+static idx_t ReplaceIndex(idx_t *index, const FrameBounds &frame, const FrameBounds &prev) {
+	D_ASSERT(index);
 
 	idx_t j = 0;
 	for (idx_t p = 0; p < (prev.second - prev.first); ++p) {
@@ -74923,12 +74918,12 @@ static idx_t ReplaceIndex(STATE *state, const FrameBounds &frame, const FrameBou
 	return j;
 }
 
-template <class INPUT_TYPE, class STATE>
-static inline bool CanReplace(STATE *state, const INPUT_TYPE *fdata, const idx_t j, const idx_t k0, const idx_t k1) {
+template <class INPUT_TYPE>
+static inline bool CanReplace(const idx_t *index, const INPUT_TYPE *fdata, const idx_t j, const idx_t k0,
+                              const idx_t k1) {
 	auto same = false;
 
-	D_ASSERT(state->v);
-	auto index = (idx_t *)state->v;
+	D_ASSERT(index);
 
 	auto curr = fdata[index[j]];
 	if (k1 < j) {
@@ -74965,31 +74960,44 @@ struct IndirectLess {
 	const INPUT_TYPE *inputs;
 };
 
+struct CastInterpolation {
+
+	template <class INPUT_TYPE, class TARGET_TYPE>
+	static TARGET_TYPE Cast(const INPUT_TYPE &src, Vector &result) {
+		return Cast::Operation<INPUT_TYPE, TARGET_TYPE>(src);
+	}
+};
+
+template <>
+string_t CastInterpolation::Cast(const std::string &src, Vector &result) {
+	return StringVector::AddString(result, src);
+}
+
 template <class INPUT_TYPE, class TARGET_TYPE, bool DISCRETE>
 struct Interpolator {
 	Interpolator(const double q, const idx_t n_p) : n(n_p), RN((double)(n_p - 1) * q), FRN(floor(RN)), CRN(ceil(RN)) {
 	}
 
-	TARGET_TYPE operator()(INPUT_TYPE *v_t) const {
+	TARGET_TYPE operator()(INPUT_TYPE *v_t, Vector &result) const {
 		if (CRN == FRN) {
 			std::nth_element(v_t, v_t + FRN, v_t + n);
-			return Cast::Operation<INPUT_TYPE, TARGET_TYPE>(v_t[FRN]);
+			return CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(v_t[FRN], result);
 		} else {
 			std::nth_element(v_t, v_t + FRN, v_t + n);
 			std::nth_element(v_t + FRN, v_t + CRN, v_t + n);
-			auto lo = Cast::Operation<INPUT_TYPE, TARGET_TYPE>(v_t[FRN]);
-			auto hi = Cast::Operation<INPUT_TYPE, TARGET_TYPE>(v_t[CRN]);
+			auto lo = CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(v_t[FRN], result);
+			auto hi = CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(v_t[CRN], result);
 			auto delta = hi - lo;
 			return lo + delta * (RN - FRN);
 		}
 	}
 
-	TARGET_TYPE operator()(const INPUT_TYPE *v_t, const idx_t *index) const {
+	TARGET_TYPE operator()(const INPUT_TYPE *v_t, const idx_t *index, Vector &result) const {
 		if (CRN == FRN) {
-			return Cast::Operation<INPUT_TYPE, TARGET_TYPE>(v_t[index[FRN]]);
+			return CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(v_t[index[FRN]], result);
 		} else {
-			auto lo = Cast::Operation<INPUT_TYPE, TARGET_TYPE>(v_t[index[FRN]]);
-			auto hi = Cast::Operation<INPUT_TYPE, TARGET_TYPE>(v_t[index[CRN]]);
+			auto lo = CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(v_t[index[FRN]], result);
+			auto hi = CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(v_t[index[CRN]], result);
 			auto delta = hi - lo;
 			return lo + delta * (RN - FRN);
 		}
@@ -75006,13 +75014,13 @@ struct Interpolator<INPUT_TYPE, TARGET_TYPE, true> {
 	Interpolator(const double q, const idx_t n_p) : n(n_p), RN((double)(n_p - 1) * q), FRN(floor(RN)), CRN(FRN) {
 	}
 
-	TARGET_TYPE operator()(INPUT_TYPE *v_t) const {
+	TARGET_TYPE operator()(INPUT_TYPE *v_t, Vector &result) const {
 		std::nth_element(v_t, v_t + FRN, v_t + n);
-		return Cast::Operation<INPUT_TYPE, TARGET_TYPE>(v_t[FRN]);
+		return CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(v_t[FRN], result);
 	}
 
-	TARGET_TYPE operator()(const INPUT_TYPE *v_t, const idx_t *index) {
-		return Cast::Operation<INPUT_TYPE, TARGET_TYPE>(v_t[index[FRN]]);
+	TARGET_TYPE operator()(const INPUT_TYPE *v_t, const idx_t *index, Vector &result) {
+		return CastInterpolation::Cast<INPUT_TYPE, TARGET_TYPE>(v_t[index[FRN]], result);
 	}
 
 	const idx_t n;
@@ -75047,7 +75055,6 @@ struct QuantileBindData : public FunctionData {
 	vector<idx_t> order;
 };
 
-template <typename SAVE_TYPE>
 struct QuantileOperation {
 	template <class STATE>
 	static void Initialize(STATE *state) {
@@ -75064,22 +75071,15 @@ struct QuantileOperation {
 
 	template <class INPUT_TYPE, class STATE, class OP>
 	static void Operation(STATE *state, FunctionData *bind_data_p, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
-		if (state->pos == state->len) {
-			// growing conservatively here since we could be running this on many small groups
-			state->template Resize<SAVE_TYPE>(state->len == 0 ? 1 : state->len * 2);
-		}
-		D_ASSERT(state->v);
-		((SAVE_TYPE *)state->v)[state->pos++] = data[idx];
+		state->v.emplace_back(data[idx]);
 	}
 
 	template <class STATE, class OP>
 	static void Combine(const STATE &source, STATE *target) {
-		if (source.pos == 0) {
+		if (source.v.empty()) {
 			return;
 		}
-		target->template Resize<SAVE_TYPE>(target->pos + source.pos);
-		memcpy(target->v + target->pos * sizeof(SAVE_TYPE), source.v, source.pos * sizeof(SAVE_TYPE));
-		target->pos += source.pos;
+		target->v.insert(target->v.end(), source.v.begin(), source.v.end());
 	}
 
 	template <class STATE>
@@ -75134,23 +75134,21 @@ static AggregateFunction QuantileListAggregate(const LogicalType &input_type, co
 	    AggregateFunction::StateDestroy<STATE, OP>);
 }
 
-template <class SAVE_TYPE, bool DISCRETE>
-struct QuantileScalarOperation : public QuantileOperation<SAVE_TYPE> {
+template <bool DISCRETE>
+struct QuantileScalarOperation : public QuantileOperation {
 
 	template <class RESULT_TYPE, class STATE>
 	static void Finalize(Vector &result, FunctionData *bind_data_p, STATE *state, RESULT_TYPE *target,
 	                     ValidityMask &mask, idx_t idx) {
-		if (state->pos == 0) {
+		if (state->v.empty()) {
 			mask.SetInvalid(idx);
 			return;
 		}
-		D_ASSERT(state->v);
 		D_ASSERT(bind_data_p);
 		auto bind_data = (QuantileBindData *)bind_data_p;
 		D_ASSERT(bind_data->quantiles.size() == 1);
-		Interpolator<SAVE_TYPE, RESULT_TYPE, DISCRETE> interp(bind_data->quantiles[0], state->pos);
-		auto v_t = (SAVE_TYPE *)state->v;
-		target[idx] = interp(v_t);
+		Interpolator<typename STATE::SaveType, RESULT_TYPE, DISCRETE> interp(bind_data->quantiles[0], state->v.size());
+		target[idx] = interp(state->v.data(), result);
 	}
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
@@ -75161,11 +75159,10 @@ struct QuantileScalarOperation : public QuantileOperation<SAVE_TYPE> {
 
 		//  Lazily initialise frame state
 		const auto prev_valid = state->pos == (prev.second - prev.first);
-		state->pos = frame.second - frame.first;
-		state->template Resize<idx_t>(state->pos);
+		state->SetPos(frame.second - frame.first);
 
-		D_ASSERT(state->v);
-		auto index = (idx_t *)state->v;
+		auto index = state->w.data();
+		D_ASSERT(index);
 
 		D_ASSERT(bind_data_p);
 		auto bind_data = (QuantileBindData *)bind_data_p;
@@ -75176,15 +75173,16 @@ struct QuantileScalarOperation : public QuantileOperation<SAVE_TYPE> {
 		bool same = false;
 		if (prev_valid && dmask.AllValid() && frame.first == prev.first + 1 && frame.second == prev.second + 1) {
 			//  Fixed frame size
-			const auto j = ReplaceIndex(state, frame, prev);
+			const auto j = ReplaceIndex(index, frame, prev);
 			Interpolator<INPUT_TYPE, RESULT_TYPE, DISCRETE> interp(q, state->pos);
-			same = CanReplace(state, data, j, interp.FRN, interp.CRN);
+			same = CanReplace(index, data, j, interp.FRN, interp.CRN);
 		} else {
 			ReuseIndexes(index, frame, prev);
 		}
 
 		if (!same) {
 			if (!dmask.AllValid()) {
+				// Remove the NULLs
 				IndirectNotNull not_null(dmask, MinValue(frame.first, prev.first));
 				state->pos = std::partition(index, index + state->pos, not_null) - index;
 			}
@@ -75195,21 +75193,21 @@ struct QuantileScalarOperation : public QuantileOperation<SAVE_TYPE> {
 				if (interp.CRN != interp.FRN) {
 					std::nth_element(index + interp.CRN, index + interp.CRN, index + interp.n, lt);
 				}
-				rdata[ridx] = interp(data, index);
+				rdata[ridx] = interp(data, index, result);
 			} else {
 				rmask.Set(ridx, false);
 			}
 		} else {
 			Interpolator<INPUT_TYPE, RESULT_TYPE, DISCRETE> interp(q, state->pos);
-			rdata[ridx] = interp(data, index);
+			rdata[ridx] = interp(data, index, result);
 		}
 	}
 };
 
-template <typename INPUT_TYPE>
+template <typename INPUT_TYPE, typename SAVED_TYPE>
 AggregateFunction GetTypedDiscreteQuantileAggregateFunction(const LogicalType &type) {
-	using STATE = QuantileState;
-	using OP = QuantileScalarOperation<INPUT_TYPE, true>;
+	using STATE = QuantileState<SAVED_TYPE>;
+	using OP = QuantileScalarOperation<true>;
 	auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, INPUT_TYPE, OP>(type, type);
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, INPUT_TYPE, OP>;
 	return fun;
@@ -75218,56 +75216,59 @@ AggregateFunction GetTypedDiscreteQuantileAggregateFunction(const LogicalType &t
 AggregateFunction GetDiscreteQuantileAggregateFunction(const LogicalType &type) {
 	switch (type.id()) {
 	case LogicalTypeId::TINYINT:
-		return GetTypedDiscreteQuantileAggregateFunction<int8_t>(type);
+		return GetTypedDiscreteQuantileAggregateFunction<int8_t, int8_t>(type);
 	case LogicalTypeId::SMALLINT:
-		return GetTypedDiscreteQuantileAggregateFunction<int16_t>(type);
+		return GetTypedDiscreteQuantileAggregateFunction<int16_t, int16_t>(type);
 	case LogicalTypeId::INTEGER:
-		return GetTypedDiscreteQuantileAggregateFunction<int32_t>(type);
+		return GetTypedDiscreteQuantileAggregateFunction<int32_t, int32_t>(type);
 	case LogicalTypeId::BIGINT:
-		return GetTypedDiscreteQuantileAggregateFunction<int64_t>(type);
+		return GetTypedDiscreteQuantileAggregateFunction<int64_t, int64_t>(type);
 	case LogicalTypeId::HUGEINT:
-		return GetTypedDiscreteQuantileAggregateFunction<hugeint_t>(type);
+		return GetTypedDiscreteQuantileAggregateFunction<hugeint_t, hugeint_t>(type);
 
 	case LogicalTypeId::FLOAT:
-		return GetTypedDiscreteQuantileAggregateFunction<float>(type);
+		return GetTypedDiscreteQuantileAggregateFunction<float, float>(type);
 	case LogicalTypeId::DOUBLE:
-		return GetTypedDiscreteQuantileAggregateFunction<double>(type);
+		return GetTypedDiscreteQuantileAggregateFunction<double, double>(type);
 	case LogicalTypeId::DECIMAL:
 		switch (type.InternalType()) {
 		case PhysicalType::INT16:
-			return GetTypedDiscreteQuantileAggregateFunction<int16_t>(type);
+			return GetTypedDiscreteQuantileAggregateFunction<int16_t, int16_t>(type);
 		case PhysicalType::INT32:
-			return GetTypedDiscreteQuantileAggregateFunction<int32_t>(type);
+			return GetTypedDiscreteQuantileAggregateFunction<int32_t, int32_t>(type);
 		case PhysicalType::INT64:
-			return GetTypedDiscreteQuantileAggregateFunction<int64_t>(type);
+			return GetTypedDiscreteQuantileAggregateFunction<int64_t, int64_t>(type);
 		case PhysicalType::INT128:
-			return GetTypedDiscreteQuantileAggregateFunction<hugeint_t>(type);
+			return GetTypedDiscreteQuantileAggregateFunction<hugeint_t, hugeint_t>(type);
 		default:
 			throw NotImplementedException("Unimplemented discrete quantile aggregate");
 		}
 		break;
 
 	case LogicalTypeId::DATE:
-		return GetTypedDiscreteQuantileAggregateFunction<int32_t>(type);
+		return GetTypedDiscreteQuantileAggregateFunction<int32_t, int32_t>(type);
 	case LogicalTypeId::TIMESTAMP:
-		return GetTypedDiscreteQuantileAggregateFunction<int64_t>(type);
+		return GetTypedDiscreteQuantileAggregateFunction<int64_t, int64_t>(type);
 	case LogicalTypeId::TIME:
-		return GetTypedDiscreteQuantileAggregateFunction<int64_t>(type);
+		return GetTypedDiscreteQuantileAggregateFunction<int64_t, int64_t>(type);
 	case LogicalTypeId::INTERVAL:
-		return GetTypedDiscreteQuantileAggregateFunction<interval_t>(type);
+		return GetTypedDiscreteQuantileAggregateFunction<interval_t, interval_t>(type);
+
+	case LogicalTypeId::VARCHAR:
+		return GetTypedDiscreteQuantileAggregateFunction<string_t, std::string>(type);
 
 	default:
 		throw NotImplementedException("Unimplemented discrete quantile aggregate");
 	}
 }
 
-template <class SAVE_TYPE, class CHILD_TYPE, bool DISCRETE>
-struct QuantileListOperation : public QuantileOperation<SAVE_TYPE> {
+template <class CHILD_TYPE, bool DISCRETE>
+struct QuantileListOperation : public QuantileOperation {
 
 	template <class RESULT_TYPE, class STATE>
 	static void Finalize(Vector &result_list, FunctionData *bind_data_p, STATE *state, RESULT_TYPE *target,
 	                     ValidityMask &mask, idx_t idx) {
-		if (state->pos == 0) {
+		if (state->v.empty()) {
 			mask.SetInvalid(idx);
 			return;
 		}
@@ -75280,13 +75281,13 @@ struct QuantileListOperation : public QuantileOperation<SAVE_TYPE> {
 		ListVector::Reserve(result_list, ridx + bind_data->quantiles.size());
 		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
 
-		D_ASSERT(state->v);
-		auto v_t = (SAVE_TYPE *)state->v;
+		auto v_t = state->v.data();
+		D_ASSERT(v_t);
 
 		target[idx].offset = ridx;
 		for (const auto &quantile : bind_data->quantiles) {
-			Interpolator<SAVE_TYPE, CHILD_TYPE, DISCRETE> interp(quantile, state->pos);
-			rdata[ridx] = interp(v_t);
+			Interpolator<typename STATE::SaveType, CHILD_TYPE, DISCRETE> interp(quantile, state->v.size());
+			rdata[ridx] = interp(v_t, result);
 			++ridx;
 		}
 		target[idx].length = bind_data->quantiles.size();
@@ -75313,18 +75314,16 @@ struct QuantileListOperation : public QuantileOperation<SAVE_TYPE> {
 		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
 
 		//  Lazily initialise frame state
-		const auto prev_valid = state->pos == (prev.second - prev.first);
-		state->pos = frame.second - frame.first;
-		state->template Resize<idx_t>(state->pos);
+		const auto prev_valid = state->w.size() == (prev.second - prev.first);
+		state->SetPos(frame.second - frame.first);
 
-		D_ASSERT(state->v);
-		auto index = (idx_t *)state->v;
+		auto index = state->w.data();
 
 		bool fixed = false;
 		auto j = state->pos;
 		if (prev_valid && dmask.AllValid() && frame.first == prev.first + 1 && frame.second == prev.second + 1) {
 			//  Fixed frame size
-			j = ReplaceIndex(state, frame, prev);
+			j = ReplaceIndex(index, frame, prev);
 			fixed = true;
 		} else {
 			ReuseIndexes(index, frame, prev);
@@ -75349,8 +75348,8 @@ struct QuantileListOperation : public QuantileOperation<SAVE_TYPE> {
 			const auto &quantile = bind_data->quantiles[q];
 			Interpolator<INPUT_TYPE, CHILD_TYPE, DISCRETE> interp(quantile, state->pos);
 
-			if (fixed && CanReplace(state, data, j, interp.FRN, interp.CRN)) {
-				rdata[lentry.offset + q] = interp(data, index);
+			if (fixed && CanReplace(index, data, j, interp.FRN, interp.CRN)) {
+				rdata[lentry.offset + q] = interp(data, index, result);
 				state->upper.resize(state->lower.size(), interp.FRN);
 			} else {
 				state->disturbed.push_back(q);
@@ -75371,15 +75370,15 @@ struct QuantileListOperation : public QuantileOperation<SAVE_TYPE> {
 			if (interp.CRN != interp.FRN) {
 				std::nth_element(index + interp.CRN, index + interp.CRN, index + state->upper[i], lt);
 			}
-			rdata[lentry.offset + q] = interp(data, index);
+			rdata[lentry.offset + q] = interp(data, index, result);
 		}
 	}
 };
 
-template <typename INPUT_TYPE>
+template <typename INPUT_TYPE, typename SAVE_TYPE>
 AggregateFunction GetTypedDiscreteQuantileListAggregateFunction(const LogicalType &type) {
-	using STATE = QuantileState;
-	using OP = QuantileListOperation<INPUT_TYPE, INPUT_TYPE, true>;
+	using STATE = QuantileState<SAVE_TYPE>;
+	using OP = QuantileListOperation<INPUT_TYPE, true>;
 	auto fun = QuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(type, type);
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, list_entry_t, OP>;
 	return fun;
@@ -75388,43 +75387,46 @@ AggregateFunction GetTypedDiscreteQuantileListAggregateFunction(const LogicalTyp
 AggregateFunction GetDiscreteQuantileListAggregateFunction(const LogicalType &type) {
 	switch (type.id()) {
 	case LogicalTypeId::TINYINT:
-		return GetTypedDiscreteQuantileListAggregateFunction<int8_t>(type);
+		return GetTypedDiscreteQuantileListAggregateFunction<int8_t, int8_t>(type);
 	case LogicalTypeId::SMALLINT:
-		return GetTypedDiscreteQuantileListAggregateFunction<int16_t>(type);
+		return GetTypedDiscreteQuantileListAggregateFunction<int16_t, int16_t>(type);
 	case LogicalTypeId::INTEGER:
-		return GetTypedDiscreteQuantileListAggregateFunction<int32_t>(type);
+		return GetTypedDiscreteQuantileListAggregateFunction<int32_t, int32_t>(type);
 	case LogicalTypeId::BIGINT:
-		return GetTypedDiscreteQuantileListAggregateFunction<int64_t>(type);
+		return GetTypedDiscreteQuantileListAggregateFunction<int64_t, int64_t>(type);
 	case LogicalTypeId::HUGEINT:
-		return GetTypedDiscreteQuantileListAggregateFunction<hugeint_t>(type);
+		return GetTypedDiscreteQuantileListAggregateFunction<hugeint_t, hugeint_t>(type);
 
 	case LogicalTypeId::FLOAT:
-		return GetTypedDiscreteQuantileListAggregateFunction<float>(type);
+		return GetTypedDiscreteQuantileListAggregateFunction<float, float>(type);
 	case LogicalTypeId::DOUBLE:
-		return GetTypedDiscreteQuantileListAggregateFunction<double>(type);
+		return GetTypedDiscreteQuantileListAggregateFunction<double, double>(type);
 	case LogicalTypeId::DECIMAL:
 		switch (type.InternalType()) {
 		case PhysicalType::INT16:
-			return GetTypedDiscreteQuantileListAggregateFunction<int16_t>(type);
+			return GetTypedDiscreteQuantileListAggregateFunction<int16_t, int16_t>(type);
 		case PhysicalType::INT32:
-			return GetTypedDiscreteQuantileListAggregateFunction<int32_t>(type);
+			return GetTypedDiscreteQuantileListAggregateFunction<int32_t, int32_t>(type);
 		case PhysicalType::INT64:
-			return GetTypedDiscreteQuantileListAggregateFunction<int64_t>(type);
+			return GetTypedDiscreteQuantileListAggregateFunction<int64_t, int64_t>(type);
 		case PhysicalType::INT128:
-			return GetTypedDiscreteQuantileListAggregateFunction<hugeint_t>(type);
+			return GetTypedDiscreteQuantileListAggregateFunction<hugeint_t, hugeint_t>(type);
 		default:
 			throw NotImplementedException("Unimplemented discrete quantile list aggregate");
 		}
 		break;
 
 	case LogicalTypeId::DATE:
-		return GetTypedDiscreteQuantileListAggregateFunction<date_t>(type);
+		return GetTypedDiscreteQuantileListAggregateFunction<date_t, date_t>(type);
 	case LogicalTypeId::TIMESTAMP:
-		return GetTypedDiscreteQuantileListAggregateFunction<timestamp_t>(type);
+		return GetTypedDiscreteQuantileListAggregateFunction<timestamp_t, timestamp_t>(type);
 	case LogicalTypeId::TIME:
-		return GetTypedDiscreteQuantileListAggregateFunction<dtime_t>(type);
+		return GetTypedDiscreteQuantileListAggregateFunction<dtime_t, dtime_t>(type);
 	case LogicalTypeId::INTERVAL:
-		return GetTypedDiscreteQuantileListAggregateFunction<interval_t>(type);
+		return GetTypedDiscreteQuantileListAggregateFunction<interval_t, interval_t>(type);
+
+	case LogicalTypeId::VARCHAR:
+		return GetTypedDiscreteQuantileListAggregateFunction<string_t, std::string>(type);
 
 	default:
 		throw NotImplementedException("Unimplemented discrete quantile list aggregate");
@@ -75434,8 +75436,8 @@ AggregateFunction GetDiscreteQuantileListAggregateFunction(const LogicalType &ty
 template <typename INPUT_TYPE, typename TARGET_TYPE>
 AggregateFunction GetTypedContinuousQuantileAggregateFunction(const LogicalType &input_type,
                                                               const LogicalType &target_type) {
-	using STATE = QuantileState;
-	using OP = QuantileScalarOperation<INPUT_TYPE, false>;
+	using STATE = QuantileState<INPUT_TYPE>;
+	using OP = QuantileScalarOperation<false>;
 	auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, TARGET_TYPE, OP>(input_type, target_type);
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, TARGET_TYPE, OP>;
 	return fun;
@@ -75488,8 +75490,8 @@ AggregateFunction GetContinuousQuantileAggregateFunction(const LogicalType &type
 template <typename INPUT_TYPE, typename CHILD_TYPE>
 AggregateFunction GetTypedContinuousQuantileListAggregateFunction(const LogicalType &input_type,
                                                                   const LogicalType &result_type) {
-	using STATE = QuantileState;
-	using OP = QuantileListOperation<INPUT_TYPE, CHILD_TYPE, false>;
+	using STATE = QuantileState<INPUT_TYPE>;
+	using OP = QuantileListOperation<CHILD_TYPE, false>;
 	auto fun = QuantileListAggregate<STATE, INPUT_TYPE, list_entry_t, OP>(input_type, result_type);
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, list_entry_t, OP>;
 	return fun;
@@ -75614,9 +75616,19 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimalList(ClientContext &contex
 	return bind_data;
 }
 
+static bool CanInterpolate(const LogicalType &type) {
+	switch (type.id()) {
+	case LogicalTypeId::INTERVAL:
+	case LogicalTypeId::VARCHAR:
+		return false;
+	default:
+		return true;
+	}
+}
+
 AggregateFunction GetMedianAggregate(const LogicalType &type) {
-	auto fun = (type.id() != LogicalTypeId::INTERVAL) ? GetContinuousQuantileAggregateFunction(type)
-	                                                  : GetDiscreteQuantileAggregateFunction(type);
+	auto fun = CanInterpolate(type) ? GetContinuousQuantileAggregateFunction(type)
+	                                : GetDiscreteQuantileAggregateFunction(type);
 	fun.bind = BindMedian;
 	return fun;
 }
@@ -75659,7 +75671,7 @@ void QuantileFun::RegisterFunction(BuiltinFunctions &set) {
 	const vector<LogicalType> QUANTILES = {LogicalType::TINYINT, LogicalType::SMALLINT, LogicalType::INTEGER,
 	                                       LogicalType::BIGINT,  LogicalType::HUGEINT,  LogicalType::FLOAT,
 	                                       LogicalType::DOUBLE,  LogicalType::DATE,     LogicalType::TIMESTAMP,
-	                                       LogicalType::TIME,    LogicalType::INTERVAL};
+	                                       LogicalType::TIME,    LogicalType::INTERVAL, LogicalType::VARCHAR};
 
 	AggregateFunctionSet median("median");
 	median.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
@@ -75685,7 +75697,7 @@ void QuantileFun::RegisterFunction(BuiltinFunctions &set) {
 		median.AddFunction(GetMedianAggregate(type));
 		quantile_disc.AddFunction(GetDiscreteQuantileAggregate(type));
 		quantile_disc.AddFunction(GetDiscreteQuantileListAggregate(type));
-		if (type.id() != LogicalTypeId::INTERVAL) {
+		if (CanInterpolate(type)) {
 			quantile_cont.AddFunction(GetContinuousQuantileAggregate(type));
 			quantile_cont.AddFunction(GetContinuousQuantileListAggregate(type));
 		}
@@ -77677,6 +77689,7 @@ CompressionFunction *DBConfig::GetCompressionFunction(CompressionType type, Phys
 
 
 
+
 
 
 namespace duckdb {
@@ -77975,25 +77988,38 @@ idx_t Function::BindFunction(const string &name, vector<TableFunction> &function
 	return Function::BindFunction(name, functions, types, error);
 }
 
+enum class LogicalTypeComparisonResult { IDENTICAL_TYPE, TARGET_IS_ANY, DIFFERENT_TYPES };
+
+LogicalTypeComparisonResult RequiresCast(const LogicalType &source_type, const LogicalType &target_type) {
+	if (target_type.id() == LogicalTypeId::ANY) {
+		return LogicalTypeComparisonResult::TARGET_IS_ANY;
+	}
+	if (source_type == target_type) {
+		return LogicalTypeComparisonResult::IDENTICAL_TYPE;
+	}
+	if (source_type.id() == LogicalTypeId::LIST && target_type.id() == LogicalTypeId::LIST) {
+		return RequiresCast(ListType::GetChildType(source_type), ListType::GetChildType(target_type));
+	}
+	return LogicalTypeComparisonResult::DIFFERENT_TYPES;
+}
+
 void BaseScalarFunction::CastToFunctionArguments(vector<unique_ptr<Expression>> &children) {
 	for (idx_t i = 0; i < children.size(); i++) {
 		auto target_type = i < this->arguments.size() ? this->arguments[i] : this->varargs;
 		target_type.Verify();
 		// check if the type of child matches the type of function argument
 		// if not we need to add a cast
-		bool require_cast = children[i]->return_type != target_type;
+		auto cast_result = RequiresCast(children[i]->return_type, target_type);
 		// except for one special case: if the function accepts ANY argument
 		// in that case we don't add a cast
-		if (target_type.id() == LogicalTypeId::ANY) {
+		if (cast_result == LogicalTypeComparisonResult::TARGET_IS_ANY) {
 			if (children[i]->return_type.id() == LogicalTypeId::UNKNOWN) {
 				// UNLESS the child is a prepared statement parameter
 				// in that case we default the prepared statement parameter to VARCHAR
-				target_type = LogicalType::VARCHAR;
-			} else {
-				require_cast = false;
+				children[i]->return_type =
+				    ExpressionBinder::ExchangeType(target_type, LogicalTypeId::ANY, LogicalType::VARCHAR);
 			}
-		}
-		if (require_cast) {
+		} else if (cast_result == LogicalTypeComparisonResult::DIFFERENT_TYPES) {
 			children[i] = BoundCastExpression::AddCastToType(move(children[i]), target_type);
 		}
 	}
@@ -83186,6 +83212,10 @@ static void ListExtractFunction(DataChunk &args, ExpressionState &state, Vector
 	case LogicalTypeId::VARCHAR:
 		ExecuteStringExtract(result, base, subscript, count);
 		break;
+	case LogicalTypeId::SQLNULL:
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		ConstantVector::SetNull(result, true);
+		break;
 	default:
 		throw NotImplementedException("Specifier type not implemented");
 	}
@@ -83194,10 +83224,14 @@ static void ListExtractFunction(DataChunk &args, ExpressionState &state, Vector
 static unique_ptr<FunctionData> ListExtractBind(ClientContext &context, ScalarFunction &bound_function,
                                                 vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(bound_function.arguments.size() == 2);
-	D_ASSERT(LogicalTypeId::LIST == arguments[0]->return_type.id());
-	// list extract returns the child type of the list as return type
-	bound_function.return_type = ListType::GetChildType(arguments[0]->return_type);
-
+	if (arguments[0]->return_type.id() == LogicalTypeId::SQLNULL) {
+		bound_function.arguments[0] = LogicalType::SQLNULL;
+		bound_function.return_type = LogicalType::SQLNULL;
+	} else {
+		D_ASSERT(LogicalTypeId::LIST == arguments[0]->return_type.id());
+		// list extract returns the child type of the list as return type
+		bound_function.return_type = ListType::GetChildType(arguments[0]->return_type);
+	}
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
@@ -87869,7 +87903,7 @@ static unique_ptr<FunctionData> ListLengthBind(ClientContext &context, ScalarFun
 
 void LengthFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunction array_length_unary = ScalarFunction(
-	    {LogicalTypeId::LIST}, LogicalType::BIGINT,
+	    {LogicalType::LIST(LogicalType::ANY)}, LogicalType::BIGINT,
 	    ScalarFunction::UnaryFunction<list_entry_t, int64_t, ArrayLengthOperator>, false, ListLengthBind);
 	ScalarFunctionSet length("length");
 	length.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BIGINT,
@@ -87883,7 +87917,7 @@ void LengthFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet array_length("array_length");
 	array_length.AddFunction(array_length_unary);
 	array_length.AddFunction(
-	    ScalarFunction({LogicalTypeId::LIST, LogicalType::BIGINT}, LogicalType::BIGINT,
+	    ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT}, LogicalType::BIGINT,
 	                   ScalarFunction::BinaryFunction<list_entry_t, int64_t, int64_t, ArrayLengthBinaryOperator>, false,
 	                   ListLengthBind));
 	set.AddFunction(array_length);
@@ -143674,7 +143708,7 @@ void Planner::CreatePlan(SQLStatement &statement) {
 	for (auto &expr : bound_parameters) {
 		// check if the type of the parameter could be resolved
 		if (expr->return_type.id() == LogicalTypeId::INVALID || expr->return_type.id() == LogicalTypeId::UNKNOWN) {
-			throw InternalException("Could not determine type of parameters");
+			throw BinderException("Could not determine type of parameters");
 		}
 		auto value = make_unique<Value>(expr->return_type);
 		expr->value = value.get();

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "b63b69fcd"
-#define DUCKDB_VERSION "0.3.1-dev247"
+#define DUCKDB_SOURCE_ID "9000dfec2"
+#define DUCKDB_VERSION "0.3.1-dev283"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //