duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

package/binding.gyp

@@ -12,6 +12,7 @@
                 "src/duckdb/ub_src_catalog.cpp", 
                 "src/duckdb/ub_src_catalog_catalog_entry.cpp", 
                 "src/duckdb/ub_src_catalog_default.cpp", 
+                "src/duckdb/ub_src_common_adbc.cpp", 
                 "src/duckdb/ub_src_common.cpp", 
                 "src/duckdb/ub_src_common_arrow.cpp", 
                 "src/duckdb/ub_src_common_crypto.cpp", 
@@ -22,6 +23,8 @@
                 "src/duckdb/ub_src_common_serializer.cpp", 
                 "src/duckdb/ub_src_common_sort.cpp", 
                 "src/duckdb/ub_src_common_types.cpp", 
+                "src/duckdb/ub_src_common_types_column.cpp", 
+                "src/duckdb/ub_src_common_types_row.cpp", 
                 "src/duckdb/ub_src_common_value_operations.cpp", 
                 "src/duckdb/src/common/vector_operations/boolean_operators.cpp", 
                 "src/duckdb/src/common/vector_operations/comparison_operators.cpp", 
@@ -69,6 +72,7 @@
                 "src/duckdb/ub_src_function_scalar_operators.cpp", 
                 "src/duckdb/ub_src_function_scalar_sequence.cpp", 
                 "src/duckdb/ub_src_function_scalar_string.cpp", 
+                "src/duckdb/ub_src_function_scalar_string_regexp.cpp", 
                 "src/duckdb/ub_src_function_scalar_struct.cpp", 
                 "src/duckdb/ub_src_function_scalar_system.cpp", 
                 "src/duckdb/ub_src_function_scalar_union.cpp", 
@@ -223,17 +227,18 @@
                 "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-dateadd.cpp", 
-                "src/duckdb/extension/icu/./icu-table-range.cpp", 
                 "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
                 "src/duckdb/extension/icu/./icu-strptime.cpp", 
-                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
+                "src/duckdb/extension/icu/./icu-timezone.cpp", 
                 "src/duckdb/extension/icu/./icu-extension.cpp", 
+                "src/duckdb/extension/icu/./icu-datepart.cpp", 
+                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
+                "src/duckdb/extension/icu/./icu-list-range.cpp", 
+                "src/duckdb/extension/icu/./icu-table-range.cpp", 
+                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
                 "src/duckdb/extension/icu/./icu-makedate.cpp", 
-                "src/duckdb/extension/icu/./icu-timezone.cpp", 
+                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
                 "src/duckdb/extension/icu/./icu-datesub.cpp", 
-                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
-                "src/duckdb/extension/icu/./icu-datepart.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", 
@@ -242,6 +247,8 @@
                 "src/duckdb/extension/json/json_common.cpp", 
                 "src/duckdb/extension/json/json_functions.cpp", 
                 "src/duckdb/extension/json/json_scan.cpp", 
+                "src/duckdb/extension/json/json_serializer.cpp", 
+                "src/duckdb/extension/json/json_deserializer.cpp", 
                 "src/duckdb/ub_extension_json_json_functions.cpp", 
                 "src/duckdb/extension/json/yyjson/yyjson.cpp"
             ], 

package/lib/duckdb.d.ts

@@ -4,14 +4,67 @@
  * on Node.JS API
  */
 
+export type ExceptionType =
+    | "Invalid"          // invalid type
+    | "Out of Range"     // value out of range error
+    | "Conversion"       // conversion/casting error
+    | "Unknown Type"     // unknown type
+    | "Decimal"          // decimal related
+    | "Mismatch Type"    // type mismatch
+    | "Divide by Zero"   // divide by 0
+    | "Object Size"      // object size exceeded
+    | "Invalid type"     // incompatible for operation
+    | "Serialization"    // serialization
+    | "TransactionContext" // transaction management
+    | "Not implemented"  // method not implemented
+    | "Expression"       // expression parsing
+    | "Catalog"          // catalog related
+    | "Parser"           // parser related
+    | "Binder"           // binder related
+    | "Planner"          // planner related
+    | "Scheduler"        // scheduler related
+    | "Executor"         // executor related
+    | "Constraint"       // constraint related
+    | "Index"            // index related
+    | "Stat"             // stat related
+    | "Connection"       // connection related
+    | "Syntax"           // syntax related
+    | "Settings"         // settings related
+    | "Optimizer"        // optimizer related
+    | "NullPointer"      // nullptr exception
+    | "IO"               // IO exception
+    | "INTERRUPT"        // interrupt
+    | "FATAL"            // Fatal exceptions are non-recoverable and render the entire DB in an unusable state
+    | "INTERNAL"         // Internal exceptions indicate something went wrong internally (i.e. bug in the code base)
+    | "Invalid Input"    // Input or arguments error
+    | "Out of Memory"    // out of memory
+    | "Permission"       // insufficient permissions
+    | "Parameter Not Resolved" // parameter types could not be resolved
+    | "Parameter Not Allowed"  // parameter types not allowed
+    | "Dependency"       // dependency
+    | "Unknown"
+    | "HTTP"
+    ;
+
 /**
  * Standard error shape for DuckDB errors
  */
-export interface DuckDbError extends Error {
+export interface _DuckDbError extends Error {
   errno: -1; // value of ERROR
   code: 'DUCKDB_NODEJS_ERROR';
+  errorType: ExceptionType;
+}
+
+export interface HttpError extends _DuckDbError {
+  errorType: 'HTTP';
+  statusCode: number;
+  response: string;
+  reason: string;
+  headers: Record<string, string>;
 }
 
+export type DuckDbError = HttpError | _DuckDbError;
+
 type Callback<T> = (err: DuckDbError | null, res: T) => void;
 
 export type RowData = {
@@ -47,7 +100,7 @@ export class Connection {
   unregister_udf(name: string, callback: Callback<any>): void;
 
   stream(sql: any, ...args: any[]): QueryResult;
-  arrowIPCStream(sql: any, ...args: any[]): IpcResultStreamIterator;
+  arrowIPCStream(sql: any, ...args: any[]): Promise<IpcResultStreamIterator>;
 
   register_buffer(name: string, array: ArrowIterable, force: boolean, callback?: Callback<void>): void;
   unregister_buffer(name: string, callback?: Callback<void>): void;

package/lib/duckdb.js

@@ -189,7 +189,7 @@ Connection.prototype.arrowIPCAll = function (sql) {
  * @arg sql
  * @param {...*} params
  * @param callback
- * @return IpcResultStreamIterator
+ * @return Promise<IpcResultStreamIterator>
  */
 Connection.prototype.arrowIPCStream = async function (sql) {
     const query = "SELECT * FROM to_arrow_ipc((" + sql + "));";
@@ -688,3 +688,22 @@ Statement.prototype.stream;
  * @returns sql contained in statement
  */
 Statement.prototype.sql;
+
+/**
+ * @typedef DuckDbError
+ * @type {object}
+ * @property {number} errno - -1 for DuckDB errors
+ * @property {string} message - Error message
+ * @property {string} code - 'DUCKDB_NODEJS_ERROR' for DuckDB errors
+ * @property {string} errorType - DuckDB error type code (eg, HTTP, IO, Catalog)
+ */
+
+/**
+ * @typedef HTTPError
+ * @type {object}
+ * @extends {DuckDbError}
+ * @property {number} statusCode - HTTP response status code
+ * @property {string} reason - HTTP response reason
+ * @property {string} response - HTTP response body
+ * @property {object} headers - HTTP headers
+ */

package/package.json

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

package/src/connection.cpp

@@ -38,14 +38,14 @@ struct ConnectTask : public Task {
 		if (!connection.database_ref || !connection.database_ref->database) {
 			return;
 		}
-		connection.connection = duckdb::make_unique<duckdb::Connection>(*connection.database_ref->database);
+		connection.connection = duckdb::make_uniq<duckdb::Connection>(*connection.database_ref->database);
 		success = true;
 	}
 	void Callback() override {
 		auto &connection = Get<Connection>();
 		Napi::Env env = connection.Env();
 
-		std::vector<napi_value> args;
+		vector<napi_value> args;
 		if (!success) {
 			args.push_back(Utils::CreateError(env, "Invalid database object"));
 		} else {
@@ -80,14 +80,14 @@ Connection::Connection(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Connec
 	// Register replacement scan
 	// TODO: disabled currently, either fix or remove.
 	//	database_ref->database->instance->config.replacement_scans.emplace_back(
-	//	    ScanReplacement, duckdb::make_unique<NodeReplacementScanData>(this));
+	//	    ScanReplacement, duckdb::make_uniq<NodeReplacementScanData>(this));
 
 	Napi::Function callback;
 	if (info.Length() > 0 && info[1].IsFunction()) {
 		callback = info[1].As<Napi::Function>();
 	}
 
-	database_ref->Schedule(env, duckdb::make_unique<ConnectTask>(*this, callback));
+	database_ref->Schedule(env, duckdb::make_uniq<ConnectTask>(*this, callback));
 }
 
 Connection::~Connection() {
@@ -96,7 +96,7 @@ Connection::~Connection() {
 }
 
 Napi::Value Connection::Prepare(const Napi::CallbackInfo &info) {
-	std::vector<napi_value> args;
+	vector<napi_value> args;
 	// push the connection as first argument
 	args.push_back(Value());
 	// we need to pass all the arguments onward to statement
@@ -270,8 +270,8 @@ struct RegisterUdfTask : public Task {
 		auto &cast = (duckdb::CastExpression &)*expr[0];
 		auto return_type = cast.cast_type;
 
-		connection.connection->CreateVectorizedFunction(name, std::vector<duckdb::LogicalType> {}, return_type,
-		                                                udf_function, duckdb::LogicalType::ANY);
+		connection.connection->CreateVectorizedFunction(name, vector<duckdb::LogicalType> {}, return_type, udf_function,
+		                                                duckdb::LogicalType::ANY);
 	}
 	std::string name;
 	std::string return_type_name;
@@ -306,7 +306,7 @@ Napi::Value Connection::RegisterUdf(const Napi::CallbackInfo &info) {
 	udfs[name] = udf;
 
 	database_ref->Schedule(info.Env(),
-	                       duckdb::make_unique<RegisterUdfTask>(*this, name, return_type_name, completion_callback));
+	                       duckdb::make_uniq<RegisterUdfTask>(*this, name, return_type_name, completion_callback));
 
 	return Value();
 }
@@ -351,7 +351,7 @@ Napi::Value Connection::UnregisterUdf(const Napi::CallbackInfo &info) {
 		callback = info[1].As<Napi::Function>();
 	}
 
-	database_ref->Schedule(info.Env(), duckdb::make_unique<UnregisterUdfTask>(*this, name, callback));
+	database_ref->Schedule(info.Env(), duckdb::make_uniq<UnregisterUdfTask>(*this, name, callback));
 	return Value();
 }
 
@@ -388,8 +388,7 @@ struct ExecTask : public Task {
 	void Callback() override {
 		auto env = object.Env();
 		Napi::HandleScope scope(env);
-		callback.Value().MakeCallback(object.Value(),
-		                              {success ? env.Null() : Utils::CreateError(env, error.Message())});
+		callback.Value().MakeCallback(object.Value(), {success ? env.Null() : Utils::CreateError(env, error)});
 	};
 
 	std::string sql;
@@ -426,7 +425,7 @@ Napi::Value Connection::Exec(const Napi::CallbackInfo &info) {
 		callback = info[1].As<Napi::Function>();
 	}
 
-	database_ref->Schedule(info.Env(), duckdb::make_unique<ExecTask>(*this, sql, callback));
+	database_ref->Schedule(info.Env(), duckdb::make_uniq<ExecTask>(*this, sql, callback));
 	return Value();
 }
 
@@ -484,7 +483,7 @@ Napi::Value Connection::RegisterBuffer(const Napi::CallbackInfo &info) {
 		callback = info[3].As<Napi::Function>();
 	}
 
-	database_ref->Schedule(info.Env(), duckdb::make_unique<ExecTask>(*this, final_query, callback));
+	database_ref->Schedule(info.Env(), duckdb::make_uniq<ExecTask>(*this, final_query, callback));
 
 	return Value();
 }
@@ -511,7 +510,7 @@ Napi::Value Connection::UnRegisterBuffer(const Napi::CallbackInfo &info) {
 	};
 
 	database_ref->Schedule(info.Env(),
-	                       duckdb::make_unique<ExecTaskWithCallback>(*this, final_query, callback, cpp_callback));
+	                       duckdb::make_uniq<ExecTaskWithCallback>(*this, final_query, callback, cpp_callback));
 
 	return Value();
 }

package/src/data_chunk.cpp

@@ -18,7 +18,7 @@ Napi::Array EncodeDataChunk(Napi::Env env, duckdb::DataChunk &chunk, bool with_t
 		}
 
 		// Do a post-order DFS traversal
-		std::vector<std::tuple<bool, duckdb::Vector *, Napi::Object, size_t, size_t>> pending;
+		vector<std::tuple<bool, duckdb::Vector *, Napi::Object, size_t, size_t>> pending;
 		pending.emplace_back(false, &chunk_vec, Napi::Object::New(env), 0, 0);
 
 		while (!pending.empty()) {
@@ -145,7 +145,19 @@ Napi::Array EncodeDataChunk(Napi::Env env, duckdb::DataChunk &chunk, bool with_t
 				}
 				break;
 			}
-			case duckdb::LogicalTypeId::BLOB:
+			case duckdb::LogicalTypeId::BLOB: {
+				if (with_data) {
+					auto array = Napi::Array::New(env, chunk.size());
+					auto data = duckdb::FlatVector::GetData<duckdb::string_t>(*vec);
+
+					for (size_t i = 0; i < chunk.size(); ++i) {
+						auto buf = Napi::Buffer<char>::Copy(env, data[i].GetDataUnsafe(), data[i].GetSize());
+						array.Set(i, buf);
+					}
+					desc.Set("data", array);
+				}
+				break;
+			}
 			case duckdb::LogicalTypeId::VARCHAR: {
 				if (with_data) {
 					auto array = Napi::Array::New(env, chunk.size());

package/src/database.cpp

@@ -57,7 +57,7 @@ struct OpenTask : public Task {
 
 	void DoWork() override {
 		try {
-			Get<Database>().database = duckdb::make_unique<duckdb::DuckDB>(filename, &duckdb_config);
+			Get<Database>().database = duckdb::make_uniq<duckdb::DuckDB>(filename, &duckdb_config);
 			success = true;
 
 		} catch (const duckdb::Exception &ex) {
@@ -71,9 +71,9 @@ struct OpenTask : public Task {
 		auto &database = Get<Database>();
 		Napi::Env env = database.Env();
 
-		std::vector<napi_value> args;
+		vector<napi_value> args;
 		if (!success) {
-			args.push_back(Utils::CreateError(env, error.Message()));
+			args.push_back(Utils::CreateError(env, error));
 		} else {
 			args.push_back(env.Null());
 		}
@@ -120,14 +120,14 @@ Database::Database(const Napi::CallbackInfo &info)
 		callback = info[pos++].As<Napi::Function>();
 	}
 
-	Schedule(env, duckdb::make_unique<OpenTask>(*this, filename, access_mode, config, callback));
+	Schedule(env, duckdb::make_uniq<OpenTask>(*this, filename, access_mode, config, callback));
 }
 
 Database::~Database() {
 	Napi::MemoryManagement::AdjustExternalMemory(env, -bytes_allocated);
 }
 
-void Database::Schedule(Napi::Env env, std::unique_ptr<Task> task) {
+void Database::Schedule(Napi::Env env, duckdb::unique_ptr<Task> task) {
 	{
 		std::lock_guard<std::mutex> lock(task_mutex);
 		task_queue.push(std::move(task));
@@ -141,7 +141,7 @@ static void TaskExecuteCallback(napi_env e, void *data) {
 }
 
 static void TaskCompleteCallback(napi_env e, napi_status status, void *data) {
-	std::unique_ptr<TaskHolder> holder((TaskHolder *)data);
+	duckdb::unique_ptr<TaskHolder> holder((TaskHolder *)data);
 	holder->db->TaskComplete(e);
 	holder->task->DoCallback();
 }
@@ -216,7 +216,7 @@ struct WaitTask : public Task {
 };
 
 Napi::Value Database::Wait(const Napi::CallbackInfo &info) {
-	Schedule(info.Env(), duckdb::make_unique<WaitTask>(*this, info[0].As<Napi::Function>()));
+	Schedule(info.Env(), duckdb::make_uniq<WaitTask>(*this, info[0].As<Napi::Function>()));
 	return info.This();
 }
 
@@ -256,7 +256,7 @@ Napi::Value Database::Close(const Napi::CallbackInfo &info) {
 		callback = info[0].As<Napi::Function>();
 	}
 
-	Schedule(info.Env(), duckdb::make_unique<CloseTask>(*this, callback));
+	Schedule(info.Env(), duckdb::make_uniq<CloseTask>(*this, callback));
 
 	return info.This();
 }
@@ -272,7 +272,7 @@ Napi::Value Database::Connect(const Napi::CallbackInfo &info) {
 struct JSRSArgs {
 	std::string table = "";
 	std::string function = "";
-	std::vector<duckdb::Value> parameters;
+	vector<duckdb::Value> parameters;
 	bool done = false;
 	duckdb::PreservedError error;
 };
@@ -322,13 +322,12 @@ ScanReplacement(duckdb::ClientContext &context, const std::string &table_name, d
 		jsargs.error.Throw();
 	}
 	if (jsargs.function != "") {
-		auto table_function = duckdb::make_unique<duckdb::TableFunctionRef>();
-		std::vector<std::unique_ptr<duckdb::ParsedExpression>> children;
+		auto table_function = duckdb::make_uniq<duckdb::TableFunctionRef>();
+		duckdb::vector<duckdb::unique_ptr<duckdb::ParsedExpression>> children;
 		for (auto &param : jsargs.parameters) {
-			children.push_back(duckdb::make_unique<duckdb::ConstantExpression>(std::move(param)));
+			children.push_back(duckdb::make_uniq<duckdb::ConstantExpression>(std::move(param)));
 		}
-		table_function->function =
-		    duckdb::make_unique<duckdb::FunctionExpression>(jsargs.function, std::move(children));
+		table_function->function = duckdb::make_uniq<duckdb::FunctionExpression>(jsargs.function, std::move(children));
 		return std::move(table_function);
 	}
 	return nullptr;
@@ -343,7 +342,7 @@ struct RegisterRsTask : public Task {
 		auto &database = Get<Database>();
 		if (database.database) {
 			database.database->instance->config.replacement_scans.emplace_back(
-			    ScanReplacement, duckdb::make_unique<NodeReplacementScanData>(rs));
+			    ScanReplacement, duckdb::make_uniq<NodeReplacementScanData>(rs));
 		}
 	}
 
@@ -368,7 +367,7 @@ Napi::Value Database::RegisterReplacementScan(const Napi::CallbackInfo &info) {
 	                                   0, 1, nullptr, [](Napi::Env, void *, std::nullptr_t *ctx) {});
 	rs.Unref(env);
 
-	Schedule(info.Env(), duckdb::make_unique<RegisterRsTask>(*this, rs, deferred));
+	Schedule(info.Env(), duckdb::make_uniq<RegisterRsTask>(*this, rs, deferred));
 
 	return deferred.Promise();
 }

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

@@ -197,7 +197,7 @@ struct ICUDateAdd : public ICUDateFunc {
 	static void ExecuteUnary(DataChunk &args, ExpressionState &state, Vector &result) {
 		D_ASSERT(args.ColumnCount() == 1);
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar(info.calendar->clone());
 
@@ -217,7 +217,7 @@ struct ICUDateAdd : public ICUDateFunc {
 	static void ExecuteBinary(DataChunk &args, ExpressionState &state, Vector &result) {
 		D_ASSERT(args.ColumnCount() == 2);
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar(info.calendar->clone());
 

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

@@ -42,12 +42,12 @@ bool ICUDateFunc::BindData::Equals(const FunctionData &other_p) const {
 }
 
 unique_ptr<FunctionData> ICUDateFunc::BindData::Copy() const {
-	return make_unique<BindData>(*this);
+	return make_uniq<BindData>(*this);
 }
 
 unique_ptr<FunctionData> ICUDateFunc::Bind(ClientContext &context, ScalarFunction &bound_function,
-                                           vector<unique_ptr<Expression>> &arguments) {
-	return make_unique<BindData>(context);
+                                           vector<duckdb::unique_ptr<Expression>> &arguments) {
+	return make_uniq<BindData>(context);
 }
 
 void ICUDateFunc::SetTimeZone(icu::Calendar *calendar, const string_t &tz_id) {
@@ -65,24 +65,36 @@ timestamp_t ICUDateFunc::GetTimeUnsafe(icu::Calendar *calendar, uint64_t micros)
 	return timestamp_t(millis * Interval::MICROS_PER_MSEC + micros);
 }
 
-timestamp_t ICUDateFunc::GetTime(icu::Calendar *calendar, uint64_t micros) {
+bool ICUDateFunc::TryGetTime(icu::Calendar *calendar, uint64_t micros, timestamp_t &result) {
 	// Extract the new time
 	UErrorCode status = U_ZERO_ERROR;
 	auto millis = int64_t(calendar->getTime(status));
 	if (U_FAILURE(status)) {
-		throw Exception("Unable to get ICU calendar time.");
+		return false;
 	}
 
 	// UDate is a double, so it can't overflow (it just loses accuracy), but converting back to µs can.
-	millis = MultiplyOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(millis, Interval::MICROS_PER_MSEC);
-	millis = AddOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(millis, micros);
+	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(millis, Interval::MICROS_PER_MSEC, millis)) {
+		return false;
+	}
+	if (!TryAddOperator::Operation<int64_t, int64_t, int64_t>(millis, micros, millis)) {
+		return false;
+	}
 
 	// Now make sure the value is in range
-	date_t d;
-	dtime_t t;
-	Timestamp::Convert(timestamp_t(millis), d, t);
+	result = timestamp_t(millis);
+	date_t out_date = Timestamp::GetDate(result);
+	int64_t days_micros;
+	return TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(out_date.days, Interval::MICROS_PER_DAY,
+	                                                                 days_micros);
+}
 
-	return timestamp_t(millis);
+timestamp_t ICUDateFunc::GetTime(icu::Calendar *calendar, uint64_t micros) {
+	timestamp_t result;
+	if (!TryGetTime(calendar, micros, result)) {
+		throw ConversionException("Unable to convert ICU date to timestamp");
+	}
+	return result;
 }
 
 uint64_t ICUDateFunc::SetTime(icu::Calendar *calendar, timestamp_t date) {

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

@@ -223,8 +223,8 @@ struct ICUDatePart : public ICUDateFunc {
 			return BindData::Equals(other_p) && adapters == other.adapters;
 		}
 
-		unique_ptr<FunctionData> Copy() const override {
-			return make_unique<BindAdapterData>(*this);
+		duckdb::unique_ptr<FunctionData> Copy() const override {
+			return make_uniq<BindAdapterData>(*this);
 		}
 	};
 
@@ -234,7 +234,7 @@ struct ICUDatePart : public ICUDateFunc {
 		D_ASSERT(args.ColumnCount() == 1);
 		auto &date_arg = args.data[0];
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BIND_TYPE &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
@@ -258,7 +258,7 @@ struct ICUDatePart : public ICUDateFunc {
 		auto &part_arg = args.data[0];
 		auto &date_arg = args.data[1];
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BIND_TYPE &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
@@ -280,7 +280,7 @@ struct ICUDatePart : public ICUDateFunc {
 	template <typename INPUT_TYPE>
 	static void StructFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 		using BIND_TYPE = BindAdapterData<int64_t>;
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BIND_TYPE &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
@@ -356,22 +356,22 @@ struct ICUDatePart : public ICUDateFunc {
 	}
 
 	template <typename BIND_TYPE>
-	static unique_ptr<FunctionData> BindAdapter(ClientContext &context, ScalarFunction &bound_function,
-	                                            vector<unique_ptr<Expression>> &arguments,
-	                                            typename BIND_TYPE::adapter_t adapter) {
-		return make_unique<BIND_TYPE>(context, adapter);
+	static duckdb::unique_ptr<FunctionData> BindAdapter(ClientContext &context, ScalarFunction &bound_function,
+	                                                    vector<duckdb::unique_ptr<Expression>> &arguments,
+	                                                    typename BIND_TYPE::adapter_t adapter) {
+		return make_uniq<BIND_TYPE>(context, adapter);
 	}
 
-	static unique_ptr<FunctionData> BindDatePart(ClientContext &context, ScalarFunction &bound_function,
-	                                             vector<unique_ptr<Expression>> &arguments) {
+	static duckdb::unique_ptr<FunctionData> BindDatePart(ClientContext &context, ScalarFunction &bound_function,
+	                                                     vector<duckdb::unique_ptr<Expression>> &arguments) {
 		using data_t = BindAdapterData<int64_t>;
 		auto adapter =
 		    (arguments.size() == 1) ? PartCodeAdapterFactory(GetDatePartSpecifier(bound_function.name)) : nullptr;
 		return BindAdapter<data_t>(context, bound_function, arguments, adapter);
 	}
 
-	static unique_ptr<FunctionData> BindStruct(ClientContext &context, ScalarFunction &bound_function,
-	                                           vector<unique_ptr<Expression>> &arguments) {
+	static duckdb::unique_ptr<FunctionData> BindStruct(ClientContext &context, ScalarFunction &bound_function,
+	                                                   vector<duckdb::unique_ptr<Expression>> &arguments) {
 		using data_t = BindAdapterData<int64_t>;
 		using adapters_t = data_t::adapters_t;
 
@@ -412,7 +412,7 @@ struct ICUDatePart : public ICUDateFunc {
 
 		Function::EraseArgument(bound_function, arguments, 0);
 		bound_function.return_type = LogicalType::STRUCT(std::move(struct_children));
-		return make_unique<data_t>(context, adapters);
+		return make_uniq<data_t>(context, adapters);
 	}
 
 	static void SerializeFunction(FieldWriter &writer, const FunctionData *bind_data_p,
@@ -420,8 +420,8 @@ struct ICUDatePart : public ICUDateFunc {
 		throw NotImplementedException("FIXME: serialize icu-datepart");
 	}
 
-	static unique_ptr<FunctionData> DeserializeFunction(ClientContext &context, FieldReader &reader,
-	                                                    ScalarFunction &bound_function) {
+	static duckdb::unique_ptr<FunctionData> DeserializeFunction(ClientContext &context, FieldReader &reader,
+	                                                            ScalarFunction &bound_function) {
 		throw NotImplementedException("FIXME: serialize icu-datepart");
 	}
 
@@ -464,8 +464,8 @@ struct ICUDatePart : public ICUDateFunc {
 		catalog.AddFunction(context, &func_info);
 	}
 
-	static unique_ptr<FunctionData> BindLastDate(ClientContext &context, ScalarFunction &bound_function,
-	                                             vector<unique_ptr<Expression>> &arguments) {
+	static duckdb::unique_ptr<FunctionData> BindLastDate(ClientContext &context, ScalarFunction &bound_function,
+	                                                     vector<duckdb::unique_ptr<Expression>> &arguments) {
 		using data_t = BindAdapterData<date_t>;
 		return BindAdapter<data_t>(context, bound_function, arguments, MakeLastDay);
 	}

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

@@ -95,7 +95,7 @@ struct ICUCalendarSub : public ICUDateFunc {
 		auto &startdate_arg = args.data[1];
 		auto &enddate_arg = args.data[2];
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar(info.calendar->clone());
 
@@ -217,7 +217,7 @@ struct ICUCalendarDiff : public ICUDateFunc {
 		auto &startdate_arg = args.data[1];
 		auto &enddate_arg = args.data[2];
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();

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

@@ -98,7 +98,7 @@ struct ICUDateTrunc : public ICUDateFunc {
 		auto &part_arg = args.data[0];
 		auto &date_arg = args.data[1];
 
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = (BindData &)*func_expr.bind_info;
 		CalendarPtr calendar(info.calendar->clone());