duckdb 0.3.5-dev1272.0 → 0.3.5-dev1285.0

package/package.json

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

package/src/duckdb.cpp

@@ -3951,6 +3951,7 @@ unique_ptr<CatalogEntry> TableCatalogEntry::ChangeColumnType(ClientContext &cont
 	}
 	auto change_idx = GetColumnIndex(info.column_name);
 	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
+	create_info->temporary = temporary;
 
 	for (idx_t i = 0; i < columns.size(); i++) {
 		auto copy = columns[i].Copy();
@@ -4032,6 +4033,7 @@ unique_ptr<CatalogEntry> TableCatalogEntry::ChangeColumnType(ClientContext &cont
 
 unique_ptr<CatalogEntry> TableCatalogEntry::SetForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info) {
 	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
+	create_info->temporary = temporary;
 
 	for (idx_t i = 0; i < columns.size(); i++) {
 		create_info->columns.push_back(columns[i].Copy());
@@ -23773,7 +23775,7 @@ template <typename T>
 struct IntegerCastData {
 	using Result = T;
 	Result result;
-	uint8_t decimal_count;
+	bool seen_decimal;
 };
 
 struct IntegerCastOperation {
@@ -23807,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;
 	}
 
@@ -24512,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;
@@ -126004,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());
@@ -157859,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 {
@@ -158901,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;
 };
@@ -159005,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;
@@ -163256,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!");
@@ -166062,6 +166092,8 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		// If there is a foreign key constraint, resolve primary key column's index from primary key column's name
 		auto &create_info = (CreateTableInfo &)*stmt.info;
 		auto &catalog = Catalog::GetCatalog(context);
+		// We first check if there are any user types, if yes we check to which custom types they refer.
+		unordered_set<SchemaCatalogEntry *> fk_schemas;
 		for (idx_t i = 0; i < create_info.constraints.size(); i++) {
 			auto &cond = create_info.constraints[i];
 			if (cond->type != ConstraintType::FOREIGN_KEY) {
@@ -166078,6 +166110,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			} else {
 				// have to resolve referenced table
 				auto pk_table_entry_ptr = catalog.GetEntry<TableCatalogEntry>(context, fk.info.schema, fk.info.table);
+				fk_schemas.insert(pk_table_entry_ptr->schema);
 				D_ASSERT(fk.info.pk_keys.empty());
 				FindMatchingPrimaryKeyColumns(pk_table_entry_ptr->constraints, fk);
 				for (auto &keyname : fk.pk_columns) {
@@ -166102,10 +166135,15 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		if (AnyConstraintReferencesGeneratedColumn(create_info)) {
 			throw BinderException("Constraints on generated columns are not supported yet");
 		}
-		// We first check if there are any user types, if yes we check to which custom types they refer.
 		auto bound_info = BindCreateTableInfo(move(stmt.info));
 		auto root = move(bound_info->query);
 
+		for (auto &fk_schema : fk_schemas) {
+			if (fk_schema != bound_info->schema) {
+				throw BinderException("Creating foreign keys across different schemas is not supported");
+			}
+		}
+
 		// create the logical operator
 		auto &schema = bound_info->schema;
 		auto create_table = make_unique<LogicalCreateTable>(schema, move(bound_info));
@@ -172822,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;
 
@@ -172833,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);
@@ -172877,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);
@@ -172915,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) {
@@ -172931,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));
 }
 
@@ -172950,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 "2000fbe90"
-#define DUCKDB_VERSION "v0.3.5-dev1272"
+#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;