duckdb 0.5.2-dev582.0 → 0.5.2-dev602.0

package/package.json

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

package/src/duckdb.cpp

@@ -15918,6 +15918,7 @@ void FileBuffer::Clear() {
 
 namespace duckdb {
 
+class ClientContext;
 class Value;
 
 //! Abstract type that provide client-specific context to FileSystem.
@@ -15926,6 +15927,8 @@ public:
 	virtual ~FileOpener() {};
 
 	virtual bool TryGetCurrentSetting(const string &key, Value &result) = 0;
+
+	static FileOpener *Get(ClientContext &context);
 };
 
 } // namespace duckdb
@@ -38481,8 +38484,9 @@ vector<string> StringUtil::TopNStrings(vector<pair<string, idx_t>> scores, idx_t
 	if (scores.empty()) {
 		return vector<string>();
 	}
-	sort(scores.begin(), scores.end(),
-	     [](const pair<string, idx_t> &a, const pair<string, idx_t> &b) -> bool { return a.second < b.second; });
+	sort(scores.begin(), scores.end(), [](const pair<string, idx_t> &a, const pair<string, idx_t> &b) -> bool {
+		return a.second < b.second || (a.second == b.second && a.first.size() < b.first.size());
+	});
 	vector<string> result;
 	result.push_back(scores[0].first);
 	for (idx_t i = 1; i < MinValue<idx_t>(scores.size(), n); i++) {
@@ -38554,7 +38558,11 @@ vector<string> StringUtil::TopNLevenshtein(const vector<string> &strings, const
 	vector<pair<string, idx_t>> scores;
 	scores.reserve(strings.size());
 	for (auto &str : strings) {
-		scores.emplace_back(str, LevenshteinDistance(str, target));
+		if (target.size() < str.size()) {
+			scores.emplace_back(str, LevenshteinDistance(str.substr(0, target.size()), target));
+		} else {
+			scores.emplace_back(str, LevenshteinDistance(str, target));
+		}
 	}
 	return TopNStrings(scores, n, threshold);
 }
@@ -114621,37 +114629,48 @@ void PrintfFun::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct RegexpMatchesBindData : public FunctionData {
-	RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string);
-	~RegexpMatchesBindData() override;
+struct RegexpBaseBindData : public FunctionData {
+	RegexpBaseBindData();
+	RegexpBaseBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern = true);
+	virtual ~RegexpBaseBindData();
 
 	duckdb_re2::RE2::Options options;
 	string constant_string;
 	bool constant_pattern;
+
+	virtual bool Equals(const FunctionData &other_p) const override;
+};
+
+struct RegexpMatchesBindData : public RegexpBaseBindData {
+	RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern);
+	RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern,
+	                      string range_min, string range_max, bool range_success);
+
 	string range_min;
 	string range_max;
 	bool range_success;
 
 	unique_ptr<FunctionData> Copy() const override;
-	bool Equals(const FunctionData &other_p) const override;
 };
 
-struct RegexpReplaceBindData : public FunctionData {
-	duckdb_re2::RE2::Options options;
+struct RegexpReplaceBindData : public RegexpBaseBindData {
+	RegexpReplaceBindData();
+	RegexpReplaceBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern,
+	                      bool global_replace);
+
 	bool global_replace;
 
 	unique_ptr<FunctionData> Copy() const override;
 	bool Equals(const FunctionData &other_p) const override;
 };
 
-struct RegexpExtractBindData : public FunctionData {
-	RegexpExtractBindData(bool constant_pattern, const string &pattern, const string &group_string_p);
+struct RegexpExtractBindData : public RegexpBaseBindData {
+	RegexpExtractBindData();
+	RegexpExtractBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern,
+	                      string group_string);
 
-	const bool constant_pattern;
-	const string constant_string;
-
-	const string group_string;
-	const duckdb_re2::StringPiece rewrite;
+	string group_string;
+	duckdb_re2::StringPiece rewrite;
 
 	unique_ptr<FunctionData> Copy() const override;
 	bool Equals(const FunctionData &other_p) const override;
@@ -114672,41 +114691,49 @@ struct RegexpExtractBindData : public FunctionData {
 
 namespace duckdb {
 
-RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string_p)
-    : options(options), constant_string(move(constant_string_p)) {
-	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 = pattern->PossibleMatchRange(&range_min, &range_max, 1000);
-	} else {
-		range_success = false;
-	}
-}
-
 static bool RegexOptionsEquals(const duckdb_re2::RE2::Options &opt_a, const duckdb_re2::RE2::Options &opt_b) {
 	return opt_a.case_sensitive() == opt_b.case_sensitive();
 }
 
-RegexpMatchesBindData::~RegexpMatchesBindData() {
+RegexpBaseBindData::RegexpBaseBindData() : constant_pattern(false) {
+}
+RegexpBaseBindData::RegexpBaseBindData(duckdb_re2::RE2::Options options, string constant_string_p,
+                                       bool constant_pattern)
+    : options(options), constant_string(move(constant_string_p)), constant_pattern(constant_pattern) {
 }
 
-unique_ptr<FunctionData> RegexpMatchesBindData::Copy() const {
-	return make_unique<RegexpMatchesBindData>(options, constant_string);
+RegexpBaseBindData::~RegexpBaseBindData() {
 }
 
-bool RegexpMatchesBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (const RegexpMatchesBindData &)other_p;
-	return constant_string == other.constant_string && RegexOptionsEquals(options, other.options);
+bool RegexpBaseBindData::Equals(const FunctionData &other_p) const {
+	auto &other = (RegexpBaseBindData &)other_p;
+	return constant_pattern == other.constant_pattern && constant_string == other.constant_string &&
+	       RegexOptionsEquals(options, other.options);
 }
 
 static inline duckdb_re2::StringPiece CreateStringPiece(string_t &input) {
 	return duckdb_re2::StringPiece(input.GetDataUnsafe(), input.GetSize());
 }
 
+struct RegexLocalState : public FunctionLocalState {
+	explicit RegexLocalState(RegexpBaseBindData &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<FunctionLocalState> RegexInitLocalState(const BoundFunctionExpression &expr,
+                                                          FunctionData *bind_data) {
+	auto &info = (RegexpBaseBindData &)*bind_data;
+	if (info.constant_pattern) {
+		return make_unique<RegexLocalState>(info);
+	}
+	return nullptr;
+}
+
 static void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result, bool *global_replace = nullptr) {
 	for (idx_t i = 0; i < options.size(); i++) {
 		switch (options[i]) {
@@ -114751,41 +114778,88 @@ static void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &r
 	}
 }
 
-struct RegexPartialMatch {
-	static inline bool Operation(const duckdb_re2::StringPiece &input, duckdb_re2::RE2 &re) {
-		return duckdb_re2::RE2::PartialMatch(input, re);
+void ParseRegexOptions(Expression &expr, RE2::Options &target, bool *global_replace = nullptr) {
+	if (expr.HasParameter()) {
+		throw ParameterNotResolvedException();
 	}
-};
+	if (!expr.IsFoldable()) {
+		throw InvalidInputException("Regex options field must be a constant");
+	}
+	Value options_str = ExpressionExecutor::EvaluateScalar(expr);
+	if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
+		ParseRegexOptions(StringValue::Get(options_str), target, global_replace);
+	}
+}
 
-struct RegexFullMatch {
-	static inline bool Operation(const duckdb_re2::StringPiece &input, duckdb_re2::RE2 &re) {
-		return duckdb_re2::RE2::FullMatch(input, re);
+static bool TryParseConstantPattern(Expression &expr, string &constant_string) {
+	if (!expr.IsFoldable()) {
+		return false;
 	}
-};
+	Value pattern_str = ExpressionExecutor::EvaluateScalar(expr);
+	if (!pattern_str.IsNull() && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
+		constant_string = StringValue::Get(pattern_str);
+		return true;
+	}
+	return false;
+}
 
-struct RegexLocalState : public FunctionLocalState {
-	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);
+//===--------------------------------------------------------------------===//
+// Regexp Matches
+//===--------------------------------------------------------------------===//
+RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string_p,
+                                             bool constant_pattern)
+    : RegexpBaseBindData(options, move(constant_string_p), constant_pattern) {
+	if (constant_pattern) {
+		auto pattern = make_unique<RE2>(constant_string, options);
+		if (!pattern->ok()) {
+			throw Exception(pattern->error());
+		}
+
+		range_success = pattern->PossibleMatchRange(&range_min, &range_max, 1000);
+	} else {
+		range_success = false;
 	}
+}
 
-	explicit RegexLocalState(RegexpExtractBindData &info)
-	    : constant_pattern(duckdb_re2::StringPiece(info.constant_string.c_str(), info.constant_string.size())) {
-		D_ASSERT(info.constant_pattern);
+RegexpMatchesBindData::RegexpMatchesBindData(duckdb_re2::RE2::Options options, string constant_string_p,
+                                             bool constant_pattern, string range_min_p, string range_max_p,
+                                             bool range_success)
+    : RegexpBaseBindData(options, move(constant_string_p), constant_pattern), range_min(move(range_min_p)),
+      range_max(move(range_max_p)), range_success(range_success) {
+}
+
+unique_ptr<FunctionData> RegexpMatchesBindData::Copy() const {
+	return make_unique<RegexpMatchesBindData>(options, constant_string, constant_pattern, range_min, range_max,
+	                                          range_success);
+}
+
+static unique_ptr<FunctionData> RegexpMatchesBind(ClientContext &context, ScalarFunction &bound_function,
+                                                  vector<unique_ptr<Expression>> &arguments) {
+	// pattern is the second argument. If its constant, we can already prepare the pattern and store it for later.
+	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
+	RE2::Options options;
+	options.set_log_errors(false);
+	if (arguments.size() == 3) {
+		ParseRegexOptions(*arguments[2], options);
 	}
 
-	RE2 constant_pattern;
+	string constant_string;
+	bool constant_pattern;
+	constant_pattern = TryParseConstantPattern(*arguments[1], constant_string);
+	return make_unique<RegexpMatchesBindData>(options, move(constant_string), constant_pattern);
+}
+
+struct RegexPartialMatch {
+	static inline bool Operation(const duckdb_re2::StringPiece &input, duckdb_re2::RE2 &re) {
+		return duckdb_re2::RE2::PartialMatch(input, re);
+	}
 };
 
-static unique_ptr<FunctionLocalState> RegexInitLocalState(const BoundFunctionExpression &expr,
-                                                          FunctionData *bind_data) {
-	auto &info = (RegexpMatchesBindData &)*bind_data;
-	if (info.constant_pattern) {
-		return make_unique<RegexLocalState>(info);
+struct RegexFullMatch {
+	static inline bool Operation(const duckdb_re2::StringPiece &input, duckdb_re2::RE2 &re) {
+		return duckdb_re2::RE2::FullMatch(input, re);
 	}
-	return nullptr;
-}
+};
 
 template <class OP>
 static void RegexpMatchesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -114812,153 +114886,106 @@ static void RegexpMatchesFunction(DataChunk &args, ExpressionState &state, Vecto
 	}
 }
 
-static unique_ptr<FunctionData> RegexpMatchesBind(ClientContext &context, ScalarFunction &bound_function,
-                                                  vector<unique_ptr<Expression>> &arguments) {
-	// pattern is the second argument. If its constant, we can already prepare the pattern and store it for later.
-	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
-	RE2::Options options;
-	options.set_log_errors(false);
-	if (arguments.size() == 3) {
-		if (arguments[2]->HasParameter()) {
-			throw ParameterNotResolvedException();
-		}
-		if (!arguments[2]->IsFoldable()) {
-			throw InvalidInputException("Regex options field must be a constant");
-		}
-		Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[2]);
-		if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
-			ParseRegexOptions(StringValue::Get(options_str), options);
-		}
-	}
-
-	if (arguments[1]->IsFoldable()) {
-		Value pattern_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-		if (!pattern_str.IsNull() && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
-			return make_unique<RegexpMatchesBindData>(options, StringValue::Get(pattern_str));
-		}
-	}
-	return make_unique<RegexpMatchesBindData>(options, "");
+//===--------------------------------------------------------------------===//
+// Regexp Replace
+//===--------------------------------------------------------------------===//
+RegexpReplaceBindData::RegexpReplaceBindData() : global_replace(false) {
 }
 
-static void RegexReplaceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (RegexpReplaceBindData &)*func_expr.bind_info;
-
-	auto &strings = args.data[0];
-	auto &patterns = args.data[1];
-	auto &replaces = args.data[2];
-
-	TernaryExecutor::Execute<string_t, string_t, string_t, string_t>(
-	    strings, patterns, replaces, result, args.size(), [&](string_t input, string_t pattern, string_t replace) {
-		    RE2 re(CreateStringPiece(pattern), info.options);
-		    std::string sstring = input.GetString();
-		    if (info.global_replace) {
-			    RE2::GlobalReplace(&sstring, re, CreateStringPiece(replace));
-		    } else {
-			    RE2::Replace(&sstring, re, CreateStringPiece(replace));
-		    }
-		    return StringVector::AddString(result, sstring);
-	    });
+RegexpReplaceBindData::RegexpReplaceBindData(duckdb_re2::RE2::Options options, string constant_string_p,
+                                             bool constant_pattern, bool global_replace)
+    : RegexpBaseBindData(options, move(constant_string_p), constant_pattern), global_replace(global_replace) {
 }
 
 unique_ptr<FunctionData> RegexpReplaceBindData::Copy() const {
-	auto copy = make_unique<RegexpReplaceBindData>();
-	copy->options = options;
-	copy->global_replace = global_replace;
+	auto copy = make_unique<RegexpReplaceBindData>(options, constant_string, constant_pattern, global_replace);
 	return move(copy);
 }
 
 bool RegexpReplaceBindData::Equals(const FunctionData &other_p) const {
 	auto &other = (const RegexpReplaceBindData &)other_p;
-	return global_replace == other.global_replace && RegexOptionsEquals(options, other.options);
+	return RegexpBaseBindData::Equals(other) && global_replace == other.global_replace;
 }
 
 static unique_ptr<FunctionData> RegexReplaceBind(ClientContext &context, ScalarFunction &bound_function,
                                                  vector<unique_ptr<Expression>> &arguments) {
 	auto data = make_unique<RegexpReplaceBindData>();
-	data->options.set_log_errors(false);
+
+	data->constant_pattern = TryParseConstantPattern(*arguments[1], data->constant_string);
 	if (arguments.size() == 4) {
-		if (arguments[3]->HasParameter()) {
-			throw ParameterNotResolvedException();
-		}
-		if (!arguments[3]->IsFoldable()) {
-			throw InvalidInputException("Regex options field must be a constant");
-		}
-		Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[3]);
-		if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
-			ParseRegexOptions(StringValue::Get(options_str), data->options, &data->global_replace);
-		}
+		ParseRegexOptions(*arguments[3], data->options, &data->global_replace);
 	}
-
+	data->options.set_log_errors(false);
 	return move(data);
 }
 
-inline static string_t Extract(const string_t &input, Vector &result, const RE2 &re,
-                               const duckdb_re2::StringPiece &rewrite) {
-	std::string extracted;
-	RE2::Extract(input.GetString(), re, rewrite, &extracted);
-	return StringVector::AddString(result, extracted.c_str(), extracted.size());
-}
-
-static void RegexExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static void RegexReplaceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	const auto &info = (RegexpExtractBindData &)*func_expr.bind_info;
+	auto &info = (RegexpReplaceBindData &)*func_expr.bind_info;
 
 	auto &strings = args.data[0];
 	auto &patterns = args.data[1];
+	auto &replaces = args.data[2];
+
 	if (info.constant_pattern) {
 		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
-		UnaryExecutor::Execute<string_t, string_t>(strings, result, args.size(), [&](string_t input) {
-			return Extract(input, result, lstate.constant_pattern, info.rewrite);
-		});
+		BinaryExecutor::Execute<string_t, string_t, string_t>(
+		    strings, replaces, result, args.size(), [&](string_t input, string_t replace) {
+			    std::string sstring = input.GetString();
+			    if (info.global_replace) {
+				    RE2::GlobalReplace(&sstring, lstate.constant_pattern, CreateStringPiece(replace));
+			    } else {
+				    RE2::Replace(&sstring, lstate.constant_pattern, CreateStringPiece(replace));
+			    }
+			    return StringVector::AddString(result, sstring);
+		    });
 	} else {
-		BinaryExecutor::Execute<string_t, string_t, string_t>(strings, patterns, result, args.size(),
-		                                                      [&](string_t input, string_t pattern) {
-			                                                      RE2 re(CreateStringPiece(pattern));
-			                                                      return Extract(input, result, re, info.rewrite);
-		                                                      });
+		TernaryExecutor::Execute<string_t, string_t, string_t, string_t>(
+		    strings, patterns, replaces, result, args.size(), [&](string_t input, string_t pattern, string_t replace) {
+			    RE2 re(CreateStringPiece(pattern), info.options);
+			    std::string sstring = input.GetString();
+			    if (info.global_replace) {
+				    RE2::GlobalReplace(&sstring, re, CreateStringPiece(replace));
+			    } else {
+				    RE2::Replace(&sstring, re, CreateStringPiece(replace));
+			    }
+			    return StringVector::AddString(result, sstring);
+		    });
 	}
 }
 
-static unique_ptr<FunctionLocalState> RegexExtractInitLocalState(const BoundFunctionExpression &expr,
-                                                                 FunctionData *bind_data) {
-	auto &info = (RegexpExtractBindData &)*bind_data;
-	if (info.constant_pattern) {
-		return make_unique<RegexLocalState>(info);
-	}
-	return nullptr;
+//===--------------------------------------------------------------------===//
+// Regexp Extract
+//===--------------------------------------------------------------------===//
+RegexpExtractBindData::RegexpExtractBindData() {
 }
 
-RegexpExtractBindData::RegexpExtractBindData(bool constant_pattern, const string &constant_string,
-                                             const string &group_string_p)
-    : constant_pattern(constant_pattern), constant_string(constant_string), group_string(group_string_p),
+RegexpExtractBindData::RegexpExtractBindData(duckdb_re2::RE2::Options options, string constant_string_p,
+                                             bool constant_pattern, string group_string_p)
+    : RegexpBaseBindData(options, move(constant_string_p), constant_pattern), group_string(move(group_string_p)),
       rewrite(group_string) {
 }
 
 unique_ptr<FunctionData> RegexpExtractBindData::Copy() const {
-	return make_unique<RegexpExtractBindData>(constant_pattern, constant_string, group_string);
+	return make_unique<RegexpExtractBindData>(options, constant_string, constant_pattern, group_string);
 }
 
 bool RegexpExtractBindData::Equals(const FunctionData &other_p) const {
 	auto &other = (const RegexpExtractBindData &)other_p;
-	return constant_string == other.constant_string && group_string == other.group_string;
+	return RegexpBaseBindData::Equals(other) && group_string == other.group_string;
 }
 
 static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarFunction &bound_function,
                                                  vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(arguments.size() >= 2);
 
-	bool constant_pattern = arguments[1]->IsFoldable();
-	string pattern = "";
-	if (constant_pattern) {
-		Value pattern_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
-		if (!pattern_str.IsNull() && pattern_str.type().id() == LogicalTypeId::VARCHAR) {
-			pattern = StringValue::Get(pattern_str);
-		}
-	}
+	duckdb_re2::RE2::Options options;
+
+	string constant_string;
+	bool constant_pattern = TryParseConstantPattern(*arguments[1], constant_string);
 
 	string group_string = "";
-	if (arguments.size() == 3) {
+	if (arguments.size() >= 3) {
 		if (arguments[2]->HasParameter()) {
 			throw ParameterNotResolvedException();
 		}
@@ -114976,8 +115003,37 @@ static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarF
 	} else {
 		group_string = "\\0";
 	}
+	if (arguments.size() >= 4) {
+		ParseRegexOptions(*arguments[3], options);
+	}
+	return make_unique<RegexpExtractBindData>(options, move(constant_string), constant_pattern, move(group_string));
+}
+
+inline static string_t Extract(const string_t &input, Vector &result, const RE2 &re,
+                               const duckdb_re2::StringPiece &rewrite) {
+	std::string extracted;
+	RE2::Extract(input.GetString(), re, rewrite, &extracted);
+	return StringVector::AddString(result, extracted.c_str(), extracted.size());
+}
+
+static void RegexExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	const auto &info = (RegexpExtractBindData &)*func_expr.bind_info;
 
-	return make_unique<RegexpExtractBindData>(constant_pattern, pattern, group_string);
+	auto &strings = args.data[0];
+	auto &patterns = args.data[1];
+	if (info.constant_pattern) {
+		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+		UnaryExecutor::Execute<string_t, string_t>(strings, result, args.size(), [&](string_t input) {
+			return Extract(input, result, lstate.constant_pattern, info.rewrite);
+		});
+	} else {
+		BinaryExecutor::Execute<string_t, string_t, string_t>(strings, patterns, result, args.size(),
+		                                                      [&](string_t input, string_t pattern) {
+			                                                      RE2 re(CreateStringPiece(pattern), info.options);
+			                                                      return Extract(input, result, re, info.rewrite);
+		                                                      });
+	}
 }
 
 void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
@@ -115003,19 +115059,24 @@ void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 
 	ScalarFunctionSet regexp_replace("regexp_replace");
 	regexp_replace.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                          LogicalType::VARCHAR, RegexReplaceFunction, RegexReplaceBind));
-	regexp_replace.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                   LogicalType::VARCHAR, RegexReplaceFunction, RegexReplaceBind));
+	                                          LogicalType::VARCHAR, RegexReplaceFunction, RegexReplaceBind, nullptr,
+	                                          nullptr, RegexInitLocalState));
+	regexp_replace.AddFunction(ScalarFunction(
+	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	    RegexReplaceFunction, RegexReplaceBind, nullptr, nullptr, RegexInitLocalState));
 
 	ScalarFunctionSet regexp_extract("regexp_extract");
 	regexp_extract.AddFunction(
 	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR, RegexExtractFunction,
-	                   RegexExtractBind, nullptr, nullptr, RegexExtractInitLocalState, LogicalType::INVALID,
+	                   RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
 	                   FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
 	regexp_extract.AddFunction(ScalarFunction(
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::VARCHAR, RegexExtractFunction,
-	    RegexExtractBind, nullptr, nullptr, RegexExtractInitLocalState, LogicalType::INVALID,
+	    RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
+	    FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	regexp_extract.AddFunction(ScalarFunction(
+	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	    RegexExtractFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
 	    FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
 
 	set.AddFunction(regexp_full_match);
@@ -128400,6 +128461,10 @@ Executor &ClientContext::GetExecutor() {
 	return *active_query->executor;
 }
 
+FileOpener *FileOpener::Get(ClientContext &context) {
+	return ClientData::Get(context).file_opener.get();
+}
+
 const string &ClientContext::GetCurrentQuery() {
 	D_ASSERT(active_query);
 	return active_query->query;
@@ -162735,7 +162800,7 @@ bool KeywordHelper::IsKeyword(const string &text) {
 	return Parser::IsKeyword(text);
 }
 
-bool KeywordHelper::RequiresQuotes(const string &text) {
+bool KeywordHelper::RequiresQuotes(const string &text, bool allow_caps) {
 	for (size_t i = 0; i < text.size(); i++) {
 		if (i > 0 && (text[i] >= '0' && text[i] <= '9')) {
 			continue;
@@ -162743,6 +162808,11 @@ bool KeywordHelper::RequiresQuotes(const string &text) {
 		if (text[i] >= 'a' && text[i] <= 'z') {
 			continue;
 		}
+		if (allow_caps) {
+			if (text[i] >= 'A' && text[i] <= 'Z') {
+				continue;
+			}
+		}
 		if (text[i] == '_') {
 			continue;
 		}
@@ -162751,8 +162821,8 @@ bool KeywordHelper::RequiresQuotes(const string &text) {
 	return IsKeyword(text);
 }
 
-string KeywordHelper::WriteOptionallyQuoted(const string &text, char quote) {
-	if (!RequiresQuotes(text)) {
+string KeywordHelper::WriteOptionallyQuoted(const string &text, char quote, bool allow_caps) {
+	if (!RequiresQuotes(text, allow_caps)) {
 		return text;
 	}
 	return string(1, quote) + StringUtil::Replace(text, string(1, quote), string(2, quote)) + string(1, quote);