duckdb 0.5.2-dev660.0 → 0.5.2-dev667.0

package/package.json

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

package/src/duckdb.cpp

@@ -43019,6 +43019,7 @@ void DataChunk::Print() {
 
 
 
+
 #include <cstring>
 #include <cctype>
 #include <algorithm>
@@ -43433,6 +43434,14 @@ int64_t Date::EpochNanoseconds(date_t date) {
 	return ((int64_t)date.days) * (Interval::MICROS_PER_DAY * 1000);
 }
 
+int64_t Date::EpochMicroseconds(date_t date) {
+	int64_t result;
+	if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(date.days, Interval::MICROS_PER_DAY, result)) {
+		throw ConversionException("Could not convert DATE to microseconds");
+	}
+	return result;
+}
+
 int32_t Date::ExtractYear(date_t d, int32_t *last_year) {
 	auto n = d.days;
 	// cached look up: check if year of this date is the same as the last one we looked up
@@ -98904,16 +98913,15 @@ struct DateDiff {
 	struct MicrosecondsOperator {
 		template <class TA, class TB, class TR>
 		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::EpochNanoseconds(enddate) / Interval::NANOS_PER_MICRO -
-			       Date::EpochNanoseconds(startdate) / Interval::NANOS_PER_MICRO;
+			return Date::EpochMicroseconds(enddate) - Date::EpochMicroseconds(startdate);
 		}
 	};
 
 	struct MillisecondsOperator {
 		template <class TA, class TB, class TR>
 		static inline TR Operation(TA startdate, TB enddate) {
-			return Date::EpochNanoseconds(enddate) / Interval::NANOS_PER_MSEC -
-			       Date::EpochNanoseconds(startdate) / Interval::NANOS_PER_MSEC;
+			return Date::EpochMicroseconds(enddate) / Interval::MICROS_PER_MSEC -
+			       Date::EpochMicroseconds(startdate) / Interval::MICROS_PER_MSEC;
 		}
 	};
 
@@ -189777,6 +189785,22 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	return result;
 }
 
+unique_ptr<LogicalOperator> LogicalOperator::Copy(ClientContext &context) const {
+	BufferedSerializer logical_op_serializer;
+	try {
+		this->Serialize(logical_op_serializer);
+	} catch (NotImplementedException &ex) {
+		throw NotImplementedException("Logical Operator Copy requires the logical operator and all of its children to "
+		                              "be serializable: " +
+		                              std::string(ex.what()));
+	}
+	auto data = logical_op_serializer.GetData();
+	auto logical_op_deserializer = BufferedDeserializer(data.data.get(), data.size);
+	PlanDeserializationState state(context);
+	auto op_copy = LogicalOperator::Deserialize(logical_op_deserializer, state);
+	return op_copy;
+}
+
 } // namespace duckdb
 
 

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 "271d03f6c"
-#define DUCKDB_VERSION "v0.5.2-dev660"
+#define DUCKDB_SOURCE_ID "064466a3a"
+#define DUCKDB_VERSION "v0.5.2-dev667"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -10175,6 +10175,8 @@ public:
 
 	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer, PlanDeserializationState &state);
 
+	virtual unique_ptr<LogicalOperator> Copy(ClientContext &context) const;
+
 	virtual bool RequireOptimizer() const {
 		return true;
 	}
@@ -24765,6 +24767,8 @@ public:
 	DUCKDB_API static int64_t Epoch(date_t date);
 	//! Extract the epoch from the date (nanoseconds since 1970-01-01)
 	DUCKDB_API static int64_t EpochNanoseconds(date_t date);
+	//! Extract the epoch from the date (microseconds since 1970-01-01)
+	DUCKDB_API static int64_t EpochMicroseconds(date_t date);
 	//! Convert the epoch (seconds since 1970-01-01) to a date_t
 	DUCKDB_API static date_t EpochToDate(int64_t epoch);