duckdb 0.3.1-dev317.0 → 0.3.1-dev332.0

package/package.json

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

package/src/duckdb.cpp

@@ -1028,10 +1028,12 @@ public:
 	static void ResolveParameterType(LogicalType &type);
 	static void ResolveParameterType(unique_ptr<Expression> &expr);
 
-protected:
+	//! Bind the given expresion. Unlike Bind(), this does *not* mute the given ParsedExpression.
+	//! Exposed to be used from sub-binders that aren't subclasses of ExpressionBinder.
 	virtual BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
 	                                  bool root_expression = false);
 
+protected:
 	BindResult BindExpression(BetweenExpression &expr, idx_t depth);
 	BindResult BindExpression(CaseExpression &expr, idx_t depth);
 	BindResult BindExpression(CollateExpression &expr, idx_t depth);
@@ -1331,6 +1333,7 @@ public:
 
 namespace duckdb {
 class BoundResultModifier;
+class BoundSelectNode;
 class ClientContext;
 class ExpressionBinder;
 class LimitModifier;
@@ -1544,7 +1547,6 @@ private:
 
 	BoundStatement BindSummarize(ShowStatement &stmt);
 	unique_ptr<BoundResultModifier> BindLimit(LimitModifier &limit_mod);
-	unique_ptr<Expression> BindFilter(unique_ptr<ParsedExpression> condition);
 	unique_ptr<Expression> BindOrderExpression(OrderBinder &order_binder, unique_ptr<ParsedExpression> expr);
 
 	unique_ptr<LogicalOperator> PlanFilter(unique_ptr<Expression> condition, unique_ptr<LogicalOperator> root);
@@ -58190,10 +58192,8 @@ SinkFinalizeType PhysicalHashJoin::Finalize(Pipeline &pipeline, Event &event, Cl
 		D_ASSERT(sink.hash_table->equality_types.size() == 1);
 		auto key_type = sink.hash_table->equality_types[0];
 		use_perfect_hash = sink.perfect_join_executor->BuildPerfectHashTable(key_type);
-	} else {
-		sink.perfect_join_executor.reset();
 	}
-	// In case large build side or duplicates, use regular hash join
+	// In case of a large build side or duplicates, use regular hash join
 	if (!use_perfect_hash) {
 		sink.perfect_join_executor.reset();
 		sink.hash_table->Finalize();
@@ -66465,7 +66465,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 			return;
 		}
 	}
-	// with integral types
+	// with integral internal types
 	for (auto &&join_stat : op.join_stats) {
 		if (!TypeIsInteger(join_stat->type.InternalType()) || join_stat->type.InternalType() == PhysicalType::INT128) {
 			// perfect join not possible for non-integral types or hugeint
@@ -66490,7 +66490,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	join_state.build_min = stats_build->min;
 	join_state.build_max = stats_build->max;
 	join_state.estimated_cardinality = op.estimated_cardinality;
-	if (build_range.type().id() == LogicalTypeId::DECIMAL) {
+	if (!build_range.type().IsIntegral()) {
 		switch (build_range.type().InternalType()) {
 		case PhysicalType::INT16:
 			join_state.build_range = build_range.value_.smallint;
@@ -66502,19 +66502,15 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 			join_state.build_range = build_range.value_.bigint;
 			break;
 		case PhysicalType::INT128:
-			throw InternalException("PhysicalType::INT128 not yet implemented for Perfect HJ");
-			//			join_state.build_range = build_range.GetValue<idx_t>();
-			//			break;
+			// we do not support hugeint for this optimization
+			return;
 		default:
 			throw InternalException("Invalid Physical Type for Decimals");
 		}
 	} else {
 		join_state.build_range = build_range.GetValue<idx_t>(); // cast integer types into idx_t
 	}
-	if (join_state.build_range > MAX_BUILD_SIZE) {
-		return;
-	}
-	if (stats_probe->max.is_null || stats_probe->min.is_null) {
+	if (join_state.build_range > MAX_BUILD_SIZE || stats_probe->max.is_null || stats_probe->min.is_null) {
 		return;
 	}
 	if (stats_build->min <= stats_probe->min && stats_probe->max <= stats_build->max) {
@@ -136027,6 +136023,40 @@ unique_ptr<BoundQueryNode> Binder::BindNode(RecursiveCTENode &statement) {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression_binder/column_alias_binder.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+class BoundSelectNode;
+class ColumnRefExpression;
+
+//! A helper binder for WhereBinder and HavingBinder which support alias as a columnref.
+class ColumnAliasBinder {
+public:
+	ColumnAliasBinder(BoundSelectNode &node, const unordered_map<string, idx_t> &alias_map);
+
+	BindResult BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth,
+	                     bool root_expression);
+
+private:
+	BoundSelectNode &node;
+	const unordered_map<string, idx_t> &alias_map;
+	bool in_alias;
+};
+
+} // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -136117,6 +136147,7 @@ protected:
 
 
 
+
 namespace duckdb {
 
 //! The HAVING binder is responsible for binding an expression within the HAVING clause of a SQL statement
@@ -136125,12 +136156,14 @@ public:
 	HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
 	             unordered_map<string, idx_t> &alias_map);
 
-	unordered_map<string, idx_t> &alias_map;
-	bool in_alias;
-
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
+
+private:
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
+
+	ColumnAliasBinder column_alias_binder;
 };
 
 } // namespace duckdb
@@ -136193,16 +136226,23 @@ private:
 
 namespace duckdb {
 
+class ColumnAliasBinder;
+
 //! The WHERE binder is responsible for binding an expression within the WHERE clause of a SQL statement
 class WhereBinder : public ExpressionBinder {
 public:
-	WhereBinder(Binder &binder, ClientContext &context);
+	WhereBinder(Binder &binder, ClientContext &context, ColumnAliasBinder *column_alias_binder = nullptr);
 
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;
+
+private:
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
+
+	ColumnAliasBinder *column_alias_binder;
 };
 
 } // namespace duckdb
@@ -136211,10 +136251,6 @@ protected:
 
 
 namespace duckdb {
-unique_ptr<Expression> Binder::BindFilter(unique_ptr<ParsedExpression> condition) {
-	WhereBinder where_binder(*this, context);
-	return where_binder.Bind(condition);
-}
 
 unique_ptr<Expression> Binder::BindOrderExpression(OrderBinder &order_binder, unique_ptr<ParsedExpression> expr) {
 	// we treat the Distinct list as a order by
@@ -136413,7 +136449,10 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	// first visit the WHERE clause
 	// the WHERE clause happens before the GROUP BY, PROJECTION or HAVING clauses
 	if (statement.where_clause) {
-		result->where_clause = BindFilter(move(statement.where_clause));
+		ColumnAliasBinder alias_binder(*result, alias_map);
+		WhereBinder where_binder(*this, context, &alias_binder);
+		unique_ptr<ParsedExpression> condition = move(statement.where_clause);
+		result->where_clause = where_binder.Bind(condition);
 	}
 
 	// now bind all the result modifiers; including DISTINCT and ORDER BY targets
@@ -141757,6 +141796,38 @@ BindResult CheckBinder::BindCheckColumn(ColumnRefExpression &colref) {
 } // namespace duckdb
 
 
+
+
+
+
+namespace duckdb {
+
+ColumnAliasBinder::ColumnAliasBinder(BoundSelectNode &node, const unordered_map<string, idx_t> &alias_map)
+    : node(node), alias_map(alias_map), in_alias(false) {
+}
+
+BindResult ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth,
+                                        bool root_expression) {
+	if (!expr.table_name.empty()) {
+		return BindResult(StringUtil::Format("Alias %s cannot be qualified.", expr.ToString()));
+	}
+
+	auto alias_entry = alias_map.find(expr.column_name);
+	if (alias_entry == alias_map.end()) {
+		return BindResult(StringUtil::Format("Alias %s is not found.", expr.ToString()));
+	}
+
+	// found an alias: bind the alias expression
+	D_ASSERT(!in_alias);
+	auto expression = node.original_expressions[alias_entry->second]->Copy();
+	in_alias = true;
+	auto result = enclosing_binder.BindExpression(&expression, depth, root_expression);
+	in_alias = false;
+	return result;
+}
+
+} // namespace duckdb
+
 namespace duckdb {
 
 ConstantBinder::ConstantBinder(Binder &binder, ClientContext &context, string clause)
@@ -141904,10 +141975,21 @@ namespace duckdb {
 
 HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
                            unordered_map<string, idx_t> &alias_map)
-    : SelectBinder(binder, context, node, info), alias_map(alias_map), in_alias(false) {
+    : SelectBinder(binder, context, node, info), column_alias_binder(node, alias_map) {
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
 
+BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = (ColumnRefExpression &)**expr_ptr;
+	auto alias_result = column_alias_binder.BindAlias(*this, expr, depth, root_expression);
+	if (!alias_result.HasError()) {
+		return alias_result;
+	}
+
+	return BindResult(StringUtil::Format(
+	    "column %s must appear in the GROUP BY clause or be used in an aggregate function", expr.ToString()));
+}
+
 BindResult HavingBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
 	auto &expr = **expr_ptr;
 	// check if the expression binds to one of the groups
@@ -141919,22 +142001,7 @@ BindResult HavingBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr,
 	case ExpressionClass::WINDOW:
 		return BindResult("HAVING clause cannot contain window functions!");
 	case ExpressionClass::COLUMN_REF:
-		if (!in_alias) {
-			auto &colref = (ColumnRefExpression &)expr;
-			if (colref.table_name.empty()) {
-				auto alias_entry = alias_map.find(colref.column_name);
-				if (alias_entry != alias_map.end()) {
-					// found an alias: bind the alias expression
-					auto expression = node.original_expressions[alias_entry->second]->Copy();
-					in_alias = true;
-					auto result = BindExpression(&expression, depth, root_expression);
-					in_alias = false;
-					return result;
-				}
-			}
-		}
-		return BindResult(StringUtil::Format(
-		    "column %s must appear in the GROUP BY clause or be used in an aggregate function", expr.ToString()));
+		return BindColumnRef(expr_ptr, depth, root_expression);
 	default:
 		return duckdb::SelectBinder::BindExpression(expr_ptr, depth);
 	}
@@ -142268,12 +142335,30 @@ string UpdateBinder::UnsupportedAggregateMessage() {
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
-WhereBinder::WhereBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
+WhereBinder::WhereBinder(Binder &binder, ClientContext &context, ColumnAliasBinder *column_alias_binder)
+    : ExpressionBinder(binder, context), column_alias_binder(column_alias_binder) {
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
 
+BindResult WhereBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = (ColumnRefExpression &)**expr_ptr;
+	auto result = ExpressionBinder::BindExpression(expr_ptr, depth);
+	if (!result.HasError() || !column_alias_binder) {
+		return result;
+	}
+
+	BindResult alias_result = column_alias_binder->BindAlias(*this, expr, depth, root_expression);
+	// This code path cannot be exercised at thispoint. #1547 might change that.
+	if (!alias_result.HasError()) {
+		return alias_result;
+	}
+
+	return result;
+}
+
 BindResult WhereBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
 	auto &expr = **expr_ptr;
 	switch (expr.GetExpressionClass()) {
@@ -142281,6 +142366,8 @@ BindResult WhereBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, i
 		return BindResult("WHERE clause cannot contain DEFAULT clause");
 	case ExpressionClass::WINDOW:
 		return BindResult("WHERE clause cannot contain window functions!");
+	case ExpressionClass::COLUMN_REF:
+		return BindColumnRef(expr_ptr, depth, root_expression);
 	default:
 		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	}
@@ -142542,8 +142629,6 @@ void ExpressionBinder::BindTableNames(Binder &binder, ParsedExpression &expr, un
 			if (binder.macro_binding != nullptr && binder.macro_binding->HasMatchingBinding(colref.column_name)) {
 				// macro parameters get priority
 				colref.table_name = binder.macro_binding->alias;
-			} else if (alias_map && alias_map->find(colref.column_name) != alias_map->end()) {
-				// alias: leave unqualified
 			} else {
 				colref.table_name = binder.bind_context.GetMatchingBinding(colref.column_name);
 			}

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 "dd146c2d3"
-#define DUCKDB_VERSION "0.3.1-dev317"
+#define DUCKDB_SOURCE_ID "62382bcc0"
+#define DUCKDB_VERSION "0.3.1-dev332"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //