duckdb 0.3.3-dev1265.0 → 0.3.3-dev1279.0

package/package.json

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

package/src/duckdb.cpp

@@ -84787,12 +84787,13 @@ 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()) {
 		throw InvalidInputException("strftime format must be a constant");
 	}
-	Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[1]);
+	Value options_str = ExpressionExecutor::EvaluateScalar(*arguments[REVERSED ? 0 : 1]);
 	StrfTimeFormat format;
 	if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
 		auto format_string = options_str.GetValue<string>();
@@ -84804,16 +84805,17 @@ static unique_ptr<FunctionData> StrfTimeBindFunction(ClientContext &context, Sca
 	return make_unique<StrfTimeBindData>(format);
 }
 
+template <bool REVERSED>
 static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = (BoundFunctionExpression &)state.expr;
 	auto &info = (StrfTimeBindData &)*func_expr.bind_info;
 
-	if (ConstantVector::IsNull(args.data[1])) {
+	if (ConstantVector::IsNull(args.data[REVERSED ? 0 : 1])) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 		ConstantVector::SetNull(result, true);
 		return;
 	}
-	UnaryExecutor::Execute<date_t, string_t>(args.data[0], result, args.size(), [&](date_t input) {
+	UnaryExecutor::Execute<date_t, string_t>(args.data[REVERSED ? 1 : 0], result, args.size(), [&](date_t input) {
 		dtime_t time(0);
 		idx_t len = info.format.GetLength(input, time);
 		string_t target = StringVector::EmptyString(result, len);
@@ -84823,36 +84825,44 @@ static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector
 	});
 }
 
+template <bool REVERSED>
 static void StrfTimeFunctionTimestamp(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = (BoundFunctionExpression &)state.expr;
 	auto &info = (StrfTimeBindData &)*func_expr.bind_info;
 
-	if (ConstantVector::IsNull(args.data[1])) {
+	if (ConstantVector::IsNull(args.data[REVERSED ? 0 : 1])) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 		ConstantVector::SetNull(result, true);
 		return;
 	}
 
-	UnaryExecutor::Execute<timestamp_t, string_t>(args.data[0], result, args.size(), [&](timestamp_t input) {
-		date_t date;
-		dtime_t time;
-		Timestamp::Convert(input, date, time);
-		idx_t len = info.format.GetLength(date, time);
-		string_t target = StringVector::EmptyString(result, len);
-		info.format.FormatString(date, time, target.GetDataWriteable());
-		target.Finalize();
-		return target;
-	});
+	UnaryExecutor::Execute<timestamp_t, string_t>(args.data[REVERSED ? 1 : 0], result, args.size(),
+	                                              [&](timestamp_t input) {
+		                                              date_t date;
+		                                              dtime_t time;
+		                                              Timestamp::Convert(input, date, time);
+		                                              idx_t len = info.format.GetLength(date, time);
+		                                              string_t target = StringVector::EmptyString(result, len);
+		                                              info.format.FormatString(date, time, target.GetDataWriteable());
+		                                              target.Finalize();
+		                                              return target;
+	                                              });
 }
 
 void StrfTimeFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet strftime("strftime");
 
 	strftime.AddFunction(ScalarFunction({LogicalType::DATE, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionDate, false, StrfTimeBindFunction));
+	                                    StrfTimeFunctionDate<false>, false, StrfTimeBindFunction<false>));
 
 	strftime.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionTimestamp, false, StrfTimeBindFunction));
+	                                    StrfTimeFunctionTimestamp<false>, false, StrfTimeBindFunction<false>));
+
+	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::VARCHAR,
+	                                    StrfTimeFunctionDate<true>, false, StrfTimeBindFunction<true>));
+
+	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
+	                                    StrfTimeFunctionTimestamp<true>, false, StrfTimeBindFunction<true>));
 
 	set.AddFunction(strftime);
 }
@@ -164356,6 +164366,7 @@ void WriteOverflowStringsToDisk::AllocateNewBlock(block_id_t new_block_id) {
 
 
 
+
 
 
 namespace duckdb {
@@ -164505,38 +164516,41 @@ void CheckpointManager::WriteSchema(SchemaCatalogEntry &schema) {
 		}
 	});
 
+	FieldWriter writer(*metadata_writer);
+	writer.WriteField<uint32_t>(custom_types.size());
+	writer.WriteField<uint32_t>(sequences.size());
+	writer.WriteField<uint32_t>(tables.size());
+	writer.WriteField<uint32_t>(views.size());
+	writer.WriteField<uint32_t>(macros.size());
+	writer.WriteField<uint32_t>(table_macros.size());
+	writer.Finalize();
+
 	// write the custom_types
-	metadata_writer->Write<uint32_t>(custom_types.size());
 	for (auto &custom_type : custom_types) {
 		WriteType(*custom_type);
 	}
 
 	// write the sequences
-	metadata_writer->Write<uint32_t>(sequences.size());
 	for (auto &seq : sequences) {
 		WriteSequence(*seq);
 	}
 	// reorder tables because of foreign key constraint
 	ReorderTableEntries(tables);
 	// now write the tables
-	metadata_writer->Write<uint32_t>(tables.size());
 	for (auto &table : tables) {
 		WriteTable(*table);
 	}
 	// now write the views
-	metadata_writer->Write<uint32_t>(views.size());
 	for (auto &view : views) {
 		WriteView(*view);
 	}
 
 	// finally write the macro's
-	metadata_writer->Write<uint32_t>(macros.size());
 	for (auto &macro : macros) {
 		WriteMacro(*macro);
 	}
 
 	// finally write the macro's
-	metadata_writer->Write<uint32_t>(table_macros.size());
 	for (auto &macro : table_macros) {
 		WriteTableMacro(*macro);
 	}
@@ -164551,35 +164565,39 @@ void CheckpointManager::ReadSchema(ClientContext &context, MetaBlockReader &read
 	info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
 	catalog.CreateSchema(context, info.get());
 
+	// first read all the counts
+	FieldReader field_reader(reader);
+	uint32_t enum_count = field_reader.ReadRequired<uint32_t>();
+	uint32_t seq_count = field_reader.ReadRequired<uint32_t>();
+	uint32_t table_count = field_reader.ReadRequired<uint32_t>();
+	uint32_t view_count = field_reader.ReadRequired<uint32_t>();
+	uint32_t macro_count = field_reader.ReadRequired<uint32_t>();
+	uint32_t table_macro_count = field_reader.ReadRequired<uint32_t>();
+	field_reader.Finalize();
+
 	// now read the enums
-	uint32_t enum_count = reader.Read<uint32_t>();
 	for (uint32_t i = 0; i < enum_count; i++) {
 		ReadType(context, reader);
 	}
 
 	// read the sequences
-	uint32_t seq_count = reader.Read<uint32_t>();
 	for (uint32_t i = 0; i < seq_count; i++) {
 		ReadSequence(context, reader);
 	}
 	// read the table count and recreate the tables
-	uint32_t table_count = reader.Read<uint32_t>();
 	for (uint32_t i = 0; i < table_count; i++) {
 		ReadTable(context, reader);
 	}
 	// now read the views
-	uint32_t view_count = reader.Read<uint32_t>();
 	for (uint32_t i = 0; i < view_count; i++) {
 		ReadView(context, reader);
 	}
 
 	// finally read the macro's
-	uint32_t macro_count = reader.Read<uint32_t>();
 	for (uint32_t i = 0; i < macro_count; i++) {
 		ReadMacro(context, reader);
 	}
 
-	uint32_t table_macro_count = reader.Read<uint32_t>();
 	for (uint32_t i = 0; i < table_macro_count; i++) {
 		ReadTableMacro(context, reader);
 	}
@@ -172960,7 +172978,7 @@ string ValidityStatistics::ToString() const {
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 32;
+const uint64_t VERSION_NUMBER = 33;
 
 } // 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 "6bc3f4461"
-#define DUCKDB_VERSION "v0.3.3-dev1265"
+#define DUCKDB_SOURCE_ID "f1278198b"
+#define DUCKDB_VERSION "v0.3.3-dev1279"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -5504,10 +5504,9 @@ class CycleCounter {
 	friend struct ExpressionInfo;
 	friend struct ExpressionRootInfo;
 	static constexpr int SAMPLING_RATE = 50;
-	static constexpr int SAMPLING_VARIANCE = 100;
 
 public:
-	CycleCounter() : random(-1) {
+	CycleCounter() {
 	}
 	// Next_sample determines if a sample needs to be taken, if so start the profiler
 	void BeginSample() {
@@ -5522,7 +5521,7 @@ public:
 			time += Tick() - tmp;
 		}
 		if (current_count >= next_sample) {
-			next_sample = SAMPLING_RATE + random.NextRandomInteger() % SAMPLING_VARIANCE;
+			next_sample = SAMPLING_RATE;
 			++sample_count;
 			sample_tuples_count += chunk_size;
 			current_count = 0;
@@ -5548,8 +5547,6 @@ private:
 	uint64_t sample_tuples_count = 0;
 	//! Count the number of ALL tuples
 	uint64_t tuples_count = 0;
-	//! the random number generator used for sampling
-	RandomEngine random;
 };
 
 } // namespace duckdb