duckdb 0.4.1-dev19.0 → 0.4.1-dev26.0

package/package.json

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

package/src/duckdb.cpp

@@ -6039,6 +6039,7 @@ private:
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
 ArrowSchemaWrapper::~ArrowSchemaWrapper() {
@@ -6235,6 +6236,7 @@ unique_ptr<DataChunk> ArrowUtil::FetchChunk(QueryResult *result, idx_t chunk_siz
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
 void DuckDBAssertInternal(bool condition, const char *condition_name, const char *file, int linenr) {
@@ -6842,6 +6844,7 @@ uint64_t CycleCounter::Tick() const {
 
 
 
+
 namespace duckdb {
 
 // LCOV_EXCL_START
@@ -13922,6 +13925,7 @@ void FileBuffer::Clear() {
 #undef RemoveDirectory
 
 #endif
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -17282,6 +17286,7 @@ public:
 
 
 
+
 #include <cstdint>
 #include <cstdio>
 
@@ -30782,7 +30787,8 @@ std::vector<Match> RegexFindAll(const std::string &input, const Regex &regex) {
 	return matches;
 }
 
-} // namespace duckdb_re2//===----------------------------------------------------------------------===//
+} // namespace duckdb_re2
+//===----------------------------------------------------------------------===//
 //                         DuckDB
 //
 // duckdb/common/types/row_operations/row_aggregate.cpp
@@ -37172,6 +37178,7 @@ private:
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -38252,7 +38259,8 @@ unique_ptr<RenderTree> TreeRenderer::CreateTree(const Pipeline &op) {
 	return CreateRenderTree<PipelineRenderNode>(*node);
 }
 
-} // namespace duckdb//===----------------------------------------------------------------------===//
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
 //                         DuckDB
 //
 // duckdb/common/types/batched_chunk_collection.hpp
@@ -39350,6 +39358,7 @@ struct ArrowAuxiliaryData : VectorAuxiliaryData {
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
 DataChunk::DataChunk() : count(0), capacity(STANDARD_VECTOR_SIZE) {
@@ -41677,6 +41686,7 @@ private:
 
 
 
+
 namespace duckdb {
 
 HyperLogLog::HyperLogLog() : hll(nullptr) {
@@ -61615,6 +61625,7 @@ public:
 
 } // namespace duckdb
 
+
 namespace duckdb {
 
 class PhysicalExecute : public PhysicalOperator {
@@ -73810,6 +73821,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 PhysicalCreateType::PhysicalCreateType(unique_ptr<CreateTypeInfo> info, idx_t estimated_cardinality)
@@ -91605,18 +91617,22 @@ void DateSubFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+
 namespace duckdb {
 
 struct DateTrunc {
+	template <class TA, class TR, class OP>
+	static inline TR UnaryFunction(TA input) {
+		if (Value::IsFinite(input)) {
+			return OP::template Operation<TA, TR>(input);
+		} else {
+			return Cast::template Operation<TA, TR>(input);
+		}
+	}
+
 	template <class TA, class TR, class OP>
 	static inline void UnaryExecute(Vector &left, Vector &result, idx_t count) {
-		UnaryExecutor::Execute<TA, TR>(left, result, count, [&](TA input) {
-			if (Value::IsFinite(input)) {
-				return OP::template Operation<TA, TR>(input);
-			} else {
-				return Cast::template Operation<TA, TR>(input);
-			}
-		});
+		UnaryExecutor::Execute<TA, TR>(left, result, count, UnaryFunction<TA, TR, OP>);
 	}
 
 	struct MillenniumOperator {
@@ -92179,6 +92195,82 @@ static void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &r
 	}
 }
 
+template <class TA, class TR, class OP>
+static unique_ptr<BaseStatistics> DateTruncStatistics(vector<unique_ptr<BaseStatistics>> &child_stats) {
+	// we can only propagate date stats if the child has stats
+	if (!child_stats[1]) {
+		return nullptr;
+	}
+	auto &nstats = (NumericStatistics &)*child_stats[1];
+	if (nstats.min.IsNull() || nstats.max.IsNull()) {
+		return nullptr;
+	}
+	// run the operator on both the min and the max, this gives us the [min, max] bound
+	auto min = nstats.min.GetValueUnsafe<TA>();
+	auto max = nstats.max.GetValueUnsafe<TA>();
+	if (min > max) {
+		throw InternalException("Invalid DATETRUNC child statistics");
+	}
+
+	// Infinite values are unmodified
+	auto min_part = DateTrunc::UnaryFunction<TA, TR, OP>(min);
+	auto max_part = DateTrunc::UnaryFunction<TA, TR, OP>(max);
+
+	auto min_value = Value::CreateValue(min_part);
+	auto max_value = Value::CreateValue(max_part);
+	auto result = make_unique<NumericStatistics>(min_value.type(), min_value, max_value, StatisticsType::LOCAL_STATS);
+	if (child_stats[0]->validity_stats) {
+		result->validity_stats = child_stats[1]->validity_stats->Copy();
+	}
+	return move(result);
+}
+
+template <class TA, class TR, class OP>
+static unique_ptr<BaseStatistics> PropagateDateTruncStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+	return DateTruncStatistics<TA, TR, OP>(input.child_stats);
+}
+
+template <typename TA, typename TR>
+static function_statistics_t DateTruncStats(DatePartSpecifier type) {
+	switch (type) {
+	case DatePartSpecifier::MILLENNIUM:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MillenniumOperator>;
+	case DatePartSpecifier::CENTURY:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::CenturyOperator>;
+	case DatePartSpecifier::DECADE:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::DecadeOperator>;
+	case DatePartSpecifier::YEAR:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::YearOperator>;
+	case DatePartSpecifier::QUARTER:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::QuarterOperator>;
+	case DatePartSpecifier::MONTH:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MonthOperator>;
+	case DatePartSpecifier::WEEK:
+	case DatePartSpecifier::YEARWEEK:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::WeekOperator>;
+	case DatePartSpecifier::ISOYEAR:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::ISOYearOperator>;
+	case DatePartSpecifier::DAY:
+	case DatePartSpecifier::DOW:
+	case DatePartSpecifier::ISODOW:
+	case DatePartSpecifier::DOY:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::DayOperator>;
+	case DatePartSpecifier::HOUR:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::HourOperator>;
+	case DatePartSpecifier::MINUTE:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MinuteOperator>;
+	case DatePartSpecifier::SECOND:
+	case DatePartSpecifier::EPOCH:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::SecondOperator>;
+	case DatePartSpecifier::MILLISECONDS:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MillisecondOperator>;
+	case DatePartSpecifier::MICROSECONDS:
+		return PropagateDateTruncStatistics<TA, TR, DateTrunc::MicrosecondOperator>;
+	default:
+		throw NotImplementedException("Specifier type not implemented for DATETRUNC statistics");
+	}
+}
+
 static unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunction &bound_function,
                                               vector<unique_ptr<Expression>> &arguments) {
 	if (!arguments[0]->IsFoldable()) {
@@ -92209,9 +92301,11 @@ static unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunc
 		switch (arguments[1]->return_type.id()) {
 		case LogicalType::TIMESTAMP:
 			bound_function.function = DateTruncFunction<timestamp_t, date_t>;
+			bound_function.statistics = DateTruncStats<timestamp_t, date_t>(part_code);
 			break;
 		case LogicalType::DATE:
 			bound_function.function = DateTruncFunction<date_t, date_t>;
+			bound_function.statistics = DateTruncStats<date_t, date_t>(part_code);
 			break;
 		default:
 			break;
@@ -92219,6 +92313,16 @@ static unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunc
 		bound_function.return_type = LogicalType::DATE;
 		break;
 	default:
+		switch (arguments[1]->return_type.id()) {
+		case LogicalType::TIMESTAMP:
+			bound_function.statistics = DateTruncStats<timestamp_t, timestamp_t>(part_code);
+			break;
+		case LogicalType::DATE:
+			bound_function.statistics = DateTruncStats<timestamp_t, date_t>(part_code);
+			break;
+		default:
+			break;
+		}
 		break;
 	}
 
@@ -95014,6 +95118,7 @@ void ListPositionFun::RegisterFunction(BuiltinFunctions &set) {
 } // namespace duckdb
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -96431,6 +96536,7 @@ void ListSortFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+
 namespace duckdb {
 
 static void ListValueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -114996,6 +115102,7 @@ private:
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -116514,6 +116621,7 @@ bool ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &res
 
 
 
+
 namespace duckdb {
 
 ClientData::ClientData(ClientContext &context) : catalog_search_path(make_unique<CatalogSearchPath>(context)) {
@@ -132071,6 +132179,7 @@ private:
 
 
 
+
 namespace duckdb {
 
 using ExpressionValueInformation = FilterCombiner::ExpressionValueInformation;
@@ -135624,6 +135733,7 @@ public:
 
 } // namespace duckdb
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -147305,6 +147415,7 @@ unique_ptr<ParsedExpression> BetweenExpression::Deserialize(ExpressionType type,
 
 
 
+
 namespace duckdb {
 
 CaseExpression::CaseExpression() : ParsedExpression(ExpressionType::CASE_EXPR, ExpressionClass::CASE) {
@@ -148505,6 +148616,7 @@ string KeywordHelper::WriteOptionallyQuoted(const string &text, char quote) {
 
 
 
+
 namespace duckdb {
 
 AlterInfo::AlterInfo(AlterType type, string schema_p, string name_p)
@@ -160035,6 +160147,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery
 
 
 
+
 namespace duckdb {
 
 unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode *node) {
@@ -160752,6 +160865,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateType(duckdb_libpgquery::
 
 
 
+
 namespace duckdb {
 
 unique_ptr<CreateStatement> Transformer::TransformCreateView(duckdb_libpgquery::PGNode *node) {
@@ -171258,6 +171372,7 @@ BindResult ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, Colu
 
 } // namespace duckdb
 
+
 namespace duckdb {
 
 ConstantBinder::ConstantBinder(Binder &binder, ClientContext &context, string clause)
@@ -174775,6 +174890,7 @@ public:
 #endif
 
 
+
 namespace duckdb {
 
 BlockHandle::BlockHandle(DatabaseInstance &db, block_id_t block_id_p)
@@ -178533,6 +178649,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 struct StringHash {
@@ -179180,6 +179297,7 @@ bool DictionaryCompressionFun::TypeIsSupported(PhysicalType type) {
 
 
 
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -188591,6 +188709,7 @@ struct UpdateInfo {
 
 } // namespace duckdb
 
+
 namespace duckdb {
 
 static UpdateSegment::initialize_update_function_t GetInitializeUpdateFunction(PhysicalType type);

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 "6e4d98f9f"
-#define DUCKDB_VERSION "v0.4.1-dev19"
+#define DUCKDB_SOURCE_ID "8e602ba1d"
+#define DUCKDB_VERSION "v0.4.1-dev26"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -401,6 +401,7 @@ DUCKDB_API void DuckDBAssertInternal(bool condition, const char *condition_name,
 
 #endif
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -10086,6 +10087,7 @@ private:
 
 } // namespace duckdb
 
+
 namespace duckdb {
 
 class ClientContext;
@@ -10124,6 +10126,7 @@ public:
 };
 
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -11264,6 +11267,7 @@ private:
 
 } // namespace duckdb
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -15358,6 +15362,7 @@ namespace duckdb {
 using std::deque;
 }
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -17435,6 +17440,7 @@ private:
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -17489,6 +17495,7 @@ private:
 };
 
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -17697,6 +17704,7 @@ public:
 
 } // namespace duckdb
 
+
 namespace duckdb {
 class Appender;
 class Catalog;
@@ -18087,6 +18095,7 @@ protected:
 
 
 
+
 namespace duckdb {
 
 class ChunkCollection;
@@ -18701,6 +18710,7 @@ public:
 
 } // namespace duckdb
 
+
 namespace duckdb {
 class StorageManager;
 class Catalog;
@@ -18843,6 +18853,7 @@ ExternC const PfnDliHook __pfnDliFailureHook2 = duckdb_dllimport_delay_hook;
 }
 #endif
 #endif
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //