duckdb 0.4.1-dev89.0 → 0.4.1-dev93.0

package/package.json

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

package/src/duckdb.cpp

@@ -43597,6 +43597,7 @@ int64_t Timestamp::GetEpochNanoSeconds(timestamp_t timestamp) {
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
 bool UUID::FromString(string str, hugeint_t &result) {
@@ -43681,6 +43682,45 @@ void UUID::ToString(hugeint_t input, char *buf) {
 	byte_to_hex(input.lower & 0xFF, buf, pos);
 }
 
+hugeint_t UUID::GenerateRandomUUID(RandomEngine &engine) {
+	uint8_t bytes[16];
+	for (int i = 0; i < 16; i += 4) {
+		*reinterpret_cast<uint32_t *>(bytes + i) = engine.NextRandomInteger();
+	}
+	// variant must be 10xxxxxx
+	bytes[8] &= 0xBF;
+	bytes[8] |= 0x80;
+	// version must be 0100xxxx
+	bytes[6] &= 0x4F;
+	bytes[6] |= 0x40;
+
+	hugeint_t result;
+	result.upper = 0;
+	result.upper |= ((int64_t)bytes[0] << 56);
+	result.upper |= ((int64_t)bytes[1] << 48);
+	result.upper |= ((int64_t)bytes[3] << 40);
+	result.upper |= ((int64_t)bytes[4] << 32);
+	result.upper |= ((int64_t)bytes[5] << 24);
+	result.upper |= ((int64_t)bytes[6] << 16);
+	result.upper |= ((int64_t)bytes[7] << 8);
+	result.upper |= bytes[8];
+	result.lower = 0;
+	result.lower |= ((uint64_t)bytes[8] << 56);
+	result.lower |= ((uint64_t)bytes[9] << 48);
+	result.lower |= ((uint64_t)bytes[10] << 40);
+	result.lower |= ((uint64_t)bytes[11] << 32);
+	result.lower |= ((uint64_t)bytes[12] << 24);
+	result.lower |= ((uint64_t)bytes[13] << 16);
+	result.lower |= ((uint64_t)bytes[14] << 8);
+	result.lower |= bytes[15];
+	return result;
+}
+
+hugeint_t UUID::GenerateRandomUUID() {
+	RandomEngine engine;
+	return GenerateRandomUUID(engine);
+}
+
 } // namespace duckdb
 
 
@@ -69630,6 +69670,22 @@ void BufferedCSVReaderOptions::SetDelimiter(const string &input) {
 	}
 }
 
+void BufferedCSVReaderOptions::SetDateFormat(LogicalTypeId type, const string &format, bool read_format) {
+	string error;
+	if (read_format) {
+		auto &date_format = this->date_format[type];
+		error = StrTimeFormat::ParseFormatSpecifier(format, date_format);
+		date_format.format_specifier = format;
+	} else {
+		auto &date_format = this->write_date_format[type];
+		error = StrTimeFormat::ParseFormatSpecifier(format, date_format);
+	}
+	if (!error.empty()) {
+		throw InvalidInputException("Could not parse DATEFORMAT: %s", error.c_str());
+	}
+	has_format[type] = true;
+}
+
 void BufferedCSVReaderOptions::SetReadOption(const string &loption, const Value &value,
                                              vector<string> &expected_names) {
 	if (SetBaseOption(loption, value)) {
@@ -69674,22 +69730,10 @@ void BufferedCSVReaderOptions::SetReadOption(const string &loption, const Value
 		force_not_null = ParseColumnList(value, expected_names, loption);
 	} else if (loption == "date_format" || loption == "dateformat") {
 		string format = ParseString(value, loption);
-		auto &date_format = this->date_format[LogicalTypeId::DATE];
-		string error = StrTimeFormat::ParseFormatSpecifier(format, date_format);
-		date_format.format_specifier = format;
-		if (!error.empty()) {
-			throw InvalidInputException("Could not parse DATEFORMAT: %s", error.c_str());
-		}
-		has_format[LogicalTypeId::DATE] = true;
+		SetDateFormat(LogicalTypeId::DATE, format, true);
 	} else if (loption == "timestamp_format" || loption == "timestampformat") {
 		string format = ParseString(value, loption);
-		auto &timestamp_format = date_format[LogicalTypeId::TIMESTAMP];
-		string error = StrTimeFormat::ParseFormatSpecifier(format, timestamp_format);
-		timestamp_format.format_specifier = format;
-		if (!error.empty()) {
-			throw InvalidInputException("Could not parse TIMESTAMPFORMAT: %s", error.c_str());
-		}
-		has_format[LogicalTypeId::TIMESTAMP] = true;
+		SetDateFormat(LogicalTypeId::TIMESTAMP, format, true);
 	} else if (loption == "escape") {
 		escape = ParseString(value, loption);
 		has_escape = true;
@@ -69707,6 +69751,15 @@ void BufferedCSVReaderOptions::SetWriteOption(const string &loption, const Value
 
 	if (loption == "force_quote") {
 		force_quote = ParseColumnList(value, names, loption);
+	} else if (loption == "date_format" || loption == "dateformat") {
+		string format = ParseString(value, loption);
+		SetDateFormat(LogicalTypeId::DATE, format, false);
+	} else if (loption == "timestamp_format" || loption == "timestampformat") {
+		string format = ParseString(value, loption);
+		if (StringUtil::Lower(format) == "iso") {
+			format = "%Y-%m-%dT%H:%M:%S.%fZ";
+		}
+		SetDateFormat(LogicalTypeId::TIMESTAMP, format, false);
 	} else {
 		throw BinderException("Unrecognized option CSV writer \"%s\"", loption);
 	}
@@ -93245,6 +93298,25 @@ static unique_ptr<FunctionData> StrfTimeBindFunction(ClientContext &context, Sca
 	return make_unique<StrfTimeBindData>(format, format_string);
 }
 
+void StrfTimeFormat::ConvertDateVector(Vector &input, Vector &result, idx_t count) {
+	D_ASSERT(input.GetType().id() == LogicalTypeId::DATE);
+	D_ASSERT(result.GetType().id() == LogicalTypeId::VARCHAR);
+	UnaryExecutor::ExecuteWithNulls<date_t, string_t>(input, result, count,
+	                                                  [&](date_t input, ValidityMask &mask, idx_t idx) {
+		                                                  if (Date::IsFinite(input)) {
+			                                                  dtime_t time(0);
+			                                                  idx_t len = GetLength(input, time, 0, nullptr);
+			                                                  string_t target = StringVector::EmptyString(result, len);
+			                                                  FormatString(input, time, target.GetDataWriteable());
+			                                                  target.Finalize();
+			                                                  return target;
+		                                                  } else {
+			                                                  mask.SetInvalid(idx);
+			                                                  return string_t();
+		                                                  }
+	                                                  });
+}
+
 template <bool REVERSED>
 static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = (BoundFunctionExpression &)state.expr;
@@ -93255,13 +93327,21 @@ static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector
 		ConstantVector::SetNull(result, true);
 		return;
 	}
-	UnaryExecutor::ExecuteWithNulls<date_t, string_t>(
-	    args.data[REVERSED ? 1 : 0], result, args.size(), [&](date_t input, ValidityMask &mask, idx_t idx) {
-		    if (Date::IsFinite(input)) {
-			    dtime_t time(0);
-			    idx_t len = info.format.GetLength(input, time, 0, nullptr);
+	info.format.ConvertDateVector(args.data[REVERSED ? 1 : 0], result, args.size());
+}
+
+void StrfTimeFormat::ConvertTimestampVector(Vector &input, Vector &result, idx_t count) {
+	D_ASSERT(input.GetType().id() == LogicalTypeId::TIMESTAMP);
+	D_ASSERT(result.GetType().id() == LogicalTypeId::VARCHAR);
+	UnaryExecutor::ExecuteWithNulls<timestamp_t, string_t>(
+	    input, result, count, [&](timestamp_t input, ValidityMask &mask, idx_t idx) {
+		    if (Timestamp::IsFinite(input)) {
+			    date_t date;
+			    dtime_t time;
+			    Timestamp::Convert(input, date, time);
+			    idx_t len = GetLength(date, time, 0, nullptr);
 			    string_t target = StringVector::EmptyString(result, len);
-			    info.format.FormatString(input, time, target.GetDataWriteable());
+			    FormatString(date, time, target.GetDataWriteable());
 			    target.Finalize();
 			    return target;
 		    } else {
@@ -93281,23 +93361,7 @@ static void StrfTimeFunctionTimestamp(DataChunk &args, ExpressionState &state, V
 		ConstantVector::SetNull(result, true);
 		return;
 	}
-
-	UnaryExecutor::ExecuteWithNulls<timestamp_t, string_t>(
-	    args.data[REVERSED ? 1 : 0], result, args.size(), [&](timestamp_t input, ValidityMask &mask, idx_t idx) {
-		    if (Timestamp::IsFinite(input)) {
-			    date_t date;
-			    dtime_t time;
-			    Timestamp::Convert(input, date, time);
-			    idx_t len = info.format.GetLength(date, time, 0, nullptr);
-			    string_t target = StringVector::EmptyString(result, len);
-			    info.format.FormatString(date, time, target.GetDataWriteable());
-			    target.Finalize();
-			    return target;
-		    } else {
-			    mask.SetInvalid(idx);
-			    return string_t();
-		    }
-	    });
+	info.format.ConvertTimestampVector(args.data[REVERSED ? 1 : 0], result, args.size());
 }
 
 void StrfTimeFun::RegisterFunction(BuiltinFunctions &set) {
@@ -98591,35 +98655,7 @@ static void GenerateUUIDFunction(DataChunk &args, ExpressionState &state, Vector
 	auto result_data = FlatVector::GetData<hugeint_t>(result);
 
 	for (idx_t i = 0; i < args.size(); i++) {
-		uint8_t bytes[16];
-		for (int i = 0; i < 16; i += 4) {
-			*reinterpret_cast<uint32_t *>(bytes + i) = lstate.random_engine.NextRandomInteger();
-		}
-		// variant must be 10xxxxxx
-		bytes[8] &= 0xBF;
-		bytes[8] |= 0x80;
-		// version must be 0100xxxx
-		bytes[6] &= 0x4F;
-		bytes[6] |= 0x40;
-
-		result_data[i].upper = 0;
-		result_data[i].upper |= ((int64_t)bytes[0] << 56);
-		result_data[i].upper |= ((int64_t)bytes[1] << 48);
-		result_data[i].upper |= ((int64_t)bytes[3] << 40);
-		result_data[i].upper |= ((int64_t)bytes[4] << 32);
-		result_data[i].upper |= ((int64_t)bytes[5] << 24);
-		result_data[i].upper |= ((int64_t)bytes[6] << 16);
-		result_data[i].upper |= ((int64_t)bytes[7] << 8);
-		result_data[i].upper |= bytes[8];
-		result_data[i].lower = 0;
-		result_data[i].lower |= ((uint64_t)bytes[8] << 56);
-		result_data[i].lower |= ((uint64_t)bytes[9] << 48);
-		result_data[i].lower |= ((uint64_t)bytes[10] << 40);
-		result_data[i].lower |= ((uint64_t)bytes[11] << 32);
-		result_data[i].lower |= ((uint64_t)bytes[12] << 24);
-		result_data[i].lower |= ((uint64_t)bytes[13] << 16);
-		result_data[i].lower |= ((uint64_t)bytes[14] << 8);
-		result_data[i].lower |= bytes[15];
+		result_data[i] = UUID::GenerateRandomUUID(lstate.random_engine);
 	}
 }
 
@@ -106893,6 +106929,15 @@ static void WriteCSVSink(ClientContext &context, FunctionData &bind_data, Global
 		if (csv_data.sql_types[col_idx].id() == LogicalTypeId::VARCHAR) {
 			// VARCHAR, just create a reference
 			cast_chunk.data[col_idx].Reference(input.data[col_idx]);
+		} else if (options.has_format[LogicalTypeId::DATE] && csv_data.sql_types[col_idx].id() == LogicalTypeId::DATE) {
+			// use the date format to cast the chunk
+			csv_data.options.write_date_format[LogicalTypeId::DATE].ConvertDateVector(
+			    input.data[col_idx], cast_chunk.data[col_idx], input.size());
+		} else if (options.has_format[LogicalTypeId::TIMESTAMP] &&
+		           csv_data.sql_types[col_idx].id() == LogicalTypeId::TIMESTAMP) {
+			// use the timestamp format to cast the chunk
+			csv_data.options.write_date_format[LogicalTypeId::TIMESTAMP].ConvertTimestampVector(
+			    input.data[col_idx], cast_chunk.data[col_idx], input.size());
 		} else {
 			// non varchar column, perform the cast
 			VectorOperations::Cast(input.data[col_idx], cast_chunk.data[col_idx], input.size());
@@ -118308,6 +118353,7 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 
 
 
+
 #ifndef DISABLE_DUCKDB_REMOTE_INSTALL
 
 
@@ -126551,7 +126597,8 @@ void ExtensionHelper::InstallExtension(DatabaseInstance &db, const string &exten
 		return;
 	}
 
-	string temp_path = local_extension_path + ".tmp";
+	auto uuid = UUID::ToString(UUID::GenerateRandomUUID());
+	string temp_path = local_extension_path + ".tmp-" + uuid;
 	if (fs.FileExists(temp_path)) {
 		fs.RemoveFile(temp_path);
 	}

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 "7e97a4a15"
-#define DUCKDB_VERSION "v0.4.1-dev89"
+#define DUCKDB_SOURCE_ID "b8df3c77b"
+#define DUCKDB_VERSION "v0.4.1-dev93"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -19093,6 +19093,8 @@ public:
 
 
 namespace duckdb {
+class ClientContext;
+struct RandomEngine;
 
 //! The UUID class contains static operations for the UUID type
 class UUID {
@@ -19107,6 +19109,10 @@ public:
 	//! Convert a hugeint object to a uuid style string
 	static void ToString(hugeint_t input, char *buf);
 
+	//! Convert a hugeint object to a uuid style string
+	static hugeint_t GenerateRandomUUID(RandomEngine &engine);
+	static hugeint_t GenerateRandomUUID();
+
 	//! Convert a hugeint object to a uuid style string
 	static string ToString(hugeint_t input) {
 		char buff[STRING_SIZE];
@@ -22488,6 +22494,9 @@ struct StrfTimeFormat : public StrTimeFormat {
 
 	DUCKDB_API static string Format(timestamp_t timestamp, const string &format);
 
+	DUCKDB_API void ConvertDateVector(Vector &input, Vector &result, idx_t count);
+	DUCKDB_API void ConvertTimestampVector(Vector &input, Vector &result, idx_t count);
+
 protected:
 	//! The variable-length specifiers. To determine total string size, these need to be checked.
 	vector<StrTimeSpecifier> var_length_specifiers;
@@ -22675,6 +22684,9 @@ struct BufferedCSVReaderOptions {
 
 	//! The date format to use (if any is specified)
 	std::map<LogicalTypeId, StrpTimeFormat> date_format = {{LogicalTypeId::DATE, {}}, {LogicalTypeId::TIMESTAMP, {}}};
+	//! The date format to use for writing (if any is specified)
+	std::map<LogicalTypeId, StrfTimeFormat> write_date_format = {{LogicalTypeId::DATE, {}},
+	                                                             {LogicalTypeId::TIMESTAMP, {}}};
 	//! Whether or not a type format is specified
 	std::map<LogicalTypeId, bool> has_format = {{LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}};
 
@@ -22689,6 +22701,7 @@ struct BufferedCSVReaderOptions {
 	void SetReadOption(const string &loption, const Value &value, vector<string> &expected_names);
 
 	void SetWriteOption(const string &loption, const Value &value);
+	void SetDateFormat(LogicalTypeId type, const string &format, bool read_format);
 
 	std::string ToString() const;
 };