duckdb 0.3.3-dev1297.0 → 0.3.3-dev1300.0

package/package.json

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

package/src/duckdb.cpp

@@ -153811,6 +153811,8 @@ public:
 		return max_count;
 	}
 
+	unique_ptr<Expression> CreateExtraReference(unique_ptr<ParsedExpression> expr);
+
 private:
 	unique_ptr<Expression> CreateProjectionReference(ParsedExpression &expr, idx_t index);
 
@@ -153844,9 +153846,13 @@ unique_ptr<Expression> Binder::BindOrderExpression(OrderBinder &order_binder, un
 	return bound_expr;
 }
 
-unique_ptr<Expression> Binder::BindDelimiter(ClientContext &context, unique_ptr<ParsedExpression> delimiter,
-                                             const LogicalType &type, Value &delimiter_value) {
+unique_ptr<Expression> Binder::BindDelimiter(ClientContext &context, OrderBinder &order_binder,
+                                             unique_ptr<ParsedExpression> delimiter, const LogicalType &type,
+                                             Value &delimiter_value) {
 	auto new_binder = Binder::CreateBinder(context, this, true);
+	if (delimiter->HasSubquery()) {
+		return order_binder.CreateExtraReference(move(delimiter));
+	}
 	ExpressionBinder expr_binder(*new_binder, context);
 	expr_binder.target_type = type;
 	auto expr = expr_binder.Bind(delimiter);
@@ -153858,11 +153864,11 @@ unique_ptr<Expression> Binder::BindDelimiter(ClientContext &context, unique_ptr<
 	return expr;
 }
 
-unique_ptr<BoundResultModifier> Binder::BindLimit(LimitModifier &limit_mod) {
+unique_ptr<BoundResultModifier> Binder::BindLimit(OrderBinder &order_binder, LimitModifier &limit_mod) {
 	auto result = make_unique<BoundLimitModifier>();
 	if (limit_mod.limit) {
 		Value val;
-		result->limit = BindDelimiter(context, move(limit_mod.limit), LogicalType::BIGINT, val);
+		result->limit = BindDelimiter(context, order_binder, move(limit_mod.limit), LogicalType::BIGINT, val);
 		if (!result->limit) {
 			result->limit_val = val.GetValue<int64_t>();
 			if (result->limit_val < 0) {
@@ -153872,7 +153878,7 @@ unique_ptr<BoundResultModifier> Binder::BindLimit(LimitModifier &limit_mod) {
 	}
 	if (limit_mod.offset) {
 		Value val;
-		result->offset = BindDelimiter(context, move(limit_mod.offset), LogicalType::BIGINT, val);
+		result->offset = BindDelimiter(context, order_binder, move(limit_mod.offset), LogicalType::BIGINT, val);
 		if (!result->offset) {
 			result->offset_val = val.GetValue<int64_t>();
 			if (result->offset_val < 0) {
@@ -153883,11 +153889,11 @@ unique_ptr<BoundResultModifier> Binder::BindLimit(LimitModifier &limit_mod) {
 	return move(result);
 }
 
-unique_ptr<BoundResultModifier> Binder::BindLimitPercent(LimitPercentModifier &limit_mod) {
+unique_ptr<BoundResultModifier> Binder::BindLimitPercent(OrderBinder &order_binder, LimitPercentModifier &limit_mod) {
 	auto result = make_unique<BoundLimitPercentModifier>();
 	if (limit_mod.limit) {
 		Value val;
-		result->limit = BindDelimiter(context, move(limit_mod.limit), LogicalType::DOUBLE, val);
+		result->limit = BindDelimiter(context, order_binder, move(limit_mod.limit), LogicalType::DOUBLE, val);
 		if (!result->limit) {
 			result->limit_percent = val.GetValue<double>();
 			if (result->limit_percent < 0.0) {
@@ -153897,7 +153903,7 @@ unique_ptr<BoundResultModifier> Binder::BindLimitPercent(LimitPercentModifier &l
 	}
 	if (limit_mod.offset) {
 		Value val;
-		result->offset = BindDelimiter(context, move(limit_mod.offset), LogicalType::BIGINT, val);
+		result->offset = BindDelimiter(context, order_binder, move(limit_mod.offset), LogicalType::BIGINT, val);
 		if (!result->offset) {
 			result->offset_val = val.GetValue<int64_t>();
 		}
@@ -153962,10 +153968,10 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 			break;
 		}
 		case ResultModifierType::LIMIT_MODIFIER:
-			bound_modifier = BindLimit((LimitModifier &)*mod);
+			bound_modifier = BindLimit(order_binder, (LimitModifier &)*mod);
 			break;
 		case ResultModifierType::LIMIT_PERCENT_MODIFIER:
-			bound_modifier = BindLimitPercent((LimitPercentModifier &)*mod);
+			bound_modifier = BindLimitPercent(order_binder, (LimitPercentModifier &)*mod);
 			break;
 		default:
 			throw Exception("Unsupported result modifier");
@@ -153976,6 +153982,18 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 	}
 }
 
+static void AssignReturnType(unique_ptr<Expression> &expr, const vector<LogicalType> &sql_types,
+                             idx_t projection_index) {
+	if (!expr) {
+		return;
+	}
+	if (expr->type != ExpressionType::BOUND_COLUMN_REF) {
+		return;
+	}
+	auto &bound_colref = (BoundColumnRefExpression &)*expr;
+	bound_colref.return_type = sql_types[bound_colref.binding.column_index];
+}
+
 void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType> &sql_types, idx_t projection_index) {
 	for (auto &bound_mod : result.modifiers) {
 		switch (bound_mod->type) {
@@ -154009,6 +154027,18 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 			}
 			break;
 		}
+		case ResultModifierType::LIMIT_MODIFIER: {
+			auto &limit = (BoundLimitModifier &)*bound_mod;
+			AssignReturnType(limit.limit, sql_types, projection_index);
+			AssignReturnType(limit.offset, sql_types, projection_index);
+			break;
+		}
+		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
+			auto &limit = (BoundLimitPercentModifier &)*bound_mod;
+			AssignReturnType(limit.limit, sql_types, projection_index);
+			AssignReturnType(limit.offset, sql_types, projection_index);
+			break;
+		}
 		case ResultModifierType::ORDER_MODIFIER: {
 			auto &order = (BoundOrderModifier &)*bound_mod;
 			for (auto &order_node : order.orders) {
@@ -154637,36 +154667,6 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		PlanSubqueries(&expr, &root);
 	}
 
-	for (size_t i = 0; i < statement.modifiers.size(); i++) {
-		auto &modifier = statement.modifiers[i];
-		unique_ptr<LogicalOperator> limit = nullptr;
-		if (modifier->type == ResultModifierType::LIMIT_MODIFIER) {
-			auto &limit_modifier = (BoundLimitModifier &)*modifier;
-			if (limit_modifier.limit || limit_modifier.offset) {
-				PlanSubqueries(&limit_modifier.limit, &root);
-				PlanSubqueries(&limit_modifier.offset, &root);
-				limit = make_unique<LogicalLimit>(limit_modifier.limit_val, limit_modifier.offset_val,
-				                                  move(limit_modifier.limit), move(limit_modifier.offset));
-			}
-		} else if (modifier->type == ResultModifierType::LIMIT_PERCENT_MODIFIER) {
-			auto &limit_modifier = (BoundLimitPercentModifier &)*modifier;
-			if (limit_modifier.limit || limit_modifier.offset) {
-				PlanSubqueries(&limit_modifier.limit, &root);
-				PlanSubqueries(&limit_modifier.offset, &root);
-				limit = make_unique<LogicalLimitPercent>(limit_modifier.limit_percent, limit_modifier.offset_val,
-				                                         move(limit_modifier.limit), move(limit_modifier.offset));
-			}
-		}
-		if (limit) {
-			limit->AddChild(move(root));
-			root = move(limit);
-			// Delete from modifiers
-			std::swap(statement.modifiers[i], statement.modifiers.back());
-			statement.modifiers.erase(statement.modifiers.end() - 1);
-			i--;
-		}
-	}
-
 	// create the projection
 	auto proj = make_unique<LogicalProjection>(statement.projection_index, move(statement.select_list));
 	auto &projection = *proj;
@@ -160241,6 +160241,12 @@ unique_ptr<Expression> OrderBinder::CreateProjectionReference(ParsedExpression &
 	                                             ColumnBinding(projection_index, index));
 }
 
+unique_ptr<Expression> OrderBinder::CreateExtraReference(unique_ptr<ParsedExpression> expr) {
+	auto result = CreateProjectionReference(*expr, extra_list->size());
+	extra_list->push_back(move(expr));
+	return result;
+}
+
 unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 	// in the ORDER BY clause we do not bind children
 	// we bind ONLY to the select list
@@ -160311,9 +160317,7 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 		                      expr->ToString());
 	}
 	// otherwise we need to push the ORDER BY entry into the select list
-	auto result = CreateProjectionReference(*expr, extra_list->size());
-	extra_list->push_back(move(expr));
-	return result;
+	return CreateExtraReference(move(expr));
 }
 
 } // namespace duckdb

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 "c47bd311e"
-#define DUCKDB_VERSION "v0.3.3-dev1297"
+#define DUCKDB_SOURCE_ID "299fe7466"
+#define DUCKDB_VERSION "v0.3.3-dev1300"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -13540,9 +13540,10 @@ private:
 private:
 	//! Bind the default values of the columns of a table
 	void BindDefaultValues(vector<ColumnDefinition> &columns, vector<unique_ptr<Expression>> &bound_defaults);
-	//! Bind a delimiter value (LIMIT or OFFSET)
-	unique_ptr<Expression> BindDelimiter(ClientContext &context, unique_ptr<ParsedExpression> delimiter,
-	                                     const LogicalType &type, Value &delimiter_value);
+	//! Bind a limit value (LIMIT or OFFSET)
+	unique_ptr<Expression> BindDelimiter(ClientContext &context, OrderBinder &order_binder,
+	                                     unique_ptr<ParsedExpression> delimiter, const LogicalType &type,
+	                                     Value &delimiter_value);
 
 	//! Move correlated expressions from the child binder to this binder
 	void MoveCorrelatedExpressions(Binder &other);
@@ -13603,10 +13604,6 @@ private:
 	unique_ptr<LogicalOperator> CreatePlan(BoundExpressionListRef &ref);
 	unique_ptr<LogicalOperator> CreatePlan(BoundCTERef &ref);
 
-	unique_ptr<LogicalOperator> BindTable(TableCatalogEntry &table, BaseTableRef &ref);
-	unique_ptr<LogicalOperator> BindView(ViewCatalogEntry &view, BaseTableRef &ref);
-	unique_ptr<LogicalOperator> BindTableOrView(BaseTableRef &ref);
-
 	BoundStatement BindCopyTo(CopyStatement &stmt);
 	BoundStatement BindCopyFrom(CopyStatement &stmt);
 
@@ -13614,8 +13611,8 @@ private:
 	void BindModifierTypes(BoundQueryNode &result, const vector<LogicalType> &sql_types, idx_t projection_index);
 
 	BoundStatement BindSummarize(ShowStatement &stmt);
-	unique_ptr<BoundResultModifier> BindLimit(LimitModifier &limit_mod);
-	unique_ptr<BoundResultModifier> BindLimitPercent(LimitPercentModifier &limit_mod);
+	unique_ptr<BoundResultModifier> BindLimit(OrderBinder &order_binder, LimitModifier &limit_mod);
+	unique_ptr<BoundResultModifier> BindLimitPercent(OrderBinder &order_binder, LimitPercentModifier &limit_mod);
 	unique_ptr<Expression> BindOrderExpression(OrderBinder &order_binder, unique_ptr<ParsedExpression> expr);
 
 	unique_ptr<LogicalOperator> PlanFilter(unique_ptr<Expression> condition, unique_ptr<LogicalOperator> root);