duckdb 0.8.2-dev1559.0 → 0.8.2-dev1573.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev1559.0",
+  "version": "0.8.2-dev1573.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/execution/operator/join/physical_asof_join.cpp

@@ -20,7 +20,8 @@ namespace duckdb {
 PhysicalAsOfJoin::PhysicalAsOfJoin(LogicalComparisonJoin &op, unique_ptr<PhysicalOperator> left,
                                    unique_ptr<PhysicalOperator> right)
     : PhysicalComparisonJoin(op, PhysicalOperatorType::ASOF_JOIN, std::move(op.conditions), op.join_type,
-                             op.estimated_cardinality) {
+                             op.estimated_cardinality),
+      comparison_type(ExpressionType::INVALID) {
 
 	// Convert the conditions partitions and sorts
 	for (auto &cond : conditions) {
@@ -31,9 +32,19 @@ PhysicalAsOfJoin::PhysicalAsOfJoin(LogicalComparisonJoin &op, unique_ptr<Physica
 		auto right = cond.right->Copy();
 		switch (cond.comparison) {
 		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+		case ExpressionType::COMPARE_GREATERTHAN:
 			null_sensitive.emplace_back(lhs_orders.size());
 			lhs_orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(left));
 			rhs_orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(right));
+			comparison_type = cond.comparison;
+			break;
+		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+		case ExpressionType::COMPARE_LESSTHAN:
+			//	Always put NULLS LAST so they can be ignored.
+			null_sensitive.emplace_back(lhs_orders.size());
+			lhs_orders.emplace_back(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(left));
+			rhs_orders.emplace_back(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(right));
+			comparison_type = cond.comparison;
 			break;
 		case ExpressionType::COMPARE_EQUAL:
 			null_sensitive.emplace_back(lhs_orders.size());
@@ -401,10 +412,28 @@ void AsOfProbeBuffer::BeginLeftScan(hash_t scan_bin) {
 		return;
 	}
 
+	auto iterator_comp = ExpressionType::INVALID;
+	switch (op.comparison_type) {
+	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+		iterator_comp = ExpressionType::COMPARE_LESSTHANOREQUALTO;
+		break;
+	case ExpressionType::COMPARE_GREATERTHAN:
+		iterator_comp = ExpressionType::COMPARE_LESSTHAN;
+		break;
+	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+		iterator_comp = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
+		break;
+	case ExpressionType::COMPARE_LESSTHAN:
+		iterator_comp = ExpressionType::COMPARE_GREATERTHAN;
+		break;
+	default:
+		throw NotImplementedException("Unsupported comparison type for ASOF join");
+	}
+
 	left_hash = lhs_sink.hash_groups[left_group].get();
 	auto &left_sort = *(left_hash->global_sort);
 	lhs_scanner = make_uniq<PayloadScanner>(left_sort, false);
-	left_itr = make_uniq<SBIterator>(left_sort, ExpressionType::COMPARE_LESSTHANOREQUALTO);
+	left_itr = make_uniq<SBIterator>(left_sort, iterator_comp);
 
 	// We are only probing the corresponding right side bin, which may be empty
 	// If they are empty, we leave the iterator as null so we can emit left matches
@@ -414,7 +443,7 @@ void AsOfProbeBuffer::BeginLeftScan(hash_t scan_bin) {
 		right_hash = rhs_sink.hash_groups[right_group].get();
 		right_outer = gsink.right_outers.data() + right_group;
 		auto &right_sort = *(right_hash->global_sort);
-		right_itr = make_uniq<SBIterator>(right_sort, ExpressionType::COMPARE_LESSTHANOREQUALTO);
+		right_itr = make_uniq<SBIterator>(right_sort, iterator_comp);
 		rhs_scanner = make_uniq<PayloadScanner>(right_sort, false);
 	}
 }

package/src/duckdb/src/execution/physical_plan/plan_asof_join.cpp

@@ -31,6 +31,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAsOfJoin &
 			equi_indexes.emplace_back(c);
 			break;
 		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+		case ExpressionType::COMPARE_GREATERTHAN:
+		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+		case ExpressionType::COMPARE_LESSTHAN:
 			D_ASSERT(asof_idx == op.conditions.size());
 			asof_idx = c;
 			break;
@@ -55,24 +58,37 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAsOfJoin &
 	}
 
 	//	Debug implementation: IEJoin of Window
-	//	LEAD(asof_column, 1, infinity) OVER (PARTITION BY equi_column... ORDER BY asof_column) AS asof_temp
+	//	LEAD(asof_column, 1, infinity) OVER (PARTITION BY equi_column... ORDER BY asof_column) AS asof_end
 	auto &asof_comp = op.conditions[asof_idx];
 	auto &asof_column = asof_comp.right;
 	auto asof_type = asof_column->return_type;
-	auto asof_temp = make_uniq<BoundWindowExpression>(ExpressionType::WINDOW_LEAD, asof_type, nullptr, nullptr);
-	asof_temp->children.emplace_back(asof_column->Copy());
-	asof_temp->offset_expr = make_uniq<BoundConstantExpression>(Value::BIGINT(1));
+	auto asof_end = make_uniq<BoundWindowExpression>(ExpressionType::WINDOW_LEAD, asof_type, nullptr, nullptr);
+	asof_end->children.emplace_back(asof_column->Copy());
 	// TODO: If infinities are not supported for a type, fake them by looking at LHS statistics?
-	asof_temp->default_expr = make_uniq<BoundConstantExpression>(Value::Infinity(asof_type));
+	asof_end->offset_expr = make_uniq<BoundConstantExpression>(Value::BIGINT(1));
 	for (auto equi_idx : equi_indexes) {
-		asof_temp->partitions.emplace_back(op.conditions[equi_idx].right->Copy());
+		asof_end->partitions.emplace_back(op.conditions[equi_idx].right->Copy());
 	}
-	asof_temp->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, asof_column->Copy());
-	asof_temp->start = WindowBoundary::UNBOUNDED_PRECEDING;
-	asof_temp->end = WindowBoundary::CURRENT_ROW_ROWS;
+	switch (asof_comp.comparison) {
+	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+	case ExpressionType::COMPARE_GREATERTHAN:
+		asof_end->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, asof_column->Copy());
+		asof_end->default_expr = make_uniq<BoundConstantExpression>(Value::Infinity(asof_type));
+		break;
+	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+	case ExpressionType::COMPARE_LESSTHAN:
+		asof_end->orders.emplace_back(OrderType::DESCENDING, OrderByNullType::NULLS_FIRST, asof_column->Copy());
+		asof_end->default_expr = make_uniq<BoundConstantExpression>(Value::NegativeInfinity(asof_type));
+		break;
+	default:
+		throw InternalException("Invalid ASOF JOIN ordering for WINDOW");
+	}
+
+	asof_end->start = WindowBoundary::UNBOUNDED_PRECEDING;
+	asof_end->end = WindowBoundary::CURRENT_ROW_ROWS;
 
 	vector<unique_ptr<Expression>> window_select;
-	window_select.emplace_back(std::move(asof_temp));
+	window_select.emplace_back(std::move(asof_end));
 
 	auto &window_types = op.children[1]->types;
 	window_types.emplace_back(asof_type);
@@ -80,11 +96,27 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAsOfJoin &
 	auto window = make_uniq<PhysicalWindow>(window_types, std::move(window_select), rhs_cardinality);
 	window->children.emplace_back(std::move(right));
 
-	// IEJoin(left, window, conditions || asof_column < asof_temp)
+	// IEJoin(left, window, conditions || asof_comp ~op asof_end)
 	JoinCondition asof_upper;
 	asof_upper.left = asof_comp.left->Copy();
 	asof_upper.right = make_uniq<BoundReferenceExpression>(asof_type, window_types.size() - 1);
-	asof_upper.comparison = ExpressionType::COMPARE_LESSTHAN;
+	switch (asof_comp.comparison) {
+	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+		asof_upper.comparison = ExpressionType::COMPARE_LESSTHAN;
+		break;
+	case ExpressionType::COMPARE_GREATERTHAN:
+		asof_upper.comparison = ExpressionType::COMPARE_LESSTHANOREQUALTO;
+		break;
+	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+		asof_upper.comparison = ExpressionType::COMPARE_GREATERTHAN;
+		break;
+	case ExpressionType::COMPARE_LESSTHAN:
+		asof_upper.comparison = ExpressionType::COMPARE_GREATERTHANOREQUALTO;
+		break;
+	default:
+		throw InternalException("Invalid ASOF JOIN comparison for IEJoin");
+	}
+
 	op.conditions.emplace_back(std::move(asof_upper));
 
 	return make_uniq<PhysicalIEJoin>(op, std::move(left), std::move(window), std::move(op.conditions), op.join_type,

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -136,6 +136,10 @@ string PragmaVersion(ClientContext &context, const FunctionParameters &parameter
 	return "SELECT * FROM pragma_version();";
 }
 
+string PragmaPlatform(ClientContext &context, const FunctionParameters &parameters) {
+	return "SELECT * FROM pragma_platform();";
+}
+
 string PragmaImportDatabase(ClientContext &context, const FunctionParameters &parameters) {
 	auto &config = DBConfig::GetConfig(context);
 	if (!config.options.enable_external_access) {
@@ -192,6 +196,7 @@ void PragmaQueries::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(PragmaFunction::PragmaStatement("collations", PragmaCollations));
 	set.AddFunction(PragmaFunction::PragmaCall("show", PragmaShow, {LogicalType::VARCHAR}));
 	set.AddFunction(PragmaFunction::PragmaStatement("version", PragmaVersion));
+	set.AddFunction(PragmaFunction::PragmaStatement("platform", PragmaPlatform));
 	set.AddFunction(PragmaFunction::PragmaStatement("database_size", PragmaDatabaseSize));
 	set.AddFunction(PragmaFunction::PragmaStatement("functions", PragmaFunctionsQuery));
 	set.AddFunction(PragmaFunction::PragmaCall("import_database", PragmaImportDatabase, {LogicalType::VARCHAR}));

package/src/duckdb/src/function/table/system_functions.cpp

@@ -10,6 +10,7 @@ namespace duckdb {
 
 void BuiltinFunctions::RegisterSQLiteFunctions() {
 	PragmaVersion::RegisterFunction(*this);
+	PragmaPlatform::RegisterFunction(*this);
 	PragmaCollations::RegisterFunction(*this);
 	PragmaTableInfo::RegisterFunction(*this);
 	PragmaStorageInfo::RegisterFunction(*this);

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,11 +1,12 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev1559"
+#define DUCKDB_VERSION "0.8.2-dev1573"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "fa204ca892"
+#define DUCKDB_SOURCE_ID "c277db819b"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"
+#include "duckdb/common/string_util.hpp"
 
 #include <cstdint>
 
@@ -63,6 +64,13 @@ const char *DuckDB::LibraryVersion() {
 }
 
 string DuckDB::Platform() {
+#if defined(DUCKDB_CUSTOM_PLATFORM)
+	return DUCKDB_QUOTE_DEFINE(DUCKDB_CUSTOM_PLATFORM);
+#endif
+#if defined(DUCKDB_WASM_VERSION)
+	// DuckDB-Wasm requires CUSTOM_PLATFORM to be defined
+	static_assert(0, "DUCKDB_WASM_VERSION should rely on CUSTOM_PLATFORM being provided");
+#endif
 	string os = "linux";
 #if INTPTR_MAX == INT64_MAX
 	string arch = "amd64";
@@ -97,4 +105,40 @@ string DuckDB::Platform() {
 	return os + "_" + arch + postfix;
 }
 
+struct PragmaPlatformData : public GlobalTableFunctionState {
+	PragmaPlatformData() : finished(false) {
+	}
+
+	bool finished;
+};
+
+static unique_ptr<FunctionData> PragmaPlatformBind(ClientContext &context, TableFunctionBindInput &input,
+                                                   vector<LogicalType> &return_types, vector<string> &names) {
+	names.emplace_back("platform");
+	return_types.emplace_back(LogicalType::VARCHAR);
+	return nullptr;
+}
+
+static unique_ptr<GlobalTableFunctionState> PragmaPlatformInit(ClientContext &context, TableFunctionInitInput &input) {
+	return make_uniq<PragmaPlatformData>();
+}
+
+static void PragmaPlatformFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = data_p.global_state->Cast<PragmaPlatformData>();
+	if (data.finished) {
+		// finished returning values
+		return;
+	}
+	output.SetCardinality(1);
+	output.SetValue(0, 0, DuckDB::Platform());
+	data.finished = true;
+}
+
+void PragmaPlatform::RegisterFunction(BuiltinFunctions &set) {
+	TableFunction pragma_platform("pragma_platform", {}, PragmaPlatformFunction);
+	pragma_platform.bind = PragmaPlatformBind;
+	pragma_platform.init_global = PragmaPlatformInit;
+	set.AddFunction(pragma_platform);
+}
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/string_util.hpp

@@ -16,6 +16,17 @@
 
 namespace duckdb {
 
+#ifndef DUCKDB_QUOTE_DEFINE
+// Preprocessor trick to allow text to be converted to C-string / string
+// Expecte use is:
+//	#ifdef SOME_DEFINE
+//	string str = DUCKDB_QUOTE_DEFINE(SOME_DEFINE)
+//	...do something with str
+//	#endif SOME_DEFINE
+#define DUCKDB_QUOTE_DEFINE_IMPL(x) #x
+#define DUCKDB_QUOTE_DEFINE(x)      DUCKDB_QUOTE_DEFINE_IMPL(x)
+#endif
+
 /**
  * String Utility Functions
  * Note that these are not the most efficient implementations (i.e., they copy

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_asof_join.hpp

@@ -23,6 +23,7 @@ public:
 
 	vector<LogicalType> join_key_types;
 	vector<column_t> null_sensitive;
+	ExpressionType comparison_type;
 
 	// Equalities
 	vector<unique_ptr<Expression>> lhs_partitions;

package/src/duckdb/src/include/duckdb/function/table/system_functions.hpp

@@ -37,6 +37,10 @@ struct PragmaVersion {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct PragmaPlatform {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct PragmaDatabaseSize {
 	static void RegisterFunction(BuiltinFunctions &set);
 };

package/src/duckdb/src/main/extension/extension_install.cpp

@@ -29,6 +29,9 @@ bool ExtensionHelper::IsRelease(const string &version_tag) {
 }
 
 const string ExtensionHelper::GetVersionDirectoryName() {
+#ifdef DUCKDB_WASM_VERSION
+	return DUCKDB_QUOTE_DEFINE(DUCKDB_WASM_VERSION);
+#endif
 	if (IsRelease(DuckDB::LibraryVersion())) {
 		return NormalizeVersionTag(DuckDB::LibraryVersion());
 	} else {

package/src/duckdb/src/planner/binder/tableref/plan_joinref.cpp

@@ -137,6 +137,9 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(ClientContext &con
 			case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
 				break;
 			case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+			case ExpressionType::COMPARE_GREATERTHAN:
+			case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+			case ExpressionType::COMPARE_LESSTHAN:
 				if (asof_idx < conditions.size()) {
 					throw BinderException("Multiple ASOF JOIN inequalities");
 				}