duckdb 0.7.2-dev2740.0 → 0.7.2-dev2820.0

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/function_entry.hpp

@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry/function_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/catalog/standard_entry.hpp"
+#include "duckdb/parser/parsed_data/create_function_info.hpp"
+
+namespace duckdb {
+
+//! An aggregate function in the catalog
+class FunctionEntry : public StandardEntry {
+public:
+	FunctionEntry(CatalogType type, Catalog &catalog, SchemaCatalogEntry &schema, CreateFunctionInfo &info)
+	    : StandardEntry(type, schema, catalog, info.name) {
+		description = std::move(info.description);
+		parameter_names = std::move(info.parameter_names);
+		example = std::move(info.example);
+	}
+
+	//! The description (if any)
+	string description;
+	//! Parameter names (if any)
+	vector<string> parameter_names;
+	//! The example (if any)
+	string example;
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/macro_catalog_entry.hpp

@@ -9,14 +9,14 @@
 #pragma once
 
 #include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/catalog/standard_entry.hpp"
+#include "duckdb/catalog/catalog_entry/function_entry.hpp"
 #include "duckdb/function/macro_function.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 
 namespace duckdb {
 
 //! A macro function in the catalog
-class MacroCatalogEntry : public StandardEntry {
+class MacroCatalogEntry : public FunctionEntry {
 public:
 	MacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/catalog/standard_entry.hpp"
+#include "duckdb/catalog/catalog_entry/function_entry.hpp"
 #include "duckdb/function/pragma_function.hpp"
 #include "duckdb/function/function_set.hpp"
 
@@ -18,7 +18,7 @@ class Catalog;
 struct CreatePragmaFunctionInfo;
 
 //! A table function in the catalog
-class PragmaFunctionCatalogEntry : public StandardEntry {
+class PragmaFunctionCatalogEntry : public FunctionEntry {
 public:
 	static constexpr const CatalogType Type = CatalogType::PRAGMA_FUNCTION_ENTRY;
 	static constexpr const char *Name = "pragma function";

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/catalog/standard_entry.hpp"
+#include "duckdb/catalog/catalog_entry/function_entry.hpp"
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/function/function.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
@@ -16,7 +16,7 @@
 namespace duckdb {
 
 //! A table function in the catalog
-class ScalarFunctionCatalogEntry : public StandardEntry {
+class ScalarFunctionCatalogEntry : public FunctionEntry {
 public:
 	static constexpr const CatalogType Type = CatalogType::SCALAR_FUNCTION_ENTRY;
 	static constexpr const char *Name = "scalar function";

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/catalog/standard_entry.hpp"
+#include "duckdb/catalog/catalog_entry/function_entry.hpp"
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/function/function.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
@@ -16,7 +16,7 @@
 namespace duckdb {
 
 //! A table function in the catalog
-class TableFunctionCatalogEntry : public StandardEntry {
+class TableFunctionCatalogEntry : public FunctionEntry {
 public:
 	static constexpr const CatalogType Type = CatalogType::TABLE_FUNCTION_ENTRY;
 	static constexpr const char *Name = "table function";

package/src/duckdb/src/include/duckdb/catalog/catalog_transaction.hpp

@@ -28,6 +28,8 @@ struct CatalogTransaction {
 	transaction_t start_time;
 
 	ClientContext &GetContext();
+
+	static CatalogTransaction GetSystemTransaction(DatabaseInstance &db);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/algorithm.hpp

@@ -9,3 +9,4 @@
 #pragma once
 
 #include <algorithm>
+#include <cmath>

package/src/duckdb/src/include/duckdb/common/types/vector.hpp

@@ -419,12 +419,16 @@ struct FSSTVector {
 	DUCKDB_API static idx_t GetCount(Vector &vector);
 };
 
+enum class MapInvalidReason : uint8_t { VALID, NULL_KEY_LIST, NULL_KEY, DUPLICATE_KEY };
+
 struct MapVector {
 	DUCKDB_API static const Vector &GetKeys(const Vector &vector);
 	DUCKDB_API static const Vector &GetValues(const Vector &vector);
 	DUCKDB_API static Vector &GetKeys(Vector &vector);
 	DUCKDB_API static Vector &GetValues(Vector &vector);
-	static vector<idx_t> Search(Vector &keys, idx_t count, const Value &key, list_entry_t &entry);
+	DUCKDB_API static MapInvalidReason
+	CheckMapValidity(Vector &map, idx_t count, const SelectionVector &sel = *FlatVector::IncrementalSelectionVector());
+	DUCKDB_API static void MapConversionVerify(Vector &vector, idx_t count);
 };
 
 struct StructVector {
@@ -432,6 +436,8 @@ struct StructVector {
 	DUCKDB_API static vector<unique_ptr<Vector>> &GetEntries(Vector &vector);
 };
 
+enum class UnionInvalidReason : uint8_t { VALID, TAG_OUT_OF_RANGE, NO_MEMBERS, VALIDITY_OVERLAP };
+
 struct UnionVector {
 	// Unions are stored as structs, but the first child is always the "tag"
 	// vector, specifying the currently selected member for that row.
@@ -465,6 +471,10 @@ struct UnionVector {
 	//! This will also handle invalidation of the non-selected members
 	DUCKDB_API static void SetToMember(Vector &vector, union_tag_t tag, Vector &member_vector, idx_t count,
 	                                   bool keep_tags_for_null);
+
+	DUCKDB_API static UnionInvalidReason
+	CheckUnionValidity(Vector &vector, idx_t count,
+	                   const SelectionVector &sel = *FlatVector::IncrementalSelectionVector());
 };
 
 struct SequenceVector {

package/src/duckdb/src/include/duckdb/{function → core_functions}/aggregate/algebraic/corr.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/function/aggregate/algebraic/corr.hpp
+// duckdb/core_functions/aggregate/algebraic/corr.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -9,9 +9,8 @@
 #pragma once
 
 #include "duckdb/function/aggregate_function.hpp"
-#include "duckdb/function/aggregate/algebraic_functions.hpp"
-#include "duckdb/function/aggregate/algebraic/covar.hpp"
-#include "duckdb/function/aggregate/algebraic/stddev.hpp"
+#include "duckdb/core_functions/aggregate/algebraic/covar.hpp"
+#include "duckdb/core_functions/aggregate/algebraic/stddev.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/{function → core_functions}/aggregate/algebraic/covar.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/function/aggregate/algebraic/covar.hpp
+// duckdb/core_functions/aggregate/algebraic/covar.hpp
 //
 //
 //===----------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/{function → core_functions}/aggregate/algebraic/stddev.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/function/aggregate/algebraic/stddev.hpp
+// duckdb/core_functions/aggregate/algebraic/stddev.hpp
 //
 //
 //===----------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/core_functions/aggregate/algebraic_functions.hpp

@@ -0,0 +1,124 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/core_functions/aggregate/algebraic_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+// This file is generated by scripts/generate_functions.py
+
+#pragma once
+
+#include "duckdb/function/function_set.hpp"
+
+namespace duckdb {
+
+struct AvgFun {
+	static constexpr const char *Name = "avg";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Calculates the average value for all tuples in x.";
+	static constexpr const char *Example = "SUM(x) / COUNT(*)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct MeanFun {
+	using ALIAS = AvgFun;
+
+	static constexpr const char *Name = "mean";
+};
+
+struct CorrFun {
+	static constexpr const char *Name = "corr";
+	static constexpr const char *Parameters = "y,x";
+	static constexpr const char *Description = "Returns the correlation coefficient for non-null pairs in a group.";
+	static constexpr const char *Example = "COVAR_POP(y, x) / (STDDEV_POP(x) * STDDEV_POP(y))";
+
+	static AggregateFunction GetFunction();
+};
+
+struct CovarPopFun {
+	static constexpr const char *Name = "covar_pop";
+	static constexpr const char *Parameters = "y,x";
+	static constexpr const char *Description = "Returns the population covariance of input values.";
+	static constexpr const char *Example = "(SUM(x*y) - SUM(x) * SUM(y) / COUNT(*)) / COUNT(*)";
+
+	static AggregateFunction GetFunction();
+};
+
+struct CovarSampFun {
+	static constexpr const char *Name = "covar_samp";
+	static constexpr const char *Parameters = "y,x";
+	static constexpr const char *Description = "Returns the sample covariance for non-null pairs in a group.";
+	static constexpr const char *Example = "(SUM(x*y) - SUM(x) * SUM(y) / COUNT(*)) / (COUNT(*) - 1)";
+
+	static AggregateFunction GetFunction();
+};
+
+struct FAvgFun {
+	static constexpr const char *Name = "favg";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Calculates the average using a more accurate floating point summation (Kahan Sum)";
+	static constexpr const char *Example = "favg(A)";
+
+	static AggregateFunction GetFunction();
+};
+
+struct StandardErrorOfTheMeanFun {
+	static constexpr const char *Name = "sem";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the standard error of the mean";
+	static constexpr const char *Example = "";
+
+	static AggregateFunction GetFunction();
+};
+
+struct StdDevPopFun {
+	static constexpr const char *Name = "stddev_pop";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the population standard deviation.";
+	static constexpr const char *Example = "sqrt(var_pop(x))";
+
+	static AggregateFunction GetFunction();
+};
+
+struct StdDevSampFun {
+	static constexpr const char *Name = "stddev_samp";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the sample standard deviation";
+	static constexpr const char *Example = "sqrt(var_samp(x))";
+
+	static AggregateFunction GetFunction();
+};
+
+struct StddevFun {
+	using ALIAS = StdDevSampFun;
+
+	static constexpr const char *Name = "stddev";
+};
+
+struct VarPopFun {
+	static constexpr const char *Name = "var_pop";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the population variance.";
+	static constexpr const char *Example = "";
+
+	static AggregateFunction GetFunction();
+};
+
+struct VarSampFun {
+	static constexpr const char *Name = "var_samp";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the sample variance of all input values.";
+	static constexpr const char *Example = "(SUM(x^2) - SUM(x)^2 / COUNT(x)) / (COUNT(x) - 1)";
+
+	static AggregateFunction GetFunction();
+};
+
+struct VarianceFun {
+	using ALIAS = VarSampFun;
+
+	static constexpr const char *Name = "variance";
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/aggregate/distributive_functions.hpp

@@ -0,0 +1,229 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/core_functions/aggregate/distributive_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+// This file is generated by scripts/generate_functions.py
+
+#pragma once
+
+#include "duckdb/function/function_set.hpp"
+
+namespace duckdb {
+
+struct ApproxCountDistinctFun {
+	static constexpr const char *Name = "approx_count_distinct";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Computes the approximate count of distinct elements using HyperLogLog.";
+	static constexpr const char *Example = "approx_count_distinct(A)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct ArgMinFun {
+	static constexpr const char *Name = "arg_min";
+	static constexpr const char *Parameters = "arg,val";
+	static constexpr const char *Description = "Finds the row with the minimum val. Calculates the arg expression at that row.";
+	static constexpr const char *Example = "arg_min(A,B)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct ArgminFun {
+	using ALIAS = ArgMinFun;
+
+	static constexpr const char *Name = "argmin";
+};
+
+struct MinByFun {
+	using ALIAS = ArgMinFun;
+
+	static constexpr const char *Name = "min_by";
+};
+
+struct ArgMaxFun {
+	static constexpr const char *Name = "arg_max";
+	static constexpr const char *Parameters = "arg,val";
+	static constexpr const char *Description = "Finds the row with the maximum val. Calculates the arg expression at that row.";
+	static constexpr const char *Example = "arg_max(A,B)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct ArgmaxFun {
+	using ALIAS = ArgMaxFun;
+
+	static constexpr const char *Name = "argmax";
+};
+
+struct MaxByFun {
+	using ALIAS = ArgMaxFun;
+
+	static constexpr const char *Name = "max_by";
+};
+
+struct BitAndFun {
+	static constexpr const char *Name = "bit_and";
+	static constexpr const char *Parameters = "arg";
+	static constexpr const char *Description = "Returns the bitwise AND of all bits in a given expression.";
+	static constexpr const char *Example = "bit_and(A)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct BitOrFun {
+	static constexpr const char *Name = "bit_or";
+	static constexpr const char *Parameters = "arg";
+	static constexpr const char *Description = "Returns the bitwise OR of all bits in a given expression.";
+	static constexpr const char *Example = "bit_or(A)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct BitXorFun {
+	static constexpr const char *Name = "bit_xor";
+	static constexpr const char *Parameters = "arg";
+	static constexpr const char *Description = "Returns the bitwise XOR of all bits in a given expression.";
+	static constexpr const char *Example = "bit_xor(A)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct BitstringAggFun {
+	static constexpr const char *Name = "bitstring_agg";
+	static constexpr const char *Parameters = "arg";
+	static constexpr const char *Description = "Returns a bitstring with bits set for each distinct value.";
+	static constexpr const char *Example = "bitstring_agg(A)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct BoolAndFun {
+	static constexpr const char *Name = "bool_and";
+	static constexpr const char *Parameters = "arg";
+	static constexpr const char *Description = "Returns TRUE if every input value is TRUE, otherwise FALSE.";
+	static constexpr const char *Example = "bool_and(A)";
+
+	static AggregateFunction GetFunction();
+};
+
+struct BoolOrFun {
+	static constexpr const char *Name = "bool_or";
+	static constexpr const char *Parameters = "arg";
+	static constexpr const char *Description = "Returns TRUE if any input value is TRUE, otherwise FALSE.";
+	static constexpr const char *Example = "bool_or(A)";
+
+	static AggregateFunction GetFunction();
+};
+
+struct EntropyFun {
+	static constexpr const char *Name = "entropy";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the log-2 entropy of count input-values.";
+	static constexpr const char *Example = "";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct KahanSumFun {
+	static constexpr const char *Name = "kahan_sum";
+	static constexpr const char *Parameters = "arg";
+	static constexpr const char *Description = "Calculates the sum using a more accurate floating point summation (Kahan Sum).";
+	static constexpr const char *Example = "kahan_sum(A)";
+
+	static AggregateFunction GetFunction();
+};
+
+struct FsumFun {
+	using ALIAS = KahanSumFun;
+
+	static constexpr const char *Name = "fsum";
+};
+
+struct SumkahanFun {
+	using ALIAS = KahanSumFun;
+
+	static constexpr const char *Name = "sumkahan";
+};
+
+struct KurtosisFun {
+	static constexpr const char *Name = "kurtosis";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the excess kurtosis (Fisher’s definition) of all input values, with a bias correction according to the sample size";
+	static constexpr const char *Example = "";
+
+	static AggregateFunction GetFunction();
+};
+
+struct MinFun {
+	static constexpr const char *Name = "min";
+	static constexpr const char *Parameters = "arg";
+	static constexpr const char *Description = "Returns the minimum value present in arg.";
+	static constexpr const char *Example = "min(A)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct MaxFun {
+	static constexpr const char *Name = "max";
+	static constexpr const char *Parameters = "arg";
+	static constexpr const char *Description = "Returns the maximum value present in arg.";
+	static constexpr const char *Example = "max(A)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct ProductFun {
+	static constexpr const char *Name = "product";
+	static constexpr const char *Parameters = "arg";
+	static constexpr const char *Description = "Calculates the product of all tuples in arg.";
+	static constexpr const char *Example = "product(A)";
+
+	static AggregateFunction GetFunction();
+};
+
+struct SkewnessFun {
+	static constexpr const char *Name = "skewness";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the skewness of all input values.";
+	static constexpr const char *Example = "skewness(A)";
+
+	static AggregateFunction GetFunction();
+};
+
+struct StringAggFun {
+	static constexpr const char *Name = "string_agg";
+	static constexpr const char *Parameters = "str,arg";
+	static constexpr const char *Description = "Concatenates the column string values with an optional separator.";
+	static constexpr const char *Example = "string_agg(A, '-)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct GroupConcatFun {
+	using ALIAS = StringAggFun;
+
+	static constexpr const char *Name = "group_concat";
+};
+
+struct SumFun {
+	static constexpr const char *Name = "sum";
+	static constexpr const char *Parameters = "arg";
+	static constexpr const char *Description = "Calculates the sum value for all tuples in arg.";
+	static constexpr const char *Example = "sum(A)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct SumNoOverflowFun {
+	static constexpr const char *Name = "sum_no_overflow";
+	static constexpr const char *Parameters = "arg";
+	static constexpr const char *Description = "Calculates the sum value for all tuples in arg without overflow checks.";
+	static constexpr const char *Example = "sum_no_overflow(A)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/aggregate/holistic_functions.hpp

@@ -0,0 +1,85 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/core_functions/aggregate/holistic_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+// This file is generated by scripts/generate_functions.py
+
+#pragma once
+
+#include "duckdb/function/function_set.hpp"
+
+namespace duckdb {
+
+struct ApproxQuantileFun {
+	static constexpr const char *Name = "approx_quantile";
+	static constexpr const char *Parameters = "x,pos";
+	static constexpr const char *Description = "Computes the approximate quantile using T-Digest.";
+	static constexpr const char *Example = "approx_quantile(A,0.5)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct MadFun {
+	static constexpr const char *Name = "mad";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the median absolute deviation for the values within x. NULL values are ignored. Temporal types return a positive INTERVAL.	";
+	static constexpr const char *Example = "MEDIAN(ABS(x-MEDIAN(x)))";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct MedianFun {
+	static constexpr const char *Name = "median";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the middle value of the set. NULL values are ignored. For even value counts, quantitiative values are averaged and ordinal values return the lower value.";
+	static constexpr const char *Example = "QUANTILE_CONT(x, 0.5)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct ModeFun {
+	static constexpr const char *Name = "mode";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the most frequent value for the values within x. NULL values are ignored.";
+	static constexpr const char *Example = "";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct QuantileDiscFun {
+	static constexpr const char *Name = "quantile_disc";
+	static constexpr const char *Parameters = "x,pos";
+	static constexpr const char *Description = "Returns the exact quantile number between 0 and 1 . If pos is a LIST of FLOATs, then the result is a LIST of the corresponding exact quantiles.";
+	static constexpr const char *Example = "";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct QuantileFun {
+	using ALIAS = QuantileDiscFun;
+
+	static constexpr const char *Name = "quantile";
+};
+
+struct QuantileContFun {
+	static constexpr const char *Name = "quantile_cont";
+	static constexpr const char *Parameters = "x,pos";
+	static constexpr const char *Description = "Returns the intepolated quantile number between 0 and 1 . If pos is a LIST of FLOATs, then the result is a LIST of the corresponding intepolated quantiles.	";
+	static constexpr const char *Example = "";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct ReservoirQuantileFun {
+	static constexpr const char *Name = "reservoir_quantile";
+	static constexpr const char *Parameters = "x,quantile,sample_size";
+	static constexpr const char *Description = "Gives the approximate quantile using reservoir sampling, the sample size is optional and uses 8192 as a default size.";
+	static constexpr const char *Example = "reservoir_quantile(A,0.5,1024)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+} // namespace duckdb