duckdb 0.3.3-dev1393.0 → 0.3.3-dev1399.0

package/package.json

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

package/src/duckdb.cpp

@@ -74887,9 +74887,9 @@ struct VectorMinMaxBase {
 			const auto sidx = sdata.sel->get_index(i);
 			auto state = states[sidx];
 			if (!state->value) {
-				Assign(state, input, idx);
+				Assign(state, input, i);
 			} else {
-				OP::template Execute(state, input, idx, count);
+				OP::template Execute(state, input, i, count);
 			}
 		}
 	}
@@ -74908,10 +74908,19 @@ struct VectorMinMaxBase {
 	template <class T, class STATE>
 	static void Finalize(Vector &result, FunctionData *, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->value) {
-			// we need to use FlatVector::SetNull here
+			// we need to use SetNull here
 			// since for STRUCT columns only setting the validity mask of the struct is incorrect
 			// as for a struct column, we need to also set ALL child columns to NULL
-			FlatVector::SetNull(result, idx, true);
+			switch (result.GetVectorType()) {
+			case VectorType::FLAT_VECTOR:
+				FlatVector::SetNull(result, idx, true);
+				break;
+			case VectorType::CONSTANT_VECTOR:
+				ConstantVector::SetNull(result, true);
+				break;
+			default:
+				throw InternalException("Invalid result vector type for nested min/max");
+			}
 		} else {
 			VectorOperations::Copy(*state->value, result, 1, 0, idx);
 		}
@@ -84390,7 +84399,7 @@ char *StrfTimeFormat::Write2(char *target, uint8_t value) {
 }
 
 // write a value in the range of 0..99 padded to 2 digits
-char *StrfTimeFormat::WritePadded2(char *target, int32_t value) {
+char *StrfTimeFormat::WritePadded2(char *target, uint32_t value) {
 	D_ASSERT(value < 100);
 	auto index = static_cast<unsigned>(value * 2);
 	*target++ = duckdb_fmt::internal::data::digits[index];
@@ -84413,9 +84422,9 @@ char *StrfTimeFormat::WritePadded3(char *target, uint32_t value) {
 }
 
 // write a value in the range of 0..999999 padded to 6 digits
-char *StrfTimeFormat::WritePadded(char *target, int32_t value, int32_t padding) {
+char *StrfTimeFormat::WritePadded(char *target, uint32_t value, size_t padding) {
 	D_ASSERT(padding % 2 == 0);
-	for (int i = 0; i < padding / 2; i++) {
+	for (size_t i = 0; i < padding / 2; i++) {
 		int decimals = value % 100;
 		WritePadded2(target + padding - 2 * (i + 1), decimals);
 		value /= 100;
@@ -84590,6 +84599,7 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 }
 
 void StrfTimeFormat::FormatString(date_t date, int32_t data[7], char *target) {
+	D_ASSERT(specifiers.size() + 1 == literals.size());
 	idx_t i;
 	for (i = 0; i < specifiers.size(); i++) {
 		// first copy the current literal
@@ -84810,12 +84820,12 @@ struct StrfTimeBindData : public FunctionData {
 template <bool REVERSED>
 static unique_ptr<FunctionData> StrfTimeBindFunction(ClientContext &context, ScalarFunction &bound_function,
                                                      vector<unique_ptr<Expression>> &arguments) {
-	if (!arguments[1]->IsFoldable()) {
+	if (!arguments[REVERSED ? 0 : 1]->IsFoldable()) {
 		throw InvalidInputException("strftime format must be a constant");
 	}
 	Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[REVERSED ? 0 : 1]);
 	StrfTimeFormat format;
-	if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
+	if (!options_str.IsNull()) {
 		auto format_string = options_str.GetValue<string>();
 		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
 		if (!error.empty()) {
@@ -104638,8 +104648,12 @@ void duckdb_destroy_value(duckdb_value *value) {
 	}
 }
 
+duckdb_value duckdb_create_varchar_length(const char *text, idx_t length) {
+	return (duckdb_value) new duckdb::Value(std::string(text, length));
+}
+
 duckdb_value duckdb_create_varchar(const char *text) {
-	return (duckdb_value) new duckdb::Value(text);
+	return duckdb_create_varchar_length(text, strlen(text));
 }
 
 duckdb_value duckdb_create_int64(int64_t input) {

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 "dece0efa7"
-#define DUCKDB_VERSION "v0.3.3-dev1393"
+#define DUCKDB_SOURCE_ID "7c5ba6c0e"
+#define DUCKDB_VERSION "v0.3.3-dev1399"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -15896,13 +15896,22 @@ Destroys the value and de-allocates all memory allocated for that type.
 DUCKDB_API void duckdb_destroy_value(duckdb_value *value);
 
 /*!
-Creates a value from a varchar
+Creates a value from a null-terminated string
 
-* value: The varchar value
+* value: The null-terminated string
 * returns: The value. This must be destroyed with `duckdb_destroy_value`.
 */
 DUCKDB_API duckdb_value duckdb_create_varchar(const char *text);
 
+/*!
+Creates a value from a string
+
+* value: The text
+* length: The length of the text
+* returns: The value. This must be destroyed with `duckdb_destroy_value`.
+*/
+DUCKDB_API duckdb_value duckdb_create_varchar_length(const char *text, idx_t length);
+
 /*!
 Creates a value from an int64
 
@@ -21896,9 +21905,9 @@ protected:
 	static idx_t GetSpecifierLength(StrTimeSpecifier specifier, date_t date, dtime_t time);
 	char *WriteString(char *target, const string_t &str);
 	char *Write2(char *target, uint8_t value);
-	char *WritePadded2(char *target, int32_t value);
+	char *WritePadded2(char *target, uint32_t value);
 	char *WritePadded3(char *target, uint32_t value);
-	char *WritePadded(char *target, int32_t value, int32_t padding);
+	char *WritePadded(char *target, uint32_t value, size_t padding);
 	bool IsDateSpecifier(StrTimeSpecifier specifier);
 	char *WriteDateSpecifier(StrTimeSpecifier specifier, date_t date, char *target);
 	char *WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], char *target);