duckdb 0.3.5-dev1280.0 → 0.3.5-dev1285.0

package/package.json

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

package/src/duckdb.cpp

@@ -23775,7 +23775,7 @@ template <typename T>
 struct IntegerCastData {
 	using Result = T;
 	Result result;
-	uint8_t decimal_count;
+	bool seen_decimal;
 };
 
 struct IntegerCastOperation {
@@ -23809,14 +23809,27 @@ struct IntegerCastOperation {
 
 	template <class T, bool NEGATIVE>
 	static bool HandleDecimal(T &state, uint8_t digit) {
-		if (!state.decimal_count) {
-			if (NEGATIVE) {
-				state.result -= (digit >= 5);
-			} else {
-				state.result += (digit >= 5);
+		if (state.seen_decimal) {
+			return true;
+		}
+		state.seen_decimal = true;
+		// round the integer based on what is after the decimal point
+		// if digit >= 5, then we round up (or down in case of negative numbers)
+		auto increment = digit >= 5;
+		if (!increment) {
+			return true;
+		}
+		if (NEGATIVE) {
+			if (state.result == NumericLimits<typename T::Result>::Minimum()) {
+				return false;
+			}
+			state.result--;
+		} else {
+			if (state.result == NumericLimits<typename T::Result>::Maximum()) {
+				return false;
 			}
+			state.result++;
 		}
-		++state.decimal_count;
 		return true;
 	}
 
@@ -24514,7 +24527,7 @@ struct DecimalCastOperation {
 	static bool HandleExponent(T &state, int32_t exponent) {
 		Finalize<T>(state);
 		if (exponent < 0) {
-			for (idx_t i = 0; i < idx_t(-exponent); i++) {
+			for (idx_t i = 0; i < idx_t(-int64_t(exponent)); i++) {
 				state.result /= 10;
 				if (state.result == 0) {
 					break;
@@ -126006,7 +126019,8 @@ PreparedStatementData::~PreparedStatementData() {
 
 void PreparedStatementData::Bind(vector<Value> values) {
 	// set parameters
-	const auto required = unbound_statement ? unbound_statement->n_param : 0;
+	const auto required = properties.parameter_count;
+	D_ASSERT(!unbound_statement || unbound_statement->n_param == properties.parameter_count);
 	if (values.size() != required) {
 		throw BinderException("Parameter/argument count mismatch for prepared statement. Expected %llu, got %llu",
 		                      required, values.size());
@@ -157861,6 +157875,9 @@ namespace duckdb {
 unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef *node) {
 	D_ASSERT(node);
 	auto expr = make_unique<ParameterExpression>();
+	if (node->number < 0) {
+		throw ParserException("Parameter numbers cannot be negative");
+	}
 	if (node->number == 0) {
 		expr->parameter_nr = ParamCount() + 1;
 	} else {
@@ -158903,6 +158920,14 @@ static void CheckGroupingSetMax(idx_t count) {
 	}
 }
 
+static void CheckGroupingSetCubes(idx_t current_count, idx_t cube_count) {
+	idx_t combinations = 1;
+	for (idx_t i = 0; i < cube_count; i++) {
+		combinations *= 2;
+		CheckGroupingSetMax(current_count + combinations);
+	}
+}
+
 struct GroupingExpressionMap {
 	expression_map_t<idx_t> map;
 };
@@ -159007,6 +159032,8 @@ void Transformer::TransformGroupByNode(duckdb_libpgquery::PGNode *n, GroupingExp
 				cube_sets.push_back(VectorToGroupingSet(cube_set));
 			}
 			// generate the subsets of the rollup set and add them to the grouping sets
+			CheckGroupingSetCubes(result_sets.size(), cube_sets.size());
+
 			GroupingSet current_set;
 			AddCubeSets(current_set, cube_sets, result_sets, 0);
 			break;
@@ -163258,6 +163285,7 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(ParameterExpression &expr, idx_t depth) {
+	D_ASSERT(expr.parameter_nr > 0);
 	auto bound_parameter = make_unique<BoundParameterExpression>(expr.parameter_nr);
 	if (!binder.parameters) {
 		throw std::runtime_error("Unexpected prepared parameter. This type of statement can't be prepared!");
@@ -172832,6 +172860,7 @@ Planner::Planner(ClientContext &context) : binder(Binder::CreateBinder(context))
 
 void Planner::CreatePlan(SQLStatement &statement) {
 	auto &profiler = QueryProfiler::Get(context);
+	auto parameter_count = statement.n_param;
 
 	vector<BoundParameterExpression *> bound_parameters;
 
@@ -172843,6 +172872,7 @@ void Planner::CreatePlan(SQLStatement &statement) {
 	profiler.EndPhase();
 
 	this->properties = binder->properties;
+	this->properties.parameter_count = parameter_count;
 	this->names = bound_statement.names;
 	this->types = bound_statement.types;
 	this->plan = move(bound_statement.plan);
@@ -172887,6 +172917,7 @@ shared_ptr<PreparedStatementData> Planner::PrepareSQLStatement(unique_ptr<SQLSta
 
 void Planner::PlanExecute(unique_ptr<SQLStatement> statement) {
 	auto &stmt = (ExecuteStatement &)*statement;
+	auto parameter_count = stmt.n_param;
 
 	// bind the prepared statement
 	auto &client_data = ClientData::Get(context);
@@ -172925,6 +172956,12 @@ void Planner::PlanExecute(unique_ptr<SQLStatement> statement) {
 		D_ASSERT(prepared->properties.bound_all_parameters);
 		rebound = true;
 	}
+	// copy the properties of the prepared statement into the planner
+	this->properties = prepared->properties;
+	this->properties.parameter_count = parameter_count;
+	this->names = prepared->names;
+	this->types = prepared->types;
+
 	// add casts to the prepared statement parameters as required
 	for (idx_t i = 0; i < bind_values.size(); i++) {
 		if (prepared->value_map.count(i + 1) == 0) {
@@ -172941,10 +172978,6 @@ void Planner::PlanExecute(unique_ptr<SQLStatement> statement) {
 		return;
 	}
 
-	// copy the properties of the prepared statement into the planner
-	this->properties = prepared->properties;
-	this->names = prepared->names;
-	this->types = prepared->types;
 	this->plan = make_unique<LogicalExecute>(move(prepared));
 }
 
@@ -172960,6 +172993,7 @@ void Planner::PlanPrepare(unique_ptr<SQLStatement> statement) {
 	properties.requires_valid_transaction = false;
 	properties.allow_stream_result = false;
 	properties.bound_all_parameters = true;
+	properties.parameter_count = 0;
 	properties.return_type = StatementReturnType::NOTHING;
 	this->names = {"Success"};
 	this->types = {LogicalType::BOOLEAN};

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "83209ca42"
-#define DUCKDB_VERSION "v0.3.5-dev1280"
+#define DUCKDB_SOURCE_ID "2c3c08da3"
+#define DUCKDB_VERSION "v0.3.5-dev1285"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -9897,7 +9897,7 @@ enum class StatementReturnType : uint8_t {
 struct StatementProperties {
 	StatementProperties()
 	    : read_only(true), requires_valid_transaction(true), allow_stream_result(false), bound_all_parameters(true),
-	      return_type(StatementReturnType::QUERY_RESULT) {
+	      return_type(StatementReturnType::QUERY_RESULT), parameter_count(0) {
 	}
 
 	//! Whether or not the statement is a read-only statement, or whether it can result in changes to the database
@@ -9911,6 +9911,8 @@ struct StatementProperties {
 	bool bound_all_parameters;
 	//! What type of data the statement returns
 	StatementReturnType return_type;
+	//! The number of prepared statement parameters
+	idx_t parameter_count;
 };
 
 } // namespace duckdb
@@ -14157,11 +14159,11 @@ public:
 	//! The statement type
 	StatementType type;
 	//! The statement location within the query string
-	idx_t stmt_location;
+	idx_t stmt_location = 0;
 	//! The statement length within the query string
-	idx_t stmt_length;
+	idx_t stmt_length = 0;
 	//! The number of prepared statement parameters (if any)
-	idx_t n_param;
+	idx_t n_param = 0;
 	//! The query text that corresponds to this SQL statement
 	string query;