duckdb 0.3.3-dev1293.0 → 0.3.3-dev1302.0

package/package.json

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

package/src/duckdb.cpp

@@ -46749,9 +46749,7 @@ void AdaptiveFilter::AdaptRuntimeStatistics(double duration) {
 
 
 
-
 #include <cmath>
-#include <map>
 
 namespace duckdb {
 
@@ -47966,7 +47964,6 @@ idx_t ExpressionExecutor::Select(const BoundBetweenExpression &expr, ExpressionS
 
 
 
-
 namespace duckdb {
 
 struct CaseExpressionState : public ExpressionState {
@@ -50968,9 +50965,6 @@ private:
 
 
 
-
-
-
 namespace duckdb {
 
 using ValidityBytes = JoinHashTable::ValidityBytes;
@@ -67004,7 +66998,6 @@ void PartitionableHashTable::Finalize() {
 
 
 
-
 namespace duckdb {
 
 PerfectAggregateHashTable::PerfectAggregateHashTable(BufferManager &buffer_manager,
@@ -71876,8 +71869,6 @@ void BaseReservoirSampling::ReplaceElement() {
 
 
 
-#include <cmath>
-
 namespace duckdb {
 
 WindowSegmentTree::WindowSegmentTree(AggregateFunction &aggregate, FunctionData *bind_info,
@@ -78652,6 +78643,9 @@ void HistogramFun::RegisterFunction(BuiltinFunctions &set) {
 	fun.AddFunction(GetHistogramFunction(PhysicalType::VARCHAR));
 	fun.AddFunction(GetHistogramFunction<int64_t>(LogicalType::TIMESTAMP));
 	fun.AddFunction(GetHistogramFunction<int64_t>(LogicalType::TIMESTAMP_TZ));
+	fun.AddFunction(GetHistogramFunction<int64_t>(LogicalType::TIMESTAMP_S));
+	fun.AddFunction(GetHistogramFunction<int64_t>(LogicalType::TIMESTAMP_MS));
+	fun.AddFunction(GetHistogramFunction<int64_t>(LogicalType::TIMESTAMP_NS));
 	set.AddFunction(fun);
 }
 
@@ -96609,11 +96603,6 @@ void ScalarFunction::NopFunction(DataChunk &input, ExpressionState &state, Vecto
 
 
 
-
-
-
-
-
 namespace duckdb {
 
 ScalarMacroFunction::ScalarMacroFunction(unique_ptr<ParsedExpression> expression)
@@ -96640,8 +96629,6 @@ unique_ptr<MacroFunction> ScalarMacroFunction::Copy() {
 
 
 
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -98059,7 +98046,6 @@ struct ReadCSVTableFunction {
 
 
 
-
 #include <limits>
 
 namespace duckdb {
@@ -98769,6 +98755,7 @@ struct TestAllTypesFun {
 
 
 
+
 namespace duckdb {
 
 struct PragmaDetailedProfilingOutputOperatorData : public FunctionOperatorData {
@@ -99317,7 +99304,6 @@ void BuiltinFunctions::RegisterTableFunctions() {
 
 
 
-
 #include <limits>
 
 namespace duckdb {
@@ -103346,8 +103332,6 @@ void UDFWrapper::RegisterAggrFunction(AggregateFunction aggr_function, ClientCon
 
 
 
-
-
 namespace duckdb {
 
 BaseAppender::BaseAppender() : column(0) {
@@ -104814,7 +104798,6 @@ duckdb_logical_type duckdb_struct_type_child_type(duckdb_logical_type type, idx_
 
 
 
-
 using duckdb::Connection;
 using duckdb::date_t;
 using duckdb::dtime_t;
@@ -106553,67 +106536,6 @@ public:
 
 } // namespace duckdb
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/execute_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-class ExecuteStatement : public SQLStatement {
-public:
-	ExecuteStatement();
-
-	string name;
-	vector<unique_ptr<ParsedExpression>> values;
-
-protected:
-	ExecuteStatement(const ExecuteStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/statement/prepare_statement.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class PrepareStatement : public SQLStatement {
-public:
-	PrepareStatement();
-
-	unique_ptr<SQLStatement> statement;
-	string name;
-
-protected:
-	PrepareStatement(const PrepareStatement &other);
-
-public:
-	unique_ptr<SQLStatement> Copy() const override;
-};
-} // namespace duckdb
 
 
 
@@ -106777,7 +106699,6 @@ private:
 
 
 
-
 namespace duckdb {
 
 struct ActiveQueryContext {
@@ -117936,7 +117857,6 @@ using std::ofstream;
 
 
 
-
 #include <utility>
 #include <algorithm>
 
@@ -119157,7 +119077,6 @@ public:
 
 
 
-
 namespace duckdb {
 
 CreateTableRelation::CreateTableRelation(shared_ptr<Relation> child_p, string schema_name, string table_name)
@@ -119229,7 +119148,6 @@ public:
 
 
 
-
 namespace duckdb {
 
 CreateViewRelation::CreateViewRelation(shared_ptr<Relation> child_p, string view_name_p, bool replace_p,
@@ -145683,6 +145601,36 @@ unique_ptr<SQLStatement> DropStatement::Copy() const {
 }
 
 } // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/statement/execute_statement.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+class ExecuteStatement : public SQLStatement {
+public:
+	ExecuteStatement();
+
+	string name;
+	vector<unique_ptr<ParsedExpression>> values;
+
+protected:
+	ExecuteStatement(const ExecuteStatement &other);
+
+public:
+	unique_ptr<SQLStatement> Copy() const override;
+};
+} // namespace duckdb
 
 
 namespace duckdb {
@@ -145840,6 +145788,35 @@ unique_ptr<SQLStatement> PragmaStatement::Copy() const {
 }
 
 } // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/statement/prepare_statement.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+class PrepareStatement : public SQLStatement {
+public:
+	PrepareStatement();
+
+	unique_ptr<SQLStatement> statement;
+	string name;
+
+protected:
+	PrepareStatement(const PrepareStatement &other);
+
+public:
+	unique_ptr<SQLStatement> Copy() const override;
+};
+} // namespace duckdb
 
 
 namespace duckdb {
@@ -153837,6 +153814,8 @@ public:
 		return max_count;
 	}
 
+	unique_ptr<Expression> CreateExtraReference(unique_ptr<ParsedExpression> expr);
+
 private:
 	unique_ptr<Expression> CreateProjectionReference(ParsedExpression &expr, idx_t index);
 
@@ -153870,9 +153849,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);
@@ -153884,11 +153867,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) {
@@ -153898,7 +153881,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) {
@@ -153909,11 +153892,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) {
@@ -153923,7 +153906,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>();
 		}
@@ -153988,10 +153971,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");
@@ -154002,6 +153985,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) {
@@ -154035,6 +154030,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) {
@@ -154663,36 +154670,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;
@@ -160267,6 +160244,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
@@ -160337,9 +160320,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
@@ -164377,8 +164358,6 @@ void WriteOverflowStringsToDisk::AllocateNewBlock(block_id_t new_block_id) {
 
 
 
-
-
 
 
 
@@ -178161,8 +178140,6 @@ bool ValidityColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filte
 
 
 
-
-
 
 namespace duckdb {
 
@@ -178680,7 +178657,6 @@ void ReplayState::ReplayCheckpoint() {
 
 
 
-
 #include <cstring>
 
 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 "d1cbbb44c"
-#define DUCKDB_VERSION "v0.3.3-dev1293"
+#define DUCKDB_SOURCE_ID "206ab12d8"
+#define DUCKDB_VERSION "v0.3.3-dev1302"
 //===----------------------------------------------------------------------===//
 //                         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);