duckdb 0.3.3-dev392.0 → 0.3.3-dev449.0

package/package.json

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

package/src/duckdb.cpp

@@ -13658,6 +13658,10 @@ bool FileSystem::FileExists(const string &filename) {
 	throw NotImplementedException("%s: FileExists is not implemented!", GetName());
 }
 
+bool FileSystem::IsPipe(const string &filename) {
+	throw NotImplementedException("%s: IsPipe is not implemented!", GetName());
+}
+
 void FileSystem::RemoveFile(const string &filename) {
 	throw NotImplementedException("%s: RemoveFile is not implemented!", GetName());
 }
@@ -15773,6 +15777,9 @@ public:
 	void MoveFile(const string &source, const string &target) override;
 	//! Check if a file exists
 	bool FileExists(const string &filename) override;
+
+	//! Check if path is a pipe
+	bool IsPipe(const string &filename) override;
 	//! Remove a file from disk
 	void RemoveFile(const string &filename) override;
 	//! Sync a file handle to disk
@@ -15865,8 +15872,10 @@ public:
 } // namespace duckdb
 
 #include <string>
+#include <io.h>
 
 #ifdef __MINGW32__
+#include <sys/stat.h>
 // need to manually define this for mingw
 extern "C" WINBASEAPI BOOL WINAPI GetPhysicallyInstalledSystemMemory(PULONGLONG);
 #endif
@@ -15891,6 +15900,90 @@ static void AssertValidFileFlags(uint8_t flags) {
 #endif
 }
 
+#ifdef __MINGW32__
+bool LocalFileSystem::FileExists(const string &filename) {
+	auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str());
+	const wchar_t *wpath = unicode_path.c_str();
+	if (_waccess(wpath, 0) == 0) {
+		struct _stat64i32 status;
+		_wstat(wpath, &status);
+		if (status.st_size > 0) {
+			return true;
+		}
+	}
+	return false;
+}
+bool LocalFileSystem::IsPipe(const string &filename) {
+	auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str());
+	const wchar_t *wpath = unicode_path.c_str();
+	if (_waccess(wpath, 0) == 0) {
+		struct _stat64i32 status;
+		_wstat(wpath, &status);
+		if (status.st_size == 0) {
+			return true;
+		}
+	}
+	return false;
+}
+
+#else
+#ifndef _WIN32
+bool LocalFileSystem::FileExists(const string &filename) {
+	if (!filename.empty()) {
+		if (access(filename.c_str(), 0) == 0) {
+			struct stat status;
+			stat(filename.c_str(), &status);
+			if (S_ISREG(status.st_mode)) {
+				return true;
+			}
+		}
+	}
+	// if any condition fails
+	return false;
+}
+
+bool LocalFileSystem::IsPipe(const string &filename) {
+	if (!filename.empty()) {
+		if (access(filename.c_str(), 0) == 0) {
+			struct stat status;
+			stat(filename.c_str(), &status);
+			if (S_ISFIFO(status.st_mode)) {
+				return true;
+			}
+		}
+	}
+	// if any condition fails
+	return false;
+}
+
+#else
+bool LocalFileSystem::FileExists(const string &filename) {
+	auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str());
+	const wchar_t *wpath = unicode_path.c_str();
+	if (_waccess(wpath, 0) == 0) {
+		struct _stat64i32 status;
+		_wstat(wpath, &status);
+		if (status.st_mode & S_IFREG) {
+			return true;
+		}
+	}
+	return false;
+}
+bool LocalFileSystem::IsPipe(const string &filename) {
+	auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str());
+	const wchar_t *wpath = unicode_path.c_str();
+	if (_waccess(wpath, 0) == 0) {
+		struct _stat64i32 status;
+		_wstat(wpath, &status);
+		if (status.st_mode & _S_IFCHR) {
+			return true;
+		}
+	}
+	return false;
+}
+#endif
+#endif
+
 #ifndef _WIN32
 // somehow sometimes this is missing
 #ifndef O_CLOEXEC
@@ -16127,20 +16220,6 @@ bool LocalFileSystem::DirectoryExists(const string &directory) {
 	return false;
 }
 
-bool LocalFileSystem::FileExists(const string &filename) {
-	if (!filename.empty()) {
-		if (access(filename.c_str(), 0) == 0) {
-			struct stat status;
-			stat(filename.c_str(), &status);
-			if (!(status.st_mode & S_IFDIR)) {
-				return true;
-			}
-		}
-	}
-	// if any condition fails
-	return false;
-}
-
 void LocalFileSystem::CreateDirectory(const string &directory) {
 	struct stat st;
 
@@ -16479,11 +16558,6 @@ bool LocalFileSystem::DirectoryExists(const string &directory) {
 	return (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY));
 }
 
-bool LocalFileSystem::FileExists(const string &filename) {
-	DWORD attrs = WindowsGetFileAttributes(filename);
-	return (attrs != INVALID_FILE_ATTRIBUTES && !(attrs & FILE_ATTRIBUTE_DIRECTORY));
-}
-
 void LocalFileSystem::CreateDirectory(const string &directory) {
 	if (DirectoryExists(directory)) {
 		return;
@@ -16642,9 +16716,9 @@ vector<string> LocalFileSystem::Glob(const string &path) {
 	}
 	// first check if the path has a glob at all
 	if (!HasGlob(path)) {
-		// no glob: return only the file (if it exists)
+		// no glob: return only the file (if it exists or is a pipe)
 		vector<string> result;
-		if (FileExists(path)) {
+		if (FileExists(path) || IsPipe(path)) {
 			result.push_back(path);
 		}
 		return result;
@@ -45465,6 +45539,9 @@ public:
 		return FindFileSystem(filename)->FileExists(filename);
 	}
 
+	bool IsPipe(const string &filename) override {
+		return FindFileSystem(filename)->IsPipe(filename);
+	}
 	virtual void RemoveFile(const string &filename) override {
 		FindFileSystem(filename)->RemoveFile(filename);
 	}
@@ -61229,6 +61306,8 @@ public:
 
 	CopyFunction function;
 	unique_ptr<FunctionData> bind_data;
+	string file_path;
+	bool use_tmp_file;
 
 public:
 	// Source interface
@@ -61254,6 +61333,7 @@ public:
 
 
 
+
 #include <algorithm>
 
 namespace duckdb {
@@ -61278,6 +61358,15 @@ public:
 //===--------------------------------------------------------------------===//
 // Sink
 //===--------------------------------------------------------------------===//
+void MoveTmpFile(ClientContext &context, const string &tmp_file_path) {
+	auto &fs = FileSystem::GetFileSystem(context);
+	auto file_path = tmp_file_path.substr(0, tmp_file_path.length() - 4);
+	if (fs.FileExists(file_path)) {
+		fs.RemoveFile(file_path);
+	}
+	fs.MoveFile(tmp_file_path, file_path);
+}
+
 PhysicalCopyToFile::PhysicalCopyToFile(vector<LogicalType> types, CopyFunction function_p,
                                        unique_ptr<FunctionData> bind_data, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::COPY_TO_FILE, move(types), estimated_cardinality),
@@ -61308,6 +61397,10 @@ SinkFinalizeType PhysicalCopyToFile::Finalize(Pipeline &pipeline, Event &event,
 	auto &gstate = (CopyToFunctionGlobalState &)gstate_p;
 	if (function.copy_to_finalize) {
 		function.copy_to_finalize(context, *bind_data, *gstate.global_state);
+
+		if (use_tmp_file) {
+			MoveTmpFile(context, file_path);
+		}
 	}
 	return SinkFinalizeType::READY;
 }
@@ -61316,7 +61409,7 @@ unique_ptr<LocalSinkState> PhysicalCopyToFile::GetLocalSinkState(ExecutionContex
 	return make_unique<CopyToFunctionLocalState>(function.copy_to_initialize_local(context.client, *bind_data));
 }
 unique_ptr<GlobalSinkState> PhysicalCopyToFile::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<CopyToFunctionGlobalState>(function.copy_to_initialize_global(context, *bind_data));
+	return make_unique<CopyToFunctionGlobalState>(function.copy_to_initialize_global(context, *bind_data, file_path));
 }
 
 //===--------------------------------------------------------------------===//
@@ -65351,6 +65444,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparison
 
 
 
+
 namespace duckdb {
 
 class LogicalCopyToFile : public LogicalOperator {
@@ -65360,6 +65454,9 @@ public:
 	}
 	CopyFunction function;
 	unique_ptr<FunctionData> bind_data;
+	std::string file_path;
+	bool use_tmp_file;
+	bool is_file_and_exists;
 
 protected:
 	void ResolveTypes() override {
@@ -65373,8 +65470,14 @@ namespace duckdb {
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCopyToFile &op) {
 	auto plan = CreatePlan(*op.children[0]);
+	bool use_tmp_file = op.is_file_and_exists && op.use_tmp_file;
+	if (use_tmp_file) {
+		op.file_path += ".tmp";
+	}
 	// COPY from select statement to file
 	auto copy = make_unique<PhysicalCopyToFile>(op.types, op.function, move(op.bind_data), op.estimated_cardinality);
+	copy->file_path = op.file_path;
+	copy->use_tmp_file = use_tmp_file;
 
 	copy->children.push_back(move(plan));
 	return move(copy);
@@ -69212,6 +69315,10 @@ struct VarianceFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct StandardErrorOfTheMeanFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
@@ -69806,6 +69913,20 @@ struct STDDevPopOperation : public STDDevBaseOperation {
 		}
 	}
 };
+
+struct StandardErrorOfTheMeanOperation : public STDDevBaseOperation {
+	template <class T, class STATE>
+	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
+		if (state->count == 0) {
+			mask.SetInvalid(idx);
+		} else {
+			target[idx] = sqrt(state->dsquared / state->count) / sqrt((state->count));
+			if (!Value::DoubleIsValid(target[idx])) {
+				throw OutOfRangeException("SEM is out of range!");
+			}
+		}
+	}
+};
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
@@ -69967,6 +70088,13 @@ void VarianceFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(var_samp);
 }
 
+void StandardErrorOfTheMeanFun::RegisterFunction(BuiltinFunctions &set) {
+	AggregateFunctionSet sem("sem");
+	sem.AddFunction(AggregateFunction::UnaryAggregate<StddevState, double, double, StandardErrorOfTheMeanOperation>(
+	    LogicalType::DOUBLE, LogicalType::DOUBLE));
+	set.AddFunction(sem);
+}
+
 } // namespace duckdb
 
 
@@ -69984,7 +70112,7 @@ void BuiltinFunctions::RegisterAlgebraicAggregates() {
 	Register<VarPopFun>();
 	Register<VarSampFun>();
 	Register<VarianceFun>();
-
+	Register<StandardErrorOfTheMeanFun>();
 	Register<Corr>();
 }
 
@@ -95093,10 +95221,11 @@ static unique_ptr<LocalFunctionData> WriteCSVInitializeLocal(ClientContext &cont
 	return move(local_data);
 }
 
-static unique_ptr<GlobalFunctionData> WriteCSVInitializeGlobal(ClientContext &context, FunctionData &bind_data) {
+static unique_ptr<GlobalFunctionData> WriteCSVInitializeGlobal(ClientContext &context, FunctionData &bind_data,
+                                                               const string &file_path) {
 	auto &csv_data = (WriteCSVData &)bind_data;
 	auto &options = csv_data.options;
-	auto global_data = make_unique<GlobalWriteCSVData>(FileSystem::GetFileSystem(context), csv_data.files[0],
+	auto global_data = make_unique<GlobalWriteCSVData>(FileSystem::GetFileSystem(context), file_path,
 	                                                   FileSystem::GetFileOpener(context), options.compression);
 
 	if (options.header) {
@@ -95190,6 +95319,7 @@ static void WriteCSVCombine(ClientContext &context, FunctionData &bind_data, Glo
 //===--------------------------------------------------------------------===//
 void WriteCSVFinalize(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate) {
 	auto &global_state = (GlobalWriteCSVData &)gstate;
+
 	global_state.handle->Close();
 	global_state.handle.reset();
 }
@@ -100231,6 +100361,7 @@ void BaseAppender::Close() {
 
 
 
+
 #include <cstring>
 #include <cassert>
 
@@ -100265,6 +100396,10 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &type);
 idx_t GetCTypeSize(duckdb_type type);
 duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_result *out);
 
+struct DuckDBColumnData {
+	LogicalType type;
+};
+
 } // namespace duckdb
 
 
@@ -100810,6 +100945,8 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
 		return DUCKDB_TYPE_BLOB;
 	case LogicalTypeId::INTERVAL:
 		return DUCKDB_TYPE_INTERVAL;
+	case LogicalTypeId::DECIMAL:
+		return DUCKDB_TYPE_DECIMAL;
 	default: // LCOV_EXCL_START
 		D_ASSERT(0);
 		return DUCKDB_TYPE_INVALID;
@@ -100853,6 +100990,8 @@ idx_t GetCTypeSize(duckdb_type type) {
 		return sizeof(duckdb_blob);
 	case DUCKDB_TYPE_INTERVAL:
 		return sizeof(duckdb_interval);
+	case DUCKDB_TYPE_DECIMAL:
+		return sizeof(duckdb_hugeint);
 	default: // LCOV_EXCL_START
 		// unsupported type
 		D_ASSERT(0);
@@ -100872,6 +101011,8 @@ void duckdb_free(void *ptr) {
 
 
 
+
+
 using duckdb::Hugeint;
 using duckdb::hugeint_t;
 using duckdb::Value;
@@ -100896,6 +101037,15 @@ duckdb_hugeint duckdb_double_to_hugeint(double val) {
 	return result;
 }
 
+double duckdb_decimal_to_double(duckdb_decimal val) {
+	double result;
+	hugeint_t value;
+	value.lower = val.value.lower;
+	value.upper = val.value.upper;
+	duckdb::TryCastFromDecimal::Operation<hugeint_t, double>(value, result, nullptr, val.width, val.scale);
+	return result;
+}
+
 
 
 
@@ -101133,6 +101283,9 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 	// zero initialize the columns (so we can cleanly delete it in case a malloc fails)
 	memset(out->__deprecated_columns, 0, sizeof(duckdb_column) * out->__deprecated_column_count);
 	for (idx_t i = 0; i < out->__deprecated_column_count; i++) {
+		auto column_data = new DuckDBColumnData();
+		column_data->type = result->types[i];
+		out->__deprecated_columns[i].internal_data = column_data;
 		out->__deprecated_columns[i].__deprecated_type = ConvertCPPTypeToC(result->types[i]);
 		out->__deprecated_columns[i].__deprecated_name = strdup(result->names[i].c_str());
 		out->__deprecated_columns[i].__deprecated_nullmask =
@@ -101295,9 +101448,72 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 			}
 			break;
 		}
+		case LogicalTypeId::DECIMAL: {
+			// get data
+			idx_t row = 0;
+			auto target = (hugeint_t *)out->__deprecated_columns[col].__deprecated_data;
+			switch (result->types[col].InternalType()) {
+			case PhysicalType::INT16: {
+				for (auto &chunk : result->collection.Chunks()) {
+					auto source = FlatVector::GetData<int16_t>(chunk->data[col]);
+					for (idx_t k = 0; k < chunk->size(); k++) {
+						if (!FlatVector::IsNull(chunk->data[col], k)) {
+							target[row].lower = source[k];
+							target[row].upper = 0;
+						}
+						row++;
+					}
+				}
+				break;
+			}
+			case PhysicalType::INT32: {
+				for (auto &chunk : result->collection.Chunks()) {
+					auto source = FlatVector::GetData<int32_t>(chunk->data[col]);
+					for (idx_t k = 0; k < chunk->size(); k++) {
+						if (!FlatVector::IsNull(chunk->data[col], k)) {
+							target[row].lower = source[k];
+							target[row].upper = 0;
+						}
+						row++;
+					}
+				}
+				break;
+			}
+			case PhysicalType::INT64: {
+				for (auto &chunk : result->collection.Chunks()) {
+					auto source = FlatVector::GetData<int64_t>(chunk->data[col]);
+					for (idx_t k = 0; k < chunk->size(); k++) {
+						if (!FlatVector::IsNull(chunk->data[col], k)) {
+							target[row].lower = source[k];
+							target[row].upper = 0;
+						}
+						row++;
+					}
+				}
+				break;
+			}
+			case PhysicalType::INT128: {
+				for (auto &chunk : result->collection.Chunks()) {
+					auto source = FlatVector::GetData<hugeint_t>(chunk->data[col]);
+					for (idx_t k = 0; k < chunk->size(); k++) {
+						if (!FlatVector::IsNull(chunk->data[col], k)) {
+							target[row].lower = source[k].lower;
+							target[row].upper = source[k].upper;
+						}
+						row++;
+					}
+				}
+				break;
+			}
+			default:
+				throw std::runtime_error("Unsupported physical type for Decimal" +
+				                         TypeIdToString(result->types[col].InternalType()));
+			}
+			break;
+		}
 		default: // LCOV_EXCL_START
-			// unsupported type for C API
-			D_ASSERT(0);
+			std::string err_msg = "Unsupported type for C API: " + result->types[col].ToString();
+			out->__deprecated_error_message = strdup(err_msg.c_str());
 			return DuckDBError;
 		} // LCOV_EXCL_STOP
 	}
@@ -101333,6 +101549,10 @@ static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
 	if (column.__deprecated_name) {
 		duckdb_free(column.__deprecated_name);
 	}
+	if (column.internal_data) {
+		auto column_data = (duckdb::DuckDBColumnData *)column.internal_data;
+		delete column_data;
+	}
 }
 
 void duckdb_destroy_result(duckdb_result *result) {
@@ -101547,7 +101767,12 @@ using duckdb::UnsafeFetch;
 template <class SOURCE_TYPE, class RESULT_TYPE, class OP>
 RESULT_TYPE TryCastCInternal(duckdb_result *result, idx_t col, idx_t row) {
 	RESULT_TYPE result_value;
-	if (!OP::template Operation<SOURCE_TYPE, RESULT_TYPE>(UnsafeFetch<SOURCE_TYPE>(result, col, row), result_value)) {
+	try {
+		if (!OP::template Operation<SOURCE_TYPE, RESULT_TYPE>(UnsafeFetch<SOURCE_TYPE>(result, col, row),
+		                                                      result_value)) {
+			return FetchDefaultValue::Operation<RESULT_TYPE>();
+		}
+	} catch (...) {
 		return FetchDefaultValue::Operation<RESULT_TYPE>();
 	}
 	return result_value;
@@ -101599,6 +101824,8 @@ static RESULT_TYPE GetInternalCValue(duckdb_result *result, idx_t col, idx_t row
 		return TryCastCInternal<timestamp_t, RESULT_TYPE, OP>(result, col, row);
 	case DUCKDB_TYPE_HUGEINT:
 		return TryCastCInternal<hugeint_t, RESULT_TYPE, OP>(result, col, row);
+	case DUCKDB_TYPE_DECIMAL:
+		return TryCastCInternal<hugeint_t, RESULT_TYPE, OP>(result, col, row);
 	case DUCKDB_TYPE_INTERVAL:
 		return TryCastCInternal<interval_t, RESULT_TYPE, OP>(result, col, row);
 	case DUCKDB_TYPE_VARCHAR:
@@ -101635,6 +101862,18 @@ int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t row) {
 	return GetInternalCValue<int64_t>(result, col, row);
 }
 
+duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row) {
+	duckdb_decimal result_value;
+
+	auto column_data = (duckdb::DuckDBColumnData *)result->__deprecated_columns[col].internal_data;
+	column_data->type.GetDecimalProperties(result_value.width, result_value.scale);
+
+	auto internal_value = GetInternalCValue<hugeint_t>(result, col, row);
+	result_value.value.lower = internal_value.lower;
+	result_value.value.upper = internal_value.upper;
+	return result_value;
+}
+
 duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row) {
 	duckdb_hugeint result_value;
 	auto internal_value = GetInternalCValue<hugeint_t>(result, col, row);
@@ -101728,6 +101967,7 @@ bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row) {
 	return result->__deprecated_columns[col].__deprecated_nullmask[row];
 }
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -150270,6 +150510,8 @@ BoundStatement Binder::Bind(CallStatement &stmt) {
 
 
 
+
+
 #include <algorithm>
 
 namespace duckdb {
@@ -150293,11 +150535,24 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	if (!copy_function->function.copy_to_bind) {
 		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
-
+	bool use_tmp_file = true;
+	for (auto &option : stmt.info->options) {
+		auto loption = StringUtil::Lower(option.first);
+		if (loption == "use_tmp_file") {
+			use_tmp_file = option.second[0].CastAs(LogicalType::BOOLEAN).GetValue<bool>();
+			stmt.info->options.erase(option.first);
+			break;
+		}
+	}
 	auto function_data =
 	    copy_function->function.copy_to_bind(context, *stmt.info, select_node.names, select_node.types);
 	// now create the copy information
 	auto copy = make_unique<LogicalCopyToFile>(copy_function->function, move(function_data));
+	copy->file_path = stmt.info->file_path;
+	copy->use_tmp_file = use_tmp_file;
+	LocalFileSystem fs;
+	copy->is_file_and_exists = fs.FileExists(copy->file_path);
+
 	copy->AddChild(move(select_node.plan));
 
 	result.plan = move(copy);

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "27c81ef25"
-#define DUCKDB_VERSION "v0.3.3-dev392"
+#define DUCKDB_SOURCE_ID "1355f4f7a"
+#define DUCKDB_VERSION "v0.3.3-dev449"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1930,11 +1930,12 @@ public:
 	DUCKDB_API virtual void MoveFile(const string &source, const string &target);
 	//! Check if a file exists
 	DUCKDB_API virtual bool FileExists(const string &filename);
+	//! Check if path is pipe
+	DUCKDB_API virtual bool IsPipe(const string &filename);
 	//! Remove a file from disk
 	DUCKDB_API virtual void RemoveFile(const string &filename);
 	//! Sync a file handle to disk
 	DUCKDB_API virtual void FileSync(FileHandle &handle);
-
 	//! Sets the working directory
 	DUCKDB_API static void SetWorkingDirectory(const string &path);
 	//! Gets the working directory
@@ -12069,7 +12070,9 @@ typedef enum DUCKDB_TYPE {
 	// const char*
 	DUCKDB_TYPE_VARCHAR,
 	// duckdb_blob
-	DUCKDB_TYPE_BLOB
+	DUCKDB_TYPE_BLOB,
+	// decimal
+	DUCKDB_TYPE_DECIMAL
 } duckdb_type;
 
 //! Days are stored as days since 1970-01-01
@@ -12122,6 +12125,13 @@ typedef struct {
 	int64_t upper;
 } duckdb_hugeint;
 
+typedef struct {
+	uint8_t width;
+	uint8_t scale;
+
+	duckdb_hugeint value;
+} duckdb_decimal;
+
 typedef struct {
 	void *data;
 	idx_t size;
@@ -12456,6 +12466,11 @@ DUCKDB_API int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t ro
  */
 DUCKDB_API duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row);
 
+/*!
+ * returns: The duckdb_decimal value at the specified location, or 0 if the value cannot be converted.
+ */
+DUCKDB_API duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row);
+
 /*!
  * returns: The uint8_t value at the specified location, or 0 if the value cannot be converted.
  */
@@ -12622,6 +12637,17 @@ If the conversion fails because the double value is too big the result will be 0
 */
 DUCKDB_API duckdb_hugeint duckdb_double_to_hugeint(double val);
 
+//===--------------------------------------------------------------------===//
+// Decimal Helpers
+//===--------------------------------------------------------------------===//
+/*!
+Converts a duckdb_decimal object (as obtained from a `DUCKDB_TYPE_DECIMAL` column) into a double.
+
+* val: The decimal value.
+* returns: The converted `double` element.
+*/
+DUCKDB_API double duckdb_decimal_to_double(duckdb_decimal val);
+
 //===--------------------------------------------------------------------===//
 // Prepared Statements
 //===--------------------------------------------------------------------===//
@@ -18076,7 +18102,8 @@ struct GlobalFunctionData {
 typedef unique_ptr<FunctionData> (*copy_to_bind_t)(ClientContext &context, CopyInfo &info, vector<string> &names,
                                                    vector<LogicalType> &sql_types);
 typedef unique_ptr<LocalFunctionData> (*copy_to_initialize_local_t)(ClientContext &context, FunctionData &bind_data);
-typedef unique_ptr<GlobalFunctionData> (*copy_to_initialize_global_t)(ClientContext &context, FunctionData &bind_data);
+typedef unique_ptr<GlobalFunctionData> (*copy_to_initialize_global_t)(ClientContext &context, FunctionData &bind_data,
+                                                                      const string &file_path);
 typedef void (*copy_to_sink_t)(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
                                LocalFunctionData &lstate, DataChunk &input);
 typedef void (*copy_to_combine_t)(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,