duckdb 0.2.10-dev360.0 → 0.2.10-dev441.0

package/package.json

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

package/src/duckdb.cpp

@@ -47804,12 +47804,15 @@ namespace duckdb {
 
 unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundFunctionExpression &expr,
                                                                 ExpressionExecutorState &root) {
-	auto result = make_unique<ExpressionState>(expr, root);
+	auto result = make_unique<ExecuteFunctionState>(expr, root);
 	for (auto &child : expr.children) {
 		result->AddChild(child.get());
 	}
 	result->Finalize();
-	return result;
+	if (expr.function.init_local_state) {
+		result->local_state = expr.function.init_local_state(expr, expr.bind_info.get());
+	}
+	return move(result);
 }
 
 void ExpressionExecutor::Execute(const BoundFunctionExpression &expr, ExpressionState *state,
@@ -64753,6 +64756,19 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	return;
 }
 
+static void CanUseIndexJoin(TableScanBindData *tbl, Expression &expr, Index **result_index) {
+	tbl->table->storage->info->indexes.Scan([&](Index &index) {
+		if (index.unbound_expressions.size() != 1) {
+			return false;
+		}
+		if (expr.alias == index.unbound_expressions[0]->alias) {
+			*result_index = &index;
+			return true;
+		}
+		return false;
+	});
+}
+
 void TransformIndexJoin(ClientContext &context, LogicalComparisonJoin &op, Index **left_index, Index **right_index,
                         PhysicalOperator *left, PhysicalOperator *right) {
 	auto &transaction = Transaction::GetTransaction(context);
@@ -64764,26 +64780,14 @@ void TransformIndexJoin(ClientContext &context, LogicalComparisonJoin &op, Index
 			auto &tbl_scan = (PhysicalTableScan &)*left;
 			auto tbl = dynamic_cast<TableScanBindData *>(tbl_scan.bind_data.get());
 			if (CanPlanIndexJoin(transaction, tbl, tbl_scan)) {
-				tbl->table->storage->info->indexes.Scan([&](Index &index) {
-					if (index.unbound_expressions[0]->alias == op.conditions[0].left->alias) {
-						*left_index = &index;
-						return true;
-					}
-					return false;
-				});
+				CanUseIndexJoin(tbl, *op.conditions[0].left, left_index);
 			}
 		}
 		if (right->type == PhysicalOperatorType::TABLE_SCAN) {
 			auto &tbl_scan = (PhysicalTableScan &)*right;
 			auto tbl = dynamic_cast<TableScanBindData *>(tbl_scan.bind_data.get());
 			if (CanPlanIndexJoin(transaction, tbl, tbl_scan)) {
-				tbl->table->storage->info->indexes.Scan([&](Index &index) {
-					if (index.unbound_expressions[0]->alias == op.conditions[0].right->alias) {
-						*right_index = &index;
-						return true;
-					}
-					return false;
-				});
+				CanUseIndexJoin(tbl, *op.conditions[0].right, right_index);
 			}
 		}
 	}
@@ -80388,20 +80392,20 @@ template <class OP>
 static void RegisterLeastGreatest(BuiltinFunctions &set, const string &fun_name) {
 	ScalarFunctionSet fun_set(fun_name);
 	fun_set.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::DATE, LeastGreatestFunction<date_t, OP>, false,
-	                                   nullptr, nullptr, nullptr, LogicalType::DATE));
+	                                   nullptr, nullptr, nullptr, nullptr, LogicalType::DATE));
 	fun_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP,
 	                                   LeastGreatestFunction<timestamp_t, OP>, false, nullptr, nullptr, nullptr,
-	                                   LogicalType::TIMESTAMP));
+	                                   nullptr, LogicalType::TIMESTAMP));
 	fun_set.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::BIGINT, LeastGreatestFunction<int64_t, OP>,
-	                                   false, nullptr, nullptr, nullptr, LogicalType::BIGINT));
+	                                   false, nullptr, nullptr, nullptr, nullptr, LogicalType::BIGINT));
 	fun_set.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::HUGEINT,
-	                                   LeastGreatestFunction<hugeint_t, OP>, false, nullptr, nullptr, nullptr,
+	                                   LeastGreatestFunction<hugeint_t, OP>, false, nullptr, nullptr, nullptr, nullptr,
 	                                   LogicalType::HUGEINT));
 	fun_set.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, LeastGreatestFunction<double, OP>,
-	                                   false, nullptr, nullptr, nullptr, LogicalType::DOUBLE));
+	                                   false, nullptr, nullptr, nullptr, nullptr, LogicalType::DOUBLE));
 	fun_set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                                   LeastGreatestFunction<string_t, OP, true>, false, nullptr, nullptr, nullptr,
-	                                   LogicalType::VARCHAR));
+	                                   nullptr, LogicalType::VARCHAR));
 	set.AddFunction(fun_set);
 }
 
@@ -87958,7 +87962,7 @@ struct RegexpMatchesBindData : public FunctionData {
 
 	duckdb_re2::RE2::Options options;
 	string constant_string;
-	std::unique_ptr<duckdb_re2::RE2> constant_pattern;
+	bool constant_pattern;
 	string range_min;
 	string range_max;
 	bool range_success;
@@ -87980,13 +87984,14 @@ namespace duckdb {
 
 RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string_p)
     : options(options), constant_string(move(constant_string_p)) {
-	if (!constant_string.empty()) {
-		constant_pattern = make_unique<RE2>(constant_string, options);
-		if (!constant_pattern->ok()) {
-			throw Exception(constant_pattern->error());
+	constant_pattern = !constant_string.empty();
+	if (constant_pattern) {
+		auto pattern = make_unique<RE2>(constant_string, options);
+		if (!pattern->ok()) {
+			throw Exception(pattern->error());
 		}
 
-		range_success = constant_pattern->PossibleMatchRange(&range_min, &range_max, 1000);
+		range_success = pattern->PossibleMatchRange(&range_min, &range_max, 1000);
 	} else {
 		range_success = false;
 	}
@@ -88055,6 +88060,24 @@ struct RegexFullMatch {
 	}
 };
 
+struct RegexLocalState : public FunctionData {
+	explicit RegexLocalState(RegexpMatchesBindData &info)
+	    : constant_pattern(duckdb_re2::StringPiece(info.constant_string.c_str(), info.constant_string.size()),
+	                       info.options) {
+		D_ASSERT(info.constant_pattern);
+	}
+
+	RE2 constant_pattern;
+};
+
+static unique_ptr<FunctionData> RegexInitLocalState(const BoundFunctionExpression &expr, FunctionData *bind_data) {
+	auto &info = (RegexpMatchesBindData &)*bind_data;
+	if (info.constant_pattern) {
+		return make_unique<RegexLocalState>(info);
+	}
+	return nullptr;
+}
+
 template <class OP>
 static void RegexpMatchesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &strings = args.data[0];
@@ -88064,8 +88087,9 @@ static void RegexpMatchesFunction(DataChunk &args, ExpressionState &state, Vecto
 	auto &info = (RegexpMatchesBindData &)*func_expr.bind_info;
 
 	if (info.constant_pattern) {
+		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
 		UnaryExecutor::Execute<string_t, bool>(strings, result, args.size(), [&](string_t input) {
-			return OP::Operation(CreateStringPiece(input), *info.constant_pattern);
+			return OP::Operation(CreateStringPiece(input), lstate.constant_pattern);
 		});
 	} else {
 		BinaryExecutor::Execute<string_t, string_t, bool>(strings, patterns, result, args.size(),
@@ -88152,18 +88176,19 @@ static unique_ptr<FunctionData> RegexReplaceBind(ClientContext &context, ScalarF
 void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet regexp_full_match("regexp_full_match");
 	regexp_full_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                                             RegexpMatchesFunction<RegexFullMatch>, false, RegexpMatchesBind));
+	                                             RegexpMatchesFunction<RegexFullMatch>, false, RegexpMatchesBind,
+	                                             nullptr, nullptr, RegexInitLocalState));
 	regexp_full_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
 	                                             LogicalType::BOOLEAN, RegexpMatchesFunction<RegexFullMatch>, false,
-	                                             RegexpMatchesBind));
+	                                             RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState));
 
 	ScalarFunctionSet regexp_partial_match("regexp_matches");
 	regexp_partial_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                                                RegexpMatchesFunction<RegexPartialMatch>, false,
-	                                                RegexpMatchesBind));
+	                                                RegexpMatchesFunction<RegexPartialMatch>, false, RegexpMatchesBind,
+	                                                nullptr, nullptr, RegexInitLocalState));
 	regexp_partial_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
 	                                                LogicalType::BOOLEAN, RegexpMatchesFunction<RegexPartialMatch>,
-	                                                false, RegexpMatchesBind));
+	                                                false, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState));
 
 	ScalarFunctionSet regexp_replace("regexp_replace");
 	regexp_replace.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
@@ -129706,8 +129731,7 @@ SetScope ToSetScope(duckdb_libpgquery::VariableSetScope pg_scope) {
 	case duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_GLOBAL:
 		return SetScope::GLOBAL;
 	case duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_DEFAULT:
-		// FIXME: This should be SESSION. See https://github.com/duckdb/duckdb/pull/2247
-		return SetScope::GLOBAL;
+		return SetScope::SESSION;
 	default:
 		throw InternalException("Unexpected pg_scope: %d", pg_scope);
 	}

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 "b6fb72563"
-#define DUCKDB_VERSION "0.2.10-dev360"
+#define DUCKDB_SOURCE_ID "cd0b53211"
+#define DUCKDB_VERSION "0.2.10-dev441"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -5014,40 +5014,6 @@ private:
 } // namespace duckdb
 
 
-
-namespace duckdb {
-class Expression;
-class ExpressionExecutor;
-struct ExpressionExecutorState;
-
-struct ExpressionState {
-	ExpressionState(const Expression &expr, ExpressionExecutorState &root);
-	virtual ~ExpressionState() {
-	}
-
-	const Expression &expr;
-	ExpressionExecutorState &root;
-	vector<unique_ptr<ExpressionState>> child_states;
-	vector<LogicalType> types;
-	DataChunk intermediate_chunk;
-	string name;
-	CycleCounter profiler;
-
-public:
-	void AddChild(Expression *expr);
-	void Finalize();
-};
-
-struct ExpressionExecutorState {
-	explicit ExpressionExecutorState(const string &name);
-	unique_ptr<ExpressionState> root_state;
-	ExpressionExecutor *executor;
-	CycleCounter profiler;
-	string name;
-};
-
-} // namespace duckdb
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -5711,6 +5677,53 @@ private:
 
 } // namespace duckdb
 
+
+namespace duckdb {
+class Expression;
+class ExpressionExecutor;
+struct ExpressionExecutorState;
+
+struct ExpressionState {
+	ExpressionState(const Expression &expr, ExpressionExecutorState &root);
+	virtual ~ExpressionState() {
+	}
+
+	const Expression &expr;
+	ExpressionExecutorState &root;
+	vector<unique_ptr<ExpressionState>> child_states;
+	vector<LogicalType> types;
+	DataChunk intermediate_chunk;
+	string name;
+	CycleCounter profiler;
+
+public:
+	void AddChild(Expression *expr);
+	void Finalize();
+};
+
+struct ExecuteFunctionState : public ExpressionState {
+	ExecuteFunctionState(const Expression &expr, ExpressionExecutorState &root) : ExpressionState(expr, root) {
+	}
+
+	unique_ptr<FunctionData> local_state;
+
+public:
+	static FunctionData *GetFunctionState(ExpressionState &state) {
+		return ((ExecuteFunctionState &)state).local_state.get();
+	}
+};
+
+struct ExpressionExecutorState {
+	explicit ExpressionExecutorState(const string &name);
+	unique_ptr<ExpressionState> root_state;
+	ExpressionExecutor *executor;
+	CycleCounter profiler;
+	string name;
+};
+
+} // namespace duckdb
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -6296,6 +6309,7 @@ typedef std::function<void(DataChunk &, ExpressionState &, Vector &)> scalar_fun
 //! Binds the scalar function and creates the function data
 typedef unique_ptr<FunctionData> (*bind_scalar_function_t)(ClientContext &context, ScalarFunction &bound_function,
                                                            vector<unique_ptr<Expression>> &arguments);
+typedef unique_ptr<FunctionData> (*init_local_state_t)(const BoundFunctionExpression &expr, FunctionData *bind_data);
 typedef unique_ptr<BaseStatistics> (*function_statistics_t)(ClientContext &context, BoundFunctionExpression &expr,
                                                             FunctionData *bind_data,
                                                             vector<unique_ptr<BaseStatistics>> &child_stats);
@@ -6307,23 +6321,27 @@ public:
 	ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
 	               bool has_side_effects = false, bind_scalar_function_t bind = nullptr,
 	               dependency_function_t dependency = nullptr, function_statistics_t statistics = nullptr,
+	               init_local_state_t init_local_state = nullptr,
 	               LogicalType varargs = LogicalType(LogicalTypeId::INVALID))
 	    : BaseScalarFunction(name, arguments, return_type, has_side_effects, varargs), function(function), bind(bind),
-	      dependency(dependency), statistics(statistics) {
+	      init_local_state(init_local_state), dependency(dependency), statistics(statistics) {
 	}
 
 	ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
 	               bool has_side_effects = false, bind_scalar_function_t bind = nullptr,
 	               dependency_function_t dependency = nullptr, function_statistics_t statistics = nullptr,
+	               init_local_state_t init_local_state = nullptr,
 	               LogicalType varargs = LogicalType(LogicalTypeId::INVALID))
 	    : ScalarFunction(string(), arguments, return_type, function, has_side_effects, bind, dependency, statistics,
-	                     varargs) {
+	                     init_local_state, varargs) {
 	}
 
 	//! The main scalar function to execute
 	scalar_function_t function;
 	//! The bind function (if any)
 	bind_scalar_function_t bind;
+	//! Init thread local state for the function (if any)
+	init_local_state_t init_local_state;
 	// The dependency function (if any)
 	dependency_function_t dependency;
 	//! The statistics propagation function (if any)