duckdb 0.6.2-dev971.0 → 0.7.1-dev11.0

package/binding.gyp

@@ -222,20 +222,24 @@
                 "src/duckdb/third_party/zstd/compress/zstd_lazy.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
-                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
-                "src/duckdb/extension/icu/./icu-datesub.cpp", 
                 "src/duckdb/extension/icu/./icu-timezone.cpp", 
-                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
-                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
-                "src/duckdb/extension/icu/./icu-datepart.cpp", 
                 "src/duckdb/extension/icu/./icu-makedate.cpp", 
-                "src/duckdb/extension/icu/./icu-extension.cpp", 
+                "src/duckdb/extension/icu/./icu-datepart.cpp", 
+                "src/duckdb/extension/icu/./icu-datesub.cpp", 
+                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
+                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
                 "src/duckdb/extension/icu/./icu-strptime.cpp", 
+                "src/duckdb/extension/icu/./icu-extension.cpp", 
+                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
+                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_common.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp", 
                 "src/duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp", 
+                "src/duckdb/extension/json/buffered_json_reader.cpp", 
                 "src/duckdb/extension/json/json-extension.cpp", 
                 "src/duckdb/extension/json/json_common.cpp", 
+                "src/duckdb/extension/json/json_functions.cpp", 
+                "src/duckdb/extension/json/json_scan.cpp", 
                 "src/duckdb/ub_extension_json_json_functions.cpp", 
                 "src/duckdb/extension/json/yyjson/yyjson.cpp"
             ], 
@@ -292,7 +296,8 @@
             "cflags": [
                 "-frtti", 
                 "-fexceptions", 
-                "-Wno-redundant-move"
+                "-Wno-redundant-move", 
+                "-frtti"
             ], 
             "cflags!": [
                 "-fno-rrti", 
@@ -314,7 +319,8 @@
                 "VCCLCompilerTool": {
                     "ExceptionHandling": 1, 
                     "AdditionalOptions": [
-                        "/bigobj"
+                        "/bigobj", 
+                        "/GR"
                     ]
                 }
             }, 

package/configure.py

@@ -85,8 +85,8 @@ else:
     source_list = [os.path.relpath(x, basedir) if os.path.isabs(x) else os.path.join('src', x) for x in source_list]
     include_list = [os.path.join('src', 'duckdb', x) for x in include_list]
     libraries = []
-    windows_options = []
-    cflags = []
+    windows_options = ['/GR']
+    cflags = ['-frtti']
 
 def sanitize_path(x):
     return x.replace('\\', '/')

package/lib/duckdb.d.ts

@@ -3,9 +3,13 @@
  * See https://duckdb.org/docs/api/nodejs/overview for details
  * on Node.JS API
  */
-export class DuckDbError extends Error {
-  errno: number;
-  code: string;
+
+/**
+ * Standard error shape for DuckDB errors
+ */
+export interface DuckDbError extends Error {
+  errno: -1; // value of ERROR
+  code: 'DUCKDB_NODEJS_ERROR';
 }
 
 type Callback<T> = (err: DuckDbError | null, res: T) => void;
@@ -61,6 +65,15 @@ export class IpcResultStreamIterator implements AsyncIterator<Uint8Array>, Async
   toArray(): Promise<ArrowArray>;
 }
 
+export interface ReplacementScanResult {
+  function: string;
+  parameters: Array<unknown>;
+}
+
+export type ReplacementScanCallback = (
+  table: string
+) => ReplacementScanResult | null;
+
 export class Database {
   constructor(path: string, accessMode?: number | Record<string,string>, callback?: Callback<any>);
   constructor(path: string, callback?: Callback<any>);
@@ -99,6 +112,10 @@ export class Database {
   register_buffer(name: string, array: ArrowIterable, force: boolean, callback?: Callback<void>): void;
 
   unregister_buffer(name: string, callback?: Callback<void>): void;
+
+  registerReplacementScan(
+    replacementScan: ReplacementScanCallback
+  ): Promise<void>;
 }
 
 export class Statement {

package/lib/duckdb.js

@@ -46,6 +46,10 @@ var OPEN_PRIVATECACHE = duckdb.OPEN_PRIVATECACHE;
 // some wrappers for compatibilities sake
 /**
  * Main database interface
+ * @arg path - path to database file or :memory: for in-memory database
+ * @arg access_mode - access mode
+ * @arg config - the configuration object
+ * @arg callback - callback function
  */
 var Database = duckdb.Database;
 /**
@@ -330,7 +334,6 @@ Connection.prototype.register_udf = function (name, return_type, fun) {
                 desc.ret.validity[i] = res === undefined || res === null ? 0 : 1;
             }
         } catch (error) { // work around recently fixed napi bug https://github.com/nodejs/node-addon-api/issues/912
-            console.log(desc.ret);
             msg = error;
             if (typeof error == 'object' && 'message' in error) {
                 msg = error.message
@@ -609,6 +612,15 @@ Database.prototype.unregister_udf = function () {
     return this;
 }
 
+/**
+ * Register a table replace scan function
+ * @method
+ * @arg fun Replacement scan function
+ * @return {this}
+ */
+
+Database.prototype.registerReplacementScan;
+
 /**
  * Not implemented
  */

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.6.2-dev971.0",
+  "version": "0.7.1-dev11.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {
@@ -19,6 +19,7 @@
     "install": "node-pre-gyp install --fallback-to-build",
     "pretest": "node test/support/createdb.js",
     "test": "mocha -R spec --timeout 480000 --expose-gc",
+    "test-path": "mocha -R spec --timeout 480000 --exclude 'test/*.ts'",
     "pack": "node-pre-gyp package"
   },
   "directories": {
@@ -26,6 +27,7 @@
     "test": "test"
   },
   "devDependencies": {
+    "@types/chai": "^4.3.4",
     "@types/mocha": "^10.0.0",
     "@types/node": "^18.11.0",
     "apache-arrow": "^9.0.0",

package/src/connection.cpp

@@ -213,7 +213,8 @@ void DuckDBNodeUDFLauncher(Napi::Env env, Napi::Function jsudf, std::nullptr_t *
 			auto data = ret.Get("data").As<Napi::Array>();
 			auto out = duckdb::FlatVector::GetData<duckdb::string_t>(*jsargs->result);
 			for (size_t i = 0; i < data.Length(); ++i) {
-				out[i] = duckdb::string_t(data.Get(i).ToString());
+				// Use the AddString method to save the memory into the StringHeap if it can't be inlined
+				out[i] = duckdb::StringVector::AddString(*jsargs->result, data.Get(i).ToString());
 			}
 			break;
 		}
@@ -370,7 +371,7 @@ struct ExecTask : public Task {
 			}
 
 			for (duckdb::idx_t i = 0; i < statements.size(); i++) {
-				auto res = connection.connection->Query(move(statements[i]));
+				auto res = connection.connection->Query(std::move(statements[i]));
 				if (res->HasError()) {
 					success = false;
 					error = res->GetErrorObject();
@@ -387,7 +388,8 @@ struct ExecTask : public Task {
 	void Callback() override {
 		auto env = object.Env();
 		Napi::HandleScope scope(env);
-		callback.Value().MakeCallback(object.Value(), {success ? env.Null() : Napi::String::New(env, error.Message())});
+		callback.Value().MakeCallback(object.Value(),
+		                              {success ? env.Null() : Utils::CreateError(env, error.Message())});
 	};
 
 	std::string sql;

package/src/database.cpp

@@ -1,7 +1,13 @@
-#include "duckdb_node.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb_node.hpp"
 #include "napi.h"
 
+#include <iostream>
+#include <thread>
+
 namespace node_duckdb {
 
 Napi::FunctionReference Database::constructor;
@@ -13,7 +19,8 @@ Napi::Object Database::Init(Napi::Env env, Napi::Object exports) {
 	    env, "Database",
 	    {InstanceMethod("close_internal", &Database::Close), InstanceMethod("wait", &Database::Wait),
 	     InstanceMethod("serialize", &Database::Serialize), InstanceMethod("parallelize", &Database::Parallelize),
-	     InstanceMethod("connect", &Database::Connect), InstanceMethod("interrupt", &Database::Interrupt)});
+	     InstanceMethod("connect", &Database::Connect), InstanceMethod("interrupt", &Database::Interrupt),
+	     InstanceMethod("registerReplacementScan", &Database::RegisterReplacementScan)});
 
 	constructor = Napi::Persistent(t);
 	constructor.SuppressDestruct();
@@ -37,13 +44,8 @@ struct OpenTask : public Task {
 			for (duckdb::idx_t config_idx = 0; config_idx < config_names.Length(); config_idx++) {
 				std::string key = config_names.Get(config_idx).As<Napi::String>();
 				std::string val = config_.Get(key).As<Napi::String>();
-				auto config_property = duckdb::DBConfig::GetOptionByName(key);
-				if (!config_property) {
-					Napi::TypeError::New(env, "Unrecognized configuration property" + key).ThrowAsJavaScriptException();
-					return;
-				}
 				try {
-					duckdb_config.SetOption(*config_property, duckdb::Value(val));
+					duckdb_config.SetOptionByName(key, duckdb::Value(val));
 				} catch (std::exception &e) {
 					Napi::TypeError::New(env, "Failed to set configuration option " + key + ": " + e.what())
 					    .ThrowAsJavaScriptException();
@@ -128,7 +130,7 @@ Database::~Database() {
 void Database::Schedule(Napi::Env env, std::unique_ptr<Task> task) {
 	{
 		std::lock_guard<std::mutex> lock(task_mutex);
-		task_queue.push(move(task));
+		task_queue.push(std::move(task));
 	}
 	Process(env);
 }
@@ -172,11 +174,11 @@ void Database::Process(Napi::Env env) {
 	}
 	task_inflight = true;
 
-	auto task = move(task_queue.front());
+	auto task = std::move(task_queue.front());
 	task_queue.pop();
 
 	auto holder = new TaskHolder();
-	holder->task = move(task);
+	holder->task = std::move(task);
 	holder->db = this;
 
 	napi_create_async_work(env, nullptr, Napi::String::New(env, "duckdb.Database.Task"), TaskExecuteCallback,
@@ -267,4 +269,108 @@ Napi::Value Database::Connect(const Napi::CallbackInfo &info) {
 	return Connection::constructor.New({Value()});
 }
 
+struct JSRSArgs {
+	std::string table = "";
+	std::string function = "";
+	std::vector<duckdb::Value> parameters;
+	bool done = false;
+	duckdb::PreservedError error;
+};
+
+struct NodeReplacementScanData : duckdb::ReplacementScanData {
+	NodeReplacementScanData(duckdb_node_rs_function_t rs) : rs(std::move(rs)) {};
+	duckdb_node_rs_function_t rs;
+};
+
+void DuckDBNodeRSLauncher(Napi::Env env, Napi::Function jsrs, std::nullptr_t *, JSRSArgs *jsargs) {
+	try {
+		Napi::EscapableHandleScope scope(env);
+		auto arg = Napi::String::New(env, jsargs->table);
+		auto result = jsrs({arg});
+		if (result && result.IsObject()) {
+			auto obj = result.As<Napi::Object>();
+			jsargs->function = obj.Get("function").ToString().Utf8Value();
+			auto parameters = obj.Get("parameters");
+			if (parameters.IsArray()) {
+				auto paramArray = parameters.As<Napi::Array>();
+				for (uint32_t i = 0; i < paramArray.Length(); i++) {
+					jsargs->parameters.push_back(Utils::BindParameter(paramArray.Get(i)));
+				}
+			} else {
+				throw duckdb::Exception("Expected parameter array");
+			}
+		} else if (!result.IsNull()) {
+			throw duckdb::Exception("Invalid scan replacement result");
+		}
+	} catch (const duckdb::Exception &e) {
+		jsargs->error = duckdb::PreservedError(e);
+	} catch (const std::exception &e) {
+		jsargs->error = duckdb::PreservedError(e);
+	}
+	jsargs->done = true;
+}
+
+static duckdb::unique_ptr<duckdb::TableRef>
+ScanReplacement(duckdb::ClientContext &context, const std::string &table_name, duckdb::ReplacementScanData *data) {
+	JSRSArgs jsargs;
+	jsargs.table = table_name;
+	((NodeReplacementScanData *)data)->rs.BlockingCall(&jsargs);
+	while (!jsargs.done) {
+		std::this_thread::yield();
+	}
+	if (jsargs.error) {
+		jsargs.error.Throw();
+	}
+	if (jsargs.function != "") {
+		auto table_function = duckdb::make_unique<duckdb::TableFunctionRef>();
+		std::vector<std::unique_ptr<duckdb::ParsedExpression>> children;
+		for (auto &param : jsargs.parameters) {
+			children.push_back(duckdb::make_unique<duckdb::ConstantExpression>(std::move(param)));
+		}
+		table_function->function =
+		    duckdb::make_unique<duckdb::FunctionExpression>(jsargs.function, std::move(children));
+		return std::move(table_function);
+	}
+	return nullptr;
+}
+
+struct RegisterRsTask : public Task {
+	RegisterRsTask(Database &database, duckdb_node_rs_function_t rs, Napi::Promise::Deferred deferred)
+	    : Task(database), rs(std::move(rs)), deferred(deferred) {
+	}
+
+	void DoWork() override {
+		auto &database = Get<Database>();
+		if (database.database) {
+			database.database->instance->config.replacement_scans.emplace_back(
+			    ScanReplacement, duckdb::make_unique<NodeReplacementScanData>(rs));
+		}
+	}
+
+	void DoCallback() override {
+		deferred.Resolve(deferred.Env().Undefined());
+	}
+
+	duckdb_node_rs_function_t rs;
+	Napi::Promise::Deferred deferred;
+};
+
+Napi::Value Database::RegisterReplacementScan(const Napi::CallbackInfo &info) {
+	auto env = info.Env();
+	auto deferred = Napi::Promise::Deferred::New(info.Env());
+	if (info.Length() < 1) {
+		Napi::TypeError::New(env, "Replacement scan callback expected").ThrowAsJavaScriptException();
+		return env.Null();
+	}
+	Napi::Function rs_callback = info[0].As<Napi::Function>();
+	auto rs =
+	    duckdb_node_rs_function_t::New(env, rs_callback, "duckdb_node_rs_" + std::to_string(replacement_scan_count++),
+	                                   0, 1, nullptr, [](Napi::Env, void *, std::nullptr_t *ctx) {});
+	rs.Unref(env);
+
+	Schedule(info.Env(), duckdb::make_unique<RegisterRsTask>(*this, rs, deferred));
+
+	return deferred.Promise();
+}
+
 } // namespace node_duckdb

package/src/duckdb/extension/icu/icu-dateadd.cpp

@@ -1,12 +1,12 @@
 #include "include/icu-dateadd.hpp"
-#include "include/icu-datefunc.hpp"
 
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/operator/add.hpp"
 #include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "include/icu-datefunc.hpp"
 
 namespace duckdb {
 
@@ -31,8 +31,32 @@ struct ICUCalendarAge : public ICUDateFunc {
 	}
 };
 
+static inline void CalendarAddHour(icu::Calendar *calendar, int64_t interval_hour, UErrorCode &status) {
+	if (interval_hour >= 0) {
+		while (interval_hour > 0) {
+			calendar->add(UCAL_HOUR,
+			              interval_hour > NumericLimits<int32_t>::Maximum() ? NumericLimits<int32_t>::Maximum()
+			                                                                : interval_hour,
+			              status);
+			interval_hour -= NumericLimits<int32_t>::Maximum();
+		}
+	} else {
+		while (interval_hour < 0) {
+			calendar->add(UCAL_HOUR,
+			              interval_hour < NumericLimits<int32_t>::Minimum() ? NumericLimits<int32_t>::Minimum()
+			                                                                : interval_hour,
+			              status);
+			interval_hour -= NumericLimits<int32_t>::Minimum();
+		}
+	}
+}
+
 template <>
 timestamp_t ICUCalendarAdd::Operation(timestamp_t timestamp, interval_t interval, icu::Calendar *calendar) {
+	if (!Timestamp::IsFinite(timestamp)) {
+		return timestamp;
+	}
+
 	int64_t millis = timestamp.value / Interval::MICROS_PER_MSEC;
 	int64_t micros = timestamp.value % Interval::MICROS_PER_MSEC;
 
@@ -57,10 +81,37 @@ timestamp_t ICUCalendarAdd::Operation(timestamp_t timestamp, interval_t interval
 	const auto udate = UDate(millis);
 	calendar->setTime(udate, status);
 
-	// Add interval fields from lowest to highest
-	calendar->add(UCAL_MILLISECOND, interval.micros / Interval::MICROS_PER_MSEC, status);
-	calendar->add(UCAL_DATE, interval.days, status);
-	calendar->add(UCAL_MONTH, interval.months, status);
+	// Break units apart to avoid overflow
+	auto interval_h = interval.micros / Interval::MICROS_PER_MSEC;
+
+	const auto interval_ms = interval_h % Interval::MSECS_PER_SEC;
+	interval_h /= Interval::MSECS_PER_SEC;
+
+	const auto interval_s = interval_h % Interval::SECS_PER_MINUTE;
+	interval_h /= Interval::SECS_PER_MINUTE;
+
+	const auto interval_m = interval_h % Interval::MINS_PER_HOUR;
+	interval_h /= Interval::MINS_PER_HOUR;
+
+	if (interval.months < 0 || interval.days < 0 || interval.micros < 0) {
+		// Add interval fields from lowest to highest (non-ragged to ragged)
+		calendar->add(UCAL_MILLISECOND, interval_ms, status);
+		calendar->add(UCAL_SECOND, interval_s, status);
+		calendar->add(UCAL_MINUTE, interval_m, status);
+		CalendarAddHour(calendar, interval_h, status);
+
+		calendar->add(UCAL_DATE, interval.days, status);
+		calendar->add(UCAL_MONTH, interval.months, status);
+	} else {
+		// Add interval fields from highest to lowest (ragged to non-ragged)
+		calendar->add(UCAL_MONTH, interval.months, status);
+		calendar->add(UCAL_DATE, interval.days, status);
+
+		CalendarAddHour(calendar, interval_h, status);
+		calendar->add(UCAL_MINUTE, interval_m, status);
+		calendar->add(UCAL_SECOND, interval_s, status);
+		calendar->add(UCAL_MILLISECOND, interval_ms, status);
+	}
 
 	return ICUDateFunc::GetTime(calendar, micros);
 }
@@ -237,6 +288,18 @@ struct ICUDateAdd : public ICUDateFunc {
 	}
 };
 
+timestamp_t ICUDateFunc::Add(icu::Calendar *calendar, timestamp_t timestamp, interval_t interval) {
+	return ICUCalendarAdd::Operation<timestamp_t, interval_t, timestamp_t>(timestamp, interval, calendar);
+}
+
+timestamp_t ICUDateFunc::Sub(icu::Calendar *calendar, timestamp_t timestamp, interval_t interval) {
+	return ICUCalendarSub::Operation<timestamp_t, interval_t, timestamp_t>(timestamp, interval, calendar);
+}
+
+interval_t ICUDateFunc::Sub(icu::Calendar *calendar, timestamp_t end_date, timestamp_t start_date) {
+	return ICUCalendarSub::Operation<timestamp_t, timestamp_t, interval_t>(end_date, start_date, calendar);
+}
+
 void RegisterICUDateAddFunctions(ClientContext &context) {
 	ICUDateAdd::AddDateAddOperators("+", context);
 	ICUDateAdd::AddDateSubOperators("-", context);

package/src/duckdb/extension/icu/icu-datefunc.cpp

@@ -112,14 +112,6 @@ int32_t ICUDateFunc::ExtractField(icu::Calendar *calendar, UCalendarDateFields f
 }
 
 int64_t ICUDateFunc::SubtractField(icu::Calendar *calendar, UCalendarDateFields field, timestamp_t end_date) {
-	// ICU triggers the address sanitiser because it tries to left shift a negative value
-	// when start_date > end_date. To avoid this, we swap the values and negate the result.
-	const auto start_date = GetTimeUnsafe(calendar);
-	if (start_date > end_date) {
-		SetTime(calendar, end_date);
-		return -SubtractField(calendar, field, start_date);
-	}
-
 	const int64_t millis = end_date.value / Interval::MICROS_PER_MSEC;
 	const auto when = UDate(millis);
 	UErrorCode status = U_ZERO_ERROR;

package/src/duckdb/extension/icu/icu-datepart.cpp

@@ -411,7 +411,7 @@ struct ICUDatePart : public ICUDateFunc {
 		}
 
 		Function::EraseArgument(bound_function, arguments, 0);
-		bound_function.return_type = LogicalType::STRUCT(move(struct_children));
+		bound_function.return_type = LogicalType::STRUCT(std::move(struct_children));
 		return make_unique<data_t>(context, adapters);
 	}
 

package/src/duckdb/extension/icu/icu-extension.cpp

@@ -14,6 +14,7 @@
 #include "include/icu-datetrunc.hpp"
 #include "include/icu-makedate.hpp"
 #include "include/icu-strptime.hpp"
+#include "include/icu-timebucket.hpp"
 #include "include/icu-timezone.hpp"
 
 #include "duckdb/main/database.hpp"
@@ -39,7 +40,7 @@ struct IcuBindData : public FunctionData {
 	string language;
 	string country;
 
-	IcuBindData(string language_p, string country_p) : language(move(language_p)), country(move(country_p)) {
+	IcuBindData(string language_p, string country_p) : language(std::move(language_p)), country(std::move(country_p)) {
 		UErrorCode status = U_ZERO_ERROR;
 		auto locale = icu::Locale(language.c_str(), country.c_str());
 		if (locale.isBogus()) {
@@ -248,7 +249,7 @@ void ICUExtension::Load(DuckDB &db) {
 	ScalarFunction sort_key("icu_sort_key", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                        ICUCollateFunction, ICUSortKeyBind);
 
-	CreateScalarFunctionInfo sort_key_info(move(sort_key));
+	CreateScalarFunctionInfo sort_key_info(std::move(sort_key));
 	catalog.CreateFunction(*con.context, &sort_key_info);
 
 	// Time Zones
@@ -266,6 +267,7 @@ void ICUExtension::Load(DuckDB &db) {
 	RegisterICUDateTruncFunctions(*con.context);
 	RegisterICUMakeDateFunctions(*con.context);
 	RegisterICUStrptimeFunctions(*con.context);
+	RegisterICUTimeBucketFunctions(*con.context);
 	RegisterICUTimeZoneFunctions(*con.context);
 
 	// Calendars
@@ -275,7 +277,7 @@ void ICUExtension::Load(DuckDB &db) {
 	                          SetICUCalendar);
 
 	TableFunction cal_names("icu_calendar_names", {}, ICUCalendarFunction, ICUCalendarBind, ICUCalendarInit);
-	CreateTableFunctionInfo cal_names_info(move(cal_names));
+	CreateTableFunctionInfo cal_names_info(std::move(cal_names));
 	catalog.CreateTableFunction(*con.context, &cal_names_info);
 
 	con.Commit();

package/src/duckdb/extension/icu/icu-strptime.cpp

@@ -222,7 +222,7 @@ struct ICUStrptime : public ICUDateFunc {
 
 		auto cast_data = make_unique<CastData>(make_unique<BindData>(*input.context));
 
-		return BoundCastInfo(CastFromVarchar, move(cast_data));
+		return BoundCastInfo(CastFromVarchar, std::move(cast_data));
 	}
 
 	static void AddCasts(ClientContext &context) {
@@ -407,7 +407,7 @@ struct ICUStrftime : public ICUDateFunc {
 
 		auto cast_data = make_unique<CastData>(make_unique<BindData>(*input.context));
 
-		return BoundCastInfo(CastToVarchar, move(cast_data));
+		return BoundCastInfo(CastToVarchar, std::move(cast_data));
 	}
 
 	static void AddCasts(ClientContext &context) {