duckdb 0.3.1-dev283.0 → 0.3.1-dev291.0

package/package.json

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

package/src/duckdb.cpp

@@ -74973,6 +74973,11 @@ string_t CastInterpolation::Cast(const std::string &src, Vector &result) {
 	return StringVector::AddString(result, src);
 }
 
+template <>
+string_t CastInterpolation::Cast(const string_t &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)) {
@@ -91397,6 +91402,26 @@ void TrimFun::RegisterFunction(BuiltinFunctions &set) {
 } // namespace duckdb
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/scalar/uuid_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+struct UUIDFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+} // namespace duckdb
+
 
 namespace duckdb {
 
@@ -91436,6 +91461,9 @@ void BuiltinFunctions::RegisterStringFunctions() {
 	// blob functions
 	Register<Base64Fun>();
 	Register<EncodeFun>();
+
+	// uuid functions
+	Register<UUIDFun>();
 }
 
 } // namespace duckdb
@@ -91783,6 +91811,79 @@ void BuiltinFunctions::RegisterTrigonometricsFunctions() {
 
 
 
+namespace duckdb {
+
+struct UUIDRandomBindData : public FunctionData {
+	ClientContext &context;
+	std::uniform_int_distribution<uint32_t> dist;
+
+	UUIDRandomBindData(ClientContext &context, std::uniform_int_distribution<uint32_t> dist)
+	    : context(context), dist(dist) {
+	}
+
+	unique_ptr<FunctionData> Copy() override {
+		return make_unique<UUIDRandomBindData>(context, dist);
+	}
+};
+
+static unique_ptr<FunctionData> UUIDRandomBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
+	std::uniform_int_distribution<uint32_t> dist;
+	return make_unique<UUIDRandomBindData>(context, dist);
+}
+
+static void GenerateUUIDFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.ColumnCount() == 0);
+	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &info = (UUIDRandomBindData &)*func_expr.bind_info;
+
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+	auto result_data = FlatVector::GetData<hugeint_t>(result);
+	for (idx_t i = 0; i < args.size(); i++) {
+		uint8_t bytes[16];
+		for (int i = 0; i < 16; i += 4) {
+			*reinterpret_cast<uint32_t *>(bytes + i) = info.dist(info.context.random_engine);
+		}
+		// variant must be 10xxxxxx
+		bytes[8] &= 0xBF;
+		bytes[8] |= 0x80;
+		// version must be 0100xxxx
+		bytes[6] &= 0x4F;
+		bytes[6] |= 0x40;
+
+		result_data[i].upper = 0;
+		result_data[i].upper |= ((int64_t)bytes[0] << 56);
+		result_data[i].upper |= ((int64_t)bytes[1] << 48);
+		result_data[i].upper |= ((int64_t)bytes[3] << 40);
+		result_data[i].upper |= ((int64_t)bytes[4] << 32);
+		result_data[i].upper |= ((int64_t)bytes[5] << 24);
+		result_data[i].upper |= ((int64_t)bytes[6] << 16);
+		result_data[i].upper |= ((int64_t)bytes[7] << 8);
+		result_data[i].upper |= bytes[8];
+		result_data[i].lower = 0;
+		result_data[i].lower |= ((uint64_t)bytes[8] << 56);
+		result_data[i].lower |= ((uint64_t)bytes[9] << 48);
+		result_data[i].lower |= ((uint64_t)bytes[10] << 40);
+		result_data[i].lower |= ((uint64_t)bytes[11] << 32);
+		result_data[i].lower |= ((uint64_t)bytes[12] << 24);
+		result_data[i].lower |= ((uint64_t)bytes[13] << 16);
+		result_data[i].lower |= ((uint64_t)bytes[14] << 8);
+		result_data[i].lower |= bytes[15];
+	}
+}
+
+void UUIDFun::RegisterFunction(BuiltinFunctions &set) {
+	// generate a random uuid
+	set.AddFunction(
+	    ScalarFunction("gen_random_uuid", {}, LogicalType::UUID, GenerateUUIDFunction, true, UUIDRandomBind));
+}
+
+} // namespace duckdb
+
+
+
+
+
 
 
 
@@ -130027,16 +130128,23 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			throw ParserException("Cannot use multiple ORDER BY clauses with WITHIN GROUP");
 		}
 		if (lowercase_name == "percentile_cont") {
+			if (children.size() != 1) {
+				throw ParserException("Wrong number of arguments for PERCENTILE_CONT");
+			}
 			lowercase_name = "quantile_cont";
 		} else if (lowercase_name == "percentile_disc") {
+			if (children.size() != 1) {
+				throw ParserException("Wrong number of arguments for PERCENTILE_DISC");
+			}
 			lowercase_name = "quantile_disc";
 		} else if (lowercase_name == "mode") {
+			if (!children.empty()) {
+				throw ParserException("Wrong number of arguments for MODE");
+			}
 			lowercase_name = "mode";
 		} else {
 			throw ParserException("Unknown ordered aggregate \"%s\".", function_name);
 		}
-		children.insert(children.begin(), move(order_bys->orders[0].expression));
-		order_bys->orders.clear();
 	}
 
 	// star gets eaten in the parser
@@ -134148,6 +134256,7 @@ void BindContext::AddContext(BindContext other) {
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -134365,8 +134474,30 @@ public:
 
 
 
+
 namespace duckdb {
 
+static void InvertPercentileFractions(unique_ptr<ParsedExpression> &fractions) {
+	D_ASSERT(fractions.get());
+	D_ASSERT(fractions->expression_class == ExpressionClass::BOUND_EXPRESSION);
+	auto &bound = (BoundExpression &)*fractions;
+
+	if (!bound.expr->IsFoldable()) {
+		return;
+	}
+
+	Value value = ExpressionExecutor::EvaluateScalar(*bound.expr);
+	if (value.type().id() == LogicalTypeId::LIST) {
+		vector<Value> values;
+		for (const auto &element_val : value.list_value) {
+			values.emplace_back(Value(1) - element_val);
+		}
+		bound.expr = make_unique<BoundConstantExpression>(Value::LIST(values));
+	} else {
+		bound.expr = make_unique<BoundConstantExpression>(Value(1) - value);
+	}
+}
+
 BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry *func, idx_t depth) {
 	// first bind the child of the aggregate expression (if any)
 	this->bound_aggregate = true;
@@ -134379,8 +134510,28 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 		aggregate_binder.BindChild(aggr.filter, 0, error);
 	}
 
+	// Handle ordered-set aggregates by moving the single ORDER BY expression to the front of the children.
+	//	https://www.postgresql.org/docs/current/functions-aggregate.html#FUNCTIONS-ORDEREDSET-TABLE
+	bool ordered_set_agg = false;
+	bool invert_fractions = false;
+	if (aggr.order_bys && aggr.order_bys->orders.size() == 1) {
+		const auto &func_name = aggr.function_name;
+		ordered_set_agg = (func_name == "quantile_cont" || func_name == "quantile_disc" || func_name == "mode");
+
+		if (ordered_set_agg) {
+			auto &config = DBConfig::GetConfig(context);
+			const auto &order = aggr.order_bys->orders[0];
+			const auto sense = (order.type == OrderType::ORDER_DEFAULT) ? config.default_order_type : order.type;
+			invert_fractions = (sense == OrderType::DESCENDING);
+		}
+	}
+
 	for (auto &child : aggr.children) {
 		aggregate_binder.BindChild(child, 0, error);
+		// We have to invert the fractions for PERCENTILE_XXXX DESC
+		if (invert_fractions) {
+			InvertPercentileFractions(child);
+		}
 	}
 
 	// Bind the ORDER BYs, if any
@@ -134442,6 +134593,17 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 	vector<LogicalType> types;
 	vector<LogicalType> arguments;
 	vector<unique_ptr<Expression>> children;
+
+	if (ordered_set_agg) {
+		for (auto &order : aggr.order_bys->orders) {
+			auto &child = (BoundExpression &)*order.expression;
+			types.push_back(child.expr->return_type);
+			arguments.push_back(child.expr->return_type);
+			children.push_back(move(child.expr));
+		}
+		aggr.order_bys->orders.clear();
+	}
+
 	for (idx_t i = 0; i < aggr.children.size(); i++) {
 		auto &child = (BoundExpression &)*aggr.children[i];
 		types.push_back(child.expr->return_type);

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 "9000dfec2"
-#define DUCKDB_VERSION "0.3.1-dev283"
+#define DUCKDB_SOURCE_ID "041bb3216"
+#define DUCKDB_VERSION "0.3.1-dev291"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //