duckdb 0.5.1-dev181.0 → 0.5.1-dev201.0

package/package.json

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

package/src/duckdb.cpp

@@ -80118,10 +80118,17 @@ void PhysicalCreateIndex::GetData(ExecutionContext &context, DataChunk &chunk, G
 		return;
 	}
 
+	// convert virtual column ids to storage column ids
+	vector<column_t> storage_ids;
+	for (auto &column_id : column_ids) {
+		D_ASSERT(column_id < table.columns.size());
+		storage_ids.push_back(table.columns[column_id].StorageOid());
+	}
+
 	unique_ptr<Index> index;
 	switch (info->index_type) {
 	case IndexType::ART: {
-		index = make_unique<ART>(column_ids, unbound_expressions, info->constraint_type, *context.client.db);
+		index = make_unique<ART>(storage_ids, unbound_expressions, info->constraint_type, *context.client.db);
 		break;
 	}
 	default:
@@ -144467,7 +144474,10 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 		auto node = GetNode(left_is_scalar ? comparison.right.get() : comparison.left.get());
 		idx_t equivalence_set = GetEquivalenceSet(node);
 		auto scalar = left_is_scalar ? comparison.left.get() : comparison.right.get();
-		auto constant_value = ExpressionExecutor::EvaluateScalar(*scalar);
+		Value constant_value;
+		if (!ExpressionExecutor::TryEvaluateScalar(*scalar, constant_value)) {
+			return FilterResult::UNSATISFIABLE;
+		}
 		if (constant_value.IsNull()) {
 			// comparisons with null are always null (i.e. will never result in rows)
 			return FilterResult::UNSATISFIABLE;
@@ -144548,7 +144558,11 @@ FilterResult FilterCombiner::AddFilter(Expression *expr) {
 	}
 	if (expr->IsFoldable()) {
 		// scalar condition, evaluate it
-		auto result = ExpressionExecutor::EvaluateScalar(*expr).CastAs(LogicalType::BOOLEAN);
+		Value result;
+		if (!ExpressionExecutor::TryEvaluateScalar(*expr, result)) {
+			return FilterResult::UNSUPPORTED;
+		}
+		result = result.CastAs(LogicalType::BOOLEAN);
 		// check if the filter passes
 		if (result.IsNull() || !BooleanValue::Get(result)) {
 			// the filter does not pass the scalar test, create an empty result
@@ -144572,7 +144586,10 @@ FilterResult FilterCombiner::AddFilter(Expression *expr) {
 
 			if (lower_is_scalar) {
 				auto scalar = comparison.lower.get();
-				auto constant_value = ExpressionExecutor::EvaluateScalar(*scalar);
+				Value constant_value;
+				if (!ExpressionExecutor::TryEvaluateScalar(*scalar, constant_value)) {
+					return FilterResult::UNSUPPORTED;
+				}
 
 				// create the ExpressionValueInformation
 				ExpressionValueInformation info;
@@ -144605,7 +144622,10 @@ FilterResult FilterCombiner::AddFilter(Expression *expr) {
 
 			if (upper_is_scalar) {
 				auto scalar = comparison.upper.get();
-				auto constant_value = ExpressionExecutor::EvaluateScalar(*scalar);
+				Value constant_value;
+				if (!ExpressionExecutor::TryEvaluateScalar(*scalar, constant_value)) {
+					return FilterResult::UNSUPPORTED;
+				}
 
 				// create the ExpressionValueInformation
 				ExpressionValueInformation info;
@@ -145517,7 +145537,6 @@ unique_ptr<Expression> InClauseRewriter::VisitReplace(BoundOperatorExpression &e
 	// IN clause with many children: try to generate a mark join that replaces this IN expression
 	// we can only do this if the expressions in the expression list are scalar
 	for (idx_t i = 1; i < expr.children.size(); i++) {
-		D_ASSERT(expr.children[i]->return_type == in_type);
 		if (!expr.children[i]->IsFoldable()) {
 			// non-scalar expression
 			all_scalar = false;
@@ -167743,7 +167762,7 @@ string QueryNode::ResultModifiersToString() const {
 		} else if (modifier.type == ResultModifierType::LIMIT_PERCENT_MODIFIER) {
 			auto &limit_p_modifier = (LimitPercentModifier &)modifier;
 			if (limit_p_modifier.limit) {
-				result += " LIMIT " + limit_p_modifier.limit->ToString() + " %";
+				result += " LIMIT (" + limit_p_modifier.limit->ToString() + ") %";
 			}
 			if (limit_p_modifier.offset) {
 				result += " OFFSET " + limit_p_modifier.offset->ToString();
@@ -175215,6 +175234,8 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 			// we didn't bind columns, try again in children
 			return BindResult(error);
 		}
+	} else if (depth > 0 && !aggregate_binder.HasBoundColumns()) {
+		return BindResult("Aggregate with only constant parameters has to be bound in the root subquery");
 	}
 	if (!filter_error.empty()) {
 		return BindResult(filter_error);
@@ -175222,8 +175243,9 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 
 	if (aggr.filter) {
 		auto &child = (BoundExpression &)*aggr.filter;
-		bound_filter = move(child.expr);
+		bound_filter = BoundCastExpression::AddCastToType(move(child.expr), LogicalType::BOOLEAN);
 	}
+
 	// all children bound successfully
 	// extract the children and types
 	vector<LogicalType> types;
@@ -177251,7 +177273,6 @@ protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;
-	bool CanContainSubqueries() override;
 };
 
 } // namespace duckdb
@@ -177400,10 +177421,13 @@ public:
 public:
 	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> expr);
 
-	idx_t MaxCount() {
+	idx_t MaxCount() const {
 		return max_count;
 	}
 
+	bool HasExtraList() const {
+		return extra_list;
+	}
 	unique_ptr<Expression> CreateExtraReference(unique_ptr<ParsedExpression> expr);
 
 private:
@@ -177445,6 +177469,9 @@ unique_ptr<Expression> Binder::BindDelimiter(ClientContext &context, OrderBinder
                                              Value &delimiter_value) {
 	auto new_binder = Binder::CreateBinder(context, this, true);
 	if (delimiter->HasSubquery()) {
+		if (!order_binder.HasExtraList()) {
+			throw BinderException("Subquery in LIMIT/OFFSET not supported in set operation");
+		}
 		return order_binder.CreateExtraReference(move(delimiter));
 	}
 	ExpressionBinder expr_binder(*new_binder, context);
@@ -177455,6 +177482,8 @@ unique_ptr<Expression> Binder::BindDelimiter(ClientContext &context, OrderBinder
 		delimiter_value = ExpressionExecutor::EvaluateScalar(*expr).CastAs(type);
 		return nullptr;
 	}
+	// move any correlated columns to this binder
+	MoveCorrelatedExpressions(*new_binder);
 	return expr;
 }
 
@@ -185100,7 +185129,7 @@ BindResult ConstantBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr
 	case ExpressionClass::COLUMN_REF:
 		return BindResult(clause + " cannot contain column names");
 	case ExpressionClass::SUBQUERY:
-		return BindResult(clause + " cannot contain subqueries");
+		throw BinderException(clause + " cannot contain subqueries");
 	case ExpressionClass::DEFAULT:
 		return BindResult(clause + " cannot contain DEFAULT clause");
 	case ExpressionClass::WINDOW:
@@ -185114,10 +185143,6 @@ string ConstantBinder::UnsupportedAggregateMessage() {
 	return clause + " cannot contain aggregates!";
 }
 
-bool ConstantBinder::CanContainSubqueries() {
-	return false;
-}
-
 } // namespace duckdb
 
 
@@ -185364,6 +185389,9 @@ unique_ptr<Expression> OrderBinder::CreateProjectionReference(ParsedExpression &
 }
 
 unique_ptr<Expression> OrderBinder::CreateExtraReference(unique_ptr<ParsedExpression> expr) {
+	if (!extra_list) {
+		throw InternalException("CreateExtraReference called without extra_list");
+	}
 	auto result = CreateProjectionReference(*expr, extra_list->size());
 	extra_list->push_back(move(expr));
 	return result;
@@ -185919,9 +185947,6 @@ unique_ptr<Expression> ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr
 	// bind the main expression
 	auto error_msg = Bind(&expr, 0, root_expression);
 	if (!error_msg.empty()) {
-		if (!CanContainSubqueries()) {
-			throw BinderException(error_msg);
-		}
 		// failed to bind: try to bind correlated columns in the expression (if any)
 		bool success = BindCorrelatedColumns(expr);
 		if (!success) {
@@ -185979,10 +186004,6 @@ string ExpressionBinder::Bind(unique_ptr<ParsedExpression> *expr, idx_t depth, b
 	return string();
 }
 
-bool ExpressionBinder::CanContainSubqueries() {
-	return true;
-}
-
 } // namespace duckdb
 
 
@@ -197358,7 +197379,7 @@ void DataTable::InitializeParallelScan(ClientContext &context, ParallelTableScan
 
 bool DataTable::NextParallelScan(ClientContext &context, ParallelTableScanState &state, TableScanState &scan_state,
                                  const vector<column_t> &column_ids) {
-	while (state.current_row_group) {
+	while (state.current_row_group && state.current_row_group->count > 0) {
 		idx_t vector_index;
 		idx_t max_row;
 		if (ClientConfig::GetConfig(context).verify_parallelism) {
@@ -197372,13 +197393,8 @@ bool DataTable::NextParallelScan(ClientContext &context, ParallelTableScanState
 			max_row = state.current_row_group->start + state.current_row_group->count;
 		}
 		max_row = MinValue<idx_t>(max_row, state.max_row);
-		bool need_to_scan;
-		if (state.current_row_group->count == 0) {
-			need_to_scan = false;
-		} else {
-			need_to_scan = InitializeScanInRowGroup(scan_state, column_ids, scan_state.table_filters,
-			                                        state.current_row_group, vector_index, max_row);
-		}
+		bool need_to_scan = InitializeScanInRowGroup(scan_state, column_ids, scan_state.table_filters,
+		                                             state.current_row_group, vector_index, max_row);
 		if (ClientConfig::GetConfig(context).verify_parallelism) {
 			state.vector_index++;
 			if (state.vector_index * STANDARD_VECTOR_SIZE >= state.current_row_group->count) {

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 "548692357"
-#define DUCKDB_VERSION "v0.5.1-dev181"
+#define DUCKDB_SOURCE_ID "cb8ebc692"
+#define DUCKDB_VERSION "v0.5.1-dev201"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -15992,7 +15992,6 @@ protected:
 
 	virtual string UnsupportedAggregateMessage();
 	virtual string UnsupportedUnnestMessage();
-	virtual bool CanContainSubqueries();
 
 	Binder &binder;
 	ClientContext &context;
@@ -27214,8 +27213,8 @@ public:
 					return function_name + "(" + entry.children[0]->ToString() + ")";
 				}
 			} else if (entry.children.size() == 2) {
-				return "(" + entry.children[0]->ToString() + " " + function_name + " " + entry.children[1]->ToString() +
-				       ")";
+				return StringUtil::Format("(%s) %s (%s)", entry.children[0]->ToString(), function_name,
+				                          entry.children[1]->ToString());
 			}
 		}
 		// standard function call