duckdb 0.3.2-dev589.0 → 0.3.2-dev599.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev589.0",
+  "version": "0.3.2-dev599.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {
@@ -25,8 +25,8 @@
     "test": "test"
   },
   "devDependencies": {
-    "mocha": "^8.3.0",
-    "aws-sdk": "^2.790.0"
+    "aws-sdk": "^2.790.0",
+    "mocha": "^8.3.0"
   },
   "repository": {
     "type": "git",

package/src/duckdb.cpp

@@ -24064,7 +24064,7 @@ void Printer::FinishProgressBarPrint(const char *pbstr, int pbwidth) {
 bool Printer::IsTerminal() {
 #ifndef DUCKDB_DISABLE_PRINT
 #ifdef DUCKDB_WINDOWS
-	return GetFileType(stderr) == FILE_TYPE_CHAR;
+	return GetFileType(GetStdHandle(STD_ERROR_HANDLE)) == FILE_TYPE_CHAR;
 #else
 	throw InternalException("IsTerminal is only implemented for Windows");
 #endif
@@ -35179,7 +35179,9 @@ enum class DatePartSpecifier : uint8_t {
 	WEEK,
 	QUARTER,
 	DOY,
-	YEARWEEK
+	YEARWEEK,
+	ERA,
+	OFFSET
 };
 
 DUCKDB_API bool TryGetDatePartSpecifier(const string &specifier, DatePartSpecifier &result);
@@ -79428,7 +79430,7 @@ bool TryGetDatePartSpecifier(const string &specifier_p, DatePartSpecifier &resul
 		result = DatePartSpecifier::YEAR;
 	} else if (specifier == "month" || specifier == "mon" || specifier == "months" || specifier == "mons") {
 		result = DatePartSpecifier::MONTH;
-	} else if (specifier == "day" || specifier == "days" || specifier == "d") {
+	} else if (specifier == "day" || specifier == "days" || specifier == "d" || specifier == "dayofmonth") {
 		result = DatePartSpecifier::DAY;
 	} else if (specifier == "decade" || specifier == "decades") {
 		result = DatePartSpecifier::DECADE;
@@ -79450,13 +79452,13 @@ bool TryGetDatePartSpecifier(const string &specifier_p, DatePartSpecifier &resul
 	} else if (specifier == "epoch") {
 		// seconds since 1970-01-01
 		result = DatePartSpecifier::EPOCH;
-	} else if (specifier == "dow" || specifier == "dayofweek") {
+	} else if (specifier == "dow" || specifier == "dayofweek" || specifier == "weekday") {
 		// day of the week (Sunday = 0, Saturday = 6)
 		result = DatePartSpecifier::DOW;
 	} else if (specifier == "isodow") {
 		// isodow (Monday = 1, Sunday = 7)
 		result = DatePartSpecifier::ISODOW;
-	} else if (specifier == "week" || specifier == "weeks" || specifier == "w") {
+	} else if (specifier == "week" || specifier == "weeks" || specifier == "w" || specifier == "weekofyear") {
 		// week number
 		result = DatePartSpecifier::WEEK;
 	} else if (specifier == "doy" || specifier == "dayofyear") {
@@ -79468,6 +79470,10 @@ bool TryGetDatePartSpecifier(const string &specifier_p, DatePartSpecifier &resul
 	} else if (specifier == "yearweek") {
 		// Combined year and week YYYYWW
 		result = DatePartSpecifier::YEARWEEK;
+	} else if (specifier == "era") {
+		result = DatePartSpecifier::ERA;
+	} else if (specifier == "offset") {
+		result = DatePartSpecifier::OFFSET;
 	} else {
 		return false;
 	}
@@ -79786,6 +79792,35 @@ struct DatePart {
 			return PropagateDatePartStatistics<T, EpochOperator>(child_stats);
 		}
 	};
+
+	struct EraOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			return Date::ExtractYear(input) > 0 ? 1 : 0;
+		}
+
+		template <class T>
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
+		                                                      FunctionData *bind_data,
+		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
+			return PropagateSimpleDatePartStatistics<0, 1>(child_stats);
+		}
+	};
+
+	struct OffsetOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			// Regular timestamps are UTC.
+			return 0;
+		}
+
+		template <class T>
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
+		                                                      FunctionData *bind_data,
+		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
+			return PropagateSimpleDatePartStatistics<0, 0>(child_stats);
+		}
+	};
 };
 
 template <>
@@ -80060,6 +80095,36 @@ DatePart::EpochOperator::PropagateStatistics<dtime_t>(ClientContext &context, Bo
 	return PropagateSimpleDatePartStatistics<0, 86400>(child_stats);
 }
 
+template <>
+int64_t DatePart::EraOperator::Operation(timestamp_t input) {
+	return EraOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
+}
+
+template <>
+int64_t DatePart::EraOperator::Operation(interval_t input) {
+	throw NotImplementedException("interval units \"era\" not recognized");
+}
+
+template <>
+int64_t DatePart::EraOperator::Operation(dtime_t input) {
+	throw NotImplementedException("\"time\" units \"era\" not recognized");
+}
+
+template <>
+int64_t DatePart::OffsetOperator::Operation(timestamp_t input) {
+	return 0;
+}
+
+template <>
+int64_t DatePart::OffsetOperator::Operation(interval_t input) {
+	return 0;
+}
+
+template <>
+int64_t DatePart::OffsetOperator::Operation(dtime_t input) {
+	return 0;
+}
+
 template <class T>
 static int64_t ExtractElement(DatePartSpecifier type, T element) {
 	switch (type) {
@@ -80099,6 +80164,10 @@ static int64_t ExtractElement(DatePartSpecifier type, T element) {
 		return DatePart::MinutesOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::HOUR:
 		return DatePart::HoursOperator::template Operation<T, int64_t>(element);
+	case DatePartSpecifier::ERA:
+		return DatePart::EraOperator::template Operation<T, int64_t>(element);
+	case DatePartSpecifier::OFFSET:
+		return DatePart::OffsetOperator::template Operation<T, int64_t>(element);
 	default:
 		throw NotImplementedException("Specifier type not implemented for DATEPART");
 	}
@@ -80212,6 +80281,7 @@ void DatePartFun::RegisterFunction(BuiltinFunctions &set) {
 	AddDatePartOperator<DatePart::ISODayOfWeekOperator>(set, "isodow");
 	AddDatePartOperator<DatePart::DayOfYearOperator>(set, "dayofyear");
 	AddDatePartOperator<DatePart::WeekOperator>(set, "week");
+	AddDatePartOperator<DatePart::EraOperator>(set, "era");
 	AddTimePartOperator<DatePart::EpochOperator>(set, "epoch");
 	AddTimePartOperator<DatePart::MicrosecondsOperator>(set, "microsecond");
 	AddTimePartOperator<DatePart::MillisecondsOperator>(set, "millisecond");

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "43cae15ac"
-#define DUCKDB_VERSION "0.3.2-dev589"
+#define DUCKDB_SOURCE_ID "e7d62425f"
+#define DUCKDB_VERSION "0.3.2-dev599"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //

package/src/statement.cpp

@@ -171,6 +171,9 @@ static Napi::Value convert_chunk(Napi::Env &env, std::vector<std::string> names,
 			case duckdb::LogicalTypeId::VARCHAR: {
 				value = Napi::String::New(env, dval.str_value);
 			} break;
+			case duckdb::LogicalTypeId::BOOLEAN: {
+				value = Napi::Boolean::New(env, dval.value_.boolean);
+			} break;
 			case duckdb::LogicalTypeId::BLOB: {
 				value = Napi::Buffer<char>::Copy(env, dval.str_value.c_str(), dval.str_value.length());
 			} break;

package/test/data_type_support.test.js

@@ -0,0 +1,23 @@
+var sqlite3 = require("..");
+var assert = require("assert");
+
+describe("data type support", function () {
+  let db;
+  before(function (done) {
+    db = new sqlite3.Database(":memory:", done);
+  });
+
+  it("supports BOOLEAN values", function (done) {
+    db.run("CREATE TABLE boolean_table (i BOOLEAN)");
+    const stmt = db.prepare("INSERT INTO boolean_table VALUES (?)");
+    const values = [true, false];
+    values.forEach((bool) => {
+      stmt.run(bool);
+    });
+    db.prepare("SELECT i from boolean_table;").all((err, res) => {
+      assert(err === null);
+      assert(res.every((v, i) => v.i === values[i]));
+      done();
+    });
+  });
+});