Merge pull request #90 from duckdb/upgrade-111

bump to 1.1.1

Author: hannes

CMakeLists.txt

@@ -1,5 +1,4 @@
 #include "duckdb/common/extra_type_info.hpp"
-#include "duckdb/common/extra_type_info/enum_type_info.hpp"
 #include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/numeric_utils.hpp"
@@ -221,6 +220,50 @@ PhysicalType EnumTypeInfo::DictType(idx_t size) {
 	}
 }
 
+template <class T>
+struct EnumTypeInfoTemplated : public EnumTypeInfo {
+	explicit EnumTypeInfoTemplated(Vector &values_insert_order_p, idx_t size_p)
+	    : EnumTypeInfo(values_insert_order_p, size_p) {
+		D_ASSERT(values_insert_order_p.GetType().InternalType() == PhysicalType::VARCHAR);
+
+		UnifiedVectorFormat vdata;
+		values_insert_order.ToUnifiedFormat(size_p, vdata);
+
+		auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
+		for (idx_t i = 0; i < size_p; i++) {
+			auto idx = vdata.sel->get_index(i);
+			if (!vdata.validity.RowIsValid(idx)) {
+				throw InternalException("Attempted to create ENUM type with NULL value");
+			}
+			if (values.count(data[idx]) > 0) {
+				throw InvalidInputException("Attempted to create ENUM type with duplicate value %s",
+				                            data[idx].GetString());
+			}
+			values[data[idx]] = UnsafeNumericCast<T>(i);
+		}
+	}
+
+	static shared_ptr<EnumTypeInfoTemplated> Deserialize(Deserializer &deserializer, uint32_t size) {
+		Vector values_insert_order(LogicalType::VARCHAR, size);
+		auto strings = FlatVector::GetData<string_t>(values_insert_order);
+
+		deserializer.ReadList(201, "values", [&](Deserializer::List &list, idx_t i) {
+			strings[i] = StringVector::AddStringOrBlob(values_insert_order, list.ReadElement<string>());
+		});
+		return make_shared_ptr<EnumTypeInfoTemplated>(values_insert_order, size);
+	}
+
+	const string_map_t<T> &GetValues() const {
+		return values;
+	}
+
+	EnumTypeInfoTemplated(const EnumTypeInfoTemplated &) = delete;
+	EnumTypeInfoTemplated &operator=(const EnumTypeInfoTemplated &) = delete;
+
+private:
+	string_map_t<T> values;
+};
+
 EnumTypeInfo::EnumTypeInfo(Vector &values_insert_order_p, idx_t dict_size_p)
     : ExtraTypeInfo(ExtraTypeInfoType::ENUM_TYPE_INFO), values_insert_order(values_insert_order_p),
       dict_type(EnumDictType::VECTOR_DICT), dict_size(dict_size_p) {

src/duckdb/src/common/extra_type_info.cpp

@@ -52,6 +52,7 @@ static const StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION_SET(BitwiseAndFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(ListHasAnyFunAlias),
 	DUCKDB_SCALAR_FUNCTION(PowOperatorFun),
+	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ListNegativeInnerProductFunAlias),
 	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ListDistanceFunAlias),
 	DUCKDB_SCALAR_FUNCTION_SET(LeftShiftFun),
 	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ListCosineDistanceFunAlias),

src/duckdb/src/core_functions/function_list.cpp

@@ -117,6 +117,10 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	if (join_state.build_range > MAX_BUILD_SIZE) {
 		return;
 	}
+	if (NumericStats::Min(stats_build) <= NumericStats::Min(stats_probe) &&
+	    NumericStats::Max(stats_probe) <= NumericStats::Max(stats_build)) {
+		join_state.is_probe_in_domain = true;
+	}
 	join_state.is_build_small = true;
 	return;
 }

src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -1,5 +1,5 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "2-dev27"
+#define DUCKDB_PATCH_VERSION "1"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
 #define DUCKDB_MINOR_VERSION 1
@@ -8,10 +8,10 @@
 #define DUCKDB_MAJOR_VERSION 1
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v1.1.2-dev27"
+#define DUCKDB_VERSION "v1.1.1"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "12e9777cf6"
+#define DUCKDB_SOURCE_ID "af39bd0dcf"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

src/duckdb/src/function/table/version/pragma_version.cpp

@@ -41,15 +41,16 @@ class BitpackingPrimitives {
 			}
 		} else {
 			idx_t misaligned_count = count % BITPACKING_ALGORITHM_GROUP_SIZE;
+			T tmp_buffer[BITPACKING_ALGORITHM_GROUP_SIZE]; // TODO maybe faster on the heap?
+
 			count -= misaligned_count;
+
 			for (idx_t i = 0; i < count; i += BITPACKING_ALGORITHM_GROUP_SIZE) {
 				PackGroup<T>(dst + (i * width) / 8, src + i, width);
 			}
 
-			// The input is not aligned to BITPACKING_ALGORITHM_GROUP_SIZE.
-			// Copy the unaligned count into a zero-initialized temporary group, and pack it.
+			// Input was not aligned to BITPACKING_ALGORITHM_GROUP_SIZE, we need a copy
 			if (misaligned_count) {
-				T tmp_buffer[BITPACKING_ALGORITHM_GROUP_SIZE] = {0};
 				memcpy(tmp_buffer, src + count, misaligned_count * sizeof(T));
 				PackGroup<T>(dst + (count * width) / 8, tmp_buffer, width);
 			}

src/duckdb/src/include/duckdb/common/bitpacking.hpp

@@ -330,6 +330,12 @@ struct ListNegativeDotProductFun {
 	static constexpr const char *Name = "list_negative_dot_product";
 };
 
+struct ListNegativeInnerProductFunAlias {
+	using ALIAS = ListNegativeInnerProductFun;
+
+	static constexpr const char *Name = "<#>";
+};
+
 struct UnpivotListFun {
 	static constexpr const char *Name = "unpivot_list";
 	static constexpr const char *Parameters = "any,...";

src/duckdb/src/include/duckdb/core_functions/scalar/list_functions.hpp

@@ -26,6 +26,7 @@ struct PerfectHashJoinStats {
 	Value probe_max;
 	bool is_build_small = false;
 	bool is_build_dense = false;
+	bool is_probe_in_domain = false;
 	idx_t build_range = 0;
 	idx_t estimated_cardinality = 0;
 };

src/duckdb/src/include/duckdb/execution/operator/join/perfect_hash_join_executor.hpp

@@ -145,7 +145,6 @@ class SegmentTree {
 		}
 		SegmentNode<T> node;
 		segment->index = nodes.size();
-		segment->next = nullptr;
 		node.row_start = segment->start;
 		node.node = std::move(segment);
 		nodes.push_back(std::move(node));

src/duckdb/src/include/duckdb/storage/table/segment_tree.hpp

@@ -57,7 +57,7 @@ DynamicTableFilterSet::GetFinalTableFilters(const PhysicalTableScan &scan,
 	auto result = make_uniq<TableFilterSet>();
 	if (existing_filters) {
 		for (auto &entry : existing_filters->filters) {
-			result->PushFilter(entry.first, entry.second->Copy());
+			result->filters[entry.first] = entry.second->Copy();
 		}
 	}
 	for (auto &entry : filters) {
@@ -66,7 +66,7 @@ DynamicTableFilterSet::GetFinalTableFilters(const PhysicalTableScan &scan,
 				// skip row id filters
 				continue;
 			}
-			result->PushFilter(filter.first, filter.second->Copy());
+			result->filters[filter.first] = filter.second->Copy();
 		}
 	}
 	if (result->filters.empty()) {