duckdb 1.5.5.dev3__tar.gz → 1.5.5.dev13__tar.gz

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: duckdb
-Version: 1.5.5.dev3
+Version: 1.5.5.dev13
 Summary: DuckDB in-process database
 Keywords: DuckDB,Database,SQL,OLAP
 Author: DuckDB Foundation

duckdb-1.5.5.dev13/duckdb_packaging/duckdb_version.txt

@@ -0,0 +1 @@
+v1.5.4-92-gfda2906db5

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/extension/json/json_common.cpp

@@ -134,14 +134,14 @@ static inline idx_t ReadInteger(const char *ptr, const char *const end, idx_t &i
 static inline JSONKeyReadResult ReadKey(const char *ptr, const char *const end) {
 	D_ASSERT(ptr != end);
 	if (*ptr == '*') { // Wildcard
-		if (*(ptr + 1) == '*') {
+		if (ptr + 1 != end && *(ptr + 1) == '*') {
 			return JSONKeyReadResult::RecWildCard();
 		}
 		return JSONKeyReadResult::WildCard();
 	}
 	bool recursive = false;
 	if (*ptr == '.') {
-		char next = *(ptr + 1);
+		const char next = ptr + 1 == end ? '\0' : *(ptr + 1);
 		if (next == '*') {
 			return JSONKeyReadResult::RecWildCard();
 		}
@@ -151,6 +151,10 @@ static inline JSONKeyReadResult ReadKey(const char *ptr, const char *const end)
 		ptr++;
 		recursive = true;
 	}
+	if (ptr == end) {
+		// recursive '.' with no key following it
+		return JSONKeyReadResult::Empty();
+	}
 	bool escaped = false;
 	if (*ptr == '"') {
 		ptr++; // Skip past opening '"'

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/src/catalog/catalog_set.cpp

@@ -342,6 +342,8 @@ bool CatalogSet::AlterEntry(CatalogTransaction transaction, const string &name,
 	// Mark this entry as being created by this transaction
 	value->timestamp = transaction.transaction_id;
 	value->set = this;
+	// Preserve the oid across the alter: an altered entry is the same logical object as before
+	value->oid = entry->oid;
 
 	if (!StringUtil::CIEquals(value->name, entry->name)) {
 		if (!RenameEntryInternal(transaction, *entry, value->name, alter_info, read_lock)) {
@@ -443,7 +445,7 @@ void CatalogSet::VerifyExistenceOfDependency(transaction_t commit_id, CatalogEnt
 	// Make sure that we don't see any uncommitted changes
 	auto transaction_id = MAX_TRANSACTION_ID;
 	// This will allow us to see all committed changes made before this COMMIT happened
-	auto tx_start_time = commit_id;
+	auto tx_start_time = commit_id + 1;
 	CatalogTransaction commit_transaction(duck_catalog.GetDatabase(), transaction_id, tx_start_time);
 
 	D_ASSERT(entry.type == CatalogType::DEPENDENCY_ENTRY);

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/src/catalog/dependency_manager.cpp

@@ -220,6 +220,9 @@ void DependencyManager::CreateDependent(CatalogTransaction transaction, const De
 }
 
 void DependencyManager::CreateDependency(CatalogTransaction transaction, DependencyInfo &info) {
+	auto subject_entry = LookupEntry(transaction, info.subject.entry);
+	info.subject.oid = subject_entry ? subject_entry->oid : optional_idx();
+
 	DependencyCatalogSet subjects(Subjects(), info.dependent.entry);
 	DependencyCatalogSet dependents(Dependents(), info.subject.entry);
 
@@ -315,12 +318,8 @@ CatalogEntryInfo DependencyManager::GetLookupProperties(const CatalogEntry &entr
 	}
 }
 
-optional_ptr<CatalogEntry> DependencyManager::LookupEntry(CatalogTransaction transaction, CatalogEntry &dependency) {
-	if (dependency.type != CatalogType::DEPENDENCY_ENTRY) {
-		return &dependency;
-	}
-	auto info = GetLookupProperties(dependency);
-
+optional_ptr<CatalogEntry> DependencyManager::LookupEntry(CatalogTransaction transaction,
+                                                          const CatalogEntryInfo &info) {
 	auto &type = info.type;
 	auto &schema = info.schema;
 	auto &name = info.name;
@@ -331,8 +330,14 @@ optional_ptr<CatalogEntry> DependencyManager::LookupEntry(CatalogTransaction tra
 		// This is a schema entry, perform the callback only providing the schema
 		return reinterpret_cast<CatalogEntry *>(schema_entry.get());
 	}
-	auto entry = schema_entry->GetEntry(transaction, type, name);
-	return entry;
+	return schema_entry->GetEntry(transaction, type, name);
+}
+
+optional_ptr<CatalogEntry> DependencyManager::LookupEntry(CatalogTransaction transaction, CatalogEntry &dependency) {
+	if (dependency.type != CatalogType::DEPENDENCY_ENTRY) {
+		return &dependency;
+	}
+	return LookupEntry(transaction, GetLookupProperties(dependency));
 }
 
 void DependencyManager::CleanupDependencies(CatalogTransaction transaction, CatalogEntry &object) {
@@ -468,6 +473,13 @@ void DependencyManager::VerifyExistence(CatalogTransaction transaction, Dependen
 		throw DependencyException("Could not commit creation of dependency, subject \"%s\" has been deleted",
 		                          object.SourceInfo().name);
 	}
+	// The subject still exists by name - check if it is the same object the dependency was created against
+	if (!subject.flags.IsOwnership() && subject.oid.IsValid() && lookup_result.result &&
+	    lookup_result.result->oid != subject.oid.GetIndex()) {
+		throw DependencyException(
+		    "Could not commit creation of dependency, subject \"%s\" was dropped and re-created by another transaction",
+		    object.EntryInfo().name);
+	}
 }
 
 void DependencyManager::VerifyCommitDrop(CatalogTransaction transaction, transaction_t start_time,

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/src/common/multi_file/multi_file_column_mapper.cpp

@@ -342,6 +342,18 @@ MapColumnMapComponent(ClientContext &context,
 	return child_map;
 }
 
+static bool IsInvalidMapKeyDefault(const ColumnMapResult &mapping) {
+	if (!mapping.default_value) {
+		return false;
+	}
+	auto &expr = *mapping.default_value;
+	if (expr.GetExpressionClass() != ExpressionClass::BOUND_CONSTANT) {
+		return false;
+	}
+	auto &constant_expr = expr.Cast<BoundConstantExpression>();
+	return constant_expr.value.IsNull();
+}
+
 ColumnMapResult MapColumnMap(ClientContext &context, const MultiFileColumnDefinition &global_column,
                              const ColumnIndex &global_index, const MultiFileColumnDefinition &local_column,
                              const MultiFileLocalColumnId &local_id, const ColumnMapper &mapper,
@@ -382,6 +394,11 @@ ColumnMapResult MapColumnMap(ClientContext &context, const MultiFileColumnDefini
 
 		auto map_result = MapColumnMapComponent(context, selected_children, global_index, *nested_mapper, i,
 		                                        global_component, local_key_value);
+		if (name == "key" && IsInvalidMapKeyDefault(map_result)) {
+			throw InvalidInputException(
+			    "'key' of MAP did not map to a value and the registered DEFAULT is NULL, which is not allowed");
+		}
+
 		if (map_result.column_index) {
 			child_indexes.push_back(std::move(*map_result.column_index));
 			mapping->child_mapping.insert(make_pair(i, std::move(map_result.mapping)));

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/src/function/cast/vector_cast_helpers.cpp

@@ -460,6 +460,9 @@ bool VectorStringToStruct::SplitStruct(const string_t &input, vector<unique_ptr<
 	auto end_char = buf[pos] == '{' ? '}' : ')';
 	pos++;
 	SkipWhitespace(input_state);
+	if (pos == len) {
+		return false;
+	}
 	if (buf[pos] == end_char) {
 		pos++;
 		SkipWhitespace(input_state);

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/src/include/duckdb/catalog/dependency_manager.hpp

@@ -29,6 +29,8 @@ struct DependencySubject {
 	CatalogEntryInfo entry;
 	//! The type of dependency this is (e.g, ownership)
 	DependencySubjectFlags flags;
+	//! The oid of the subject entry when the dependency was created
+	optional_idx oid;
 };
 
 // The entry that relies on the other entry
@@ -104,6 +106,7 @@ private:
 	bool IsSystemEntry(CatalogEntry &entry) const;
 	optional_ptr<CatalogEntry> LookupEntry(CatalogTransaction transaction, const LogicalDependency &dependency);
 	optional_ptr<CatalogEntry> LookupEntry(CatalogTransaction transaction, CatalogEntry &dependency);
+	optional_ptr<CatalogEntry> LookupEntry(CatalogTransaction transaction, const CatalogEntryInfo &info);
 	string CollectDependents(CatalogTransaction transaction, catalog_entry_set_t &entries, CatalogEntryInfo &info);
 	void CleanupDependencies(CatalogTransaction transaction, CatalogEntry &entry);
 

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/src/include/duckdb/storage/compression/dict_fsst/analyze.hpp

@@ -21,6 +21,12 @@ public:
 public:
 	idx_t max_string_length = 0;
 	bool contains_nulls = false;
+	//! Effective exclusive size limit for plain dictionary encoding.
+	idx_t string_size_limit = 0;
+	//! Effective exclusive input size limit for worst-case FSST encoding.
+	idx_t fsst_string_size_limit = 0;
+	//! Flag which disables the usage of FSST if worst-case encoding blowup does not fit the block size.
+	bool disable_fsst = false;
 	idx_t total_string_length = 0;
 	idx_t total_count = 0;
 };

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/src/include/duckdb/storage/compression/dict_fsst/common.hpp

@@ -1,9 +1,9 @@
 #pragma once
 
 #include "duckdb/common/typedefs.hpp"
-#include "duckdb/function/compression_function.hpp"
 #include "duckdb/common/bitpacking.hpp"
 #include "duckdb/storage/string_uncompressed.hpp"
+#include "fsst.h"
 
 namespace duckdb {
 
@@ -35,6 +35,7 @@ enum class DictionaryAppendState : uint8_t {
 
 struct DictFSSTCompression {
 public:
+	static constexpr uint16_t FSST_SYMBOL_TABLE_SIZE = sizeof(duckdb_fsst_decoder_t);
 	//! Dictionary header size at the beginning of the string segment (offset + length)
 	static constexpr uint16_t DICTIONARY_HEADER_SIZE = sizeof(dict_fsst_compression_header_t);
 	static constexpr idx_t STRING_SIZE_LIMIT = 16384;

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/src/optimizer/common_aggregate_optimizer.cpp

@@ -18,7 +18,6 @@ void CommonAggregateOptimizer::VisitOperator(LogicalOperator &op) {
 	case LogicalOperatorType::LOGICAL_UNION:
 	case LogicalOperatorType::LOGICAL_EXCEPT:
 	case LogicalOperatorType::LOGICAL_INTERSECT:
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
 	case LogicalOperatorType::LOGICAL_PROJECTION: {
 		CommonAggregateOptimizer common_aggregate;
 		common_aggregate.StandardVisitOperator(op);

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/src/planner/binder/expression/bind_operator_expression.cpp

@@ -105,6 +105,8 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		D_ASSERT(op.children.size() == 1);
 		//! This binder is used to throw when the child expression is of a type that is not allowed.
 		TryOperatorBinder try_operator_binder(binder, context);
+		//! Propagate any lambda parameter bindings so lambda parameters can be referenced inside TRY(...)
+		try_operator_binder.lambda_bindings = lambda_bindings;
 		try_operator_binder.BindChild(op.children[0], depth, error);
 	} else {
 		for (idx_t i = 0; i < op.children.size(); i++) {

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/src/storage/caching_file_system.cpp

@@ -130,7 +130,10 @@ FileHandle &CachingFileHandle::GetFileHandle() {
 
 BufferHandle CachingFileHandle::Read(data_ptr_t &buffer, const idx_t nr_bytes, const idx_t location) {
 	BufferHandle result;
-	if (!external_file_cache.IsEnabled()) {
+	// Only cache when file metadata is available.
+	const bool no_validation_metadata =
+	    Validate() && version_tag.empty() && (!Timestamp::IsFinite(last_modified) || last_modified == timestamp_t(0));
+	if (!external_file_cache.IsEnabled() || no_validation_metadata) {
 		result = external_file_cache.GetBufferManager().Allocate(MemoryTag::EXTERNAL_FILE_CACHE, nr_bytes);
 		buffer = result.Ptr();
 		GetFileHandle().Read(context, buffer, nr_bytes, location);
@@ -181,9 +184,13 @@ BufferHandle CachingFileHandle::Read(data_ptr_t &buffer, const idx_t nr_bytes, c
 BufferHandle CachingFileHandle::Read(data_ptr_t &buffer, idx_t &nr_bytes) {
 	BufferHandle result;
 
+	// Only cache when file metadata is available.
+	const bool no_validation_metadata =
+	    Validate() && version_tag.empty() && (!Timestamp::IsFinite(last_modified) || last_modified == timestamp_t(0));
+
 	// If we can't seek, we can't use the cache for these calls,
 	// because we won't be able to seek over any parts we skipped by reading from the cache
-	if (!external_file_cache.IsEnabled() || !CanSeek()) {
+	if (!external_file_cache.IsEnabled() || !CanSeek() || no_validation_metadata) {
 		result = external_file_cache.GetBufferManager().Allocate(MemoryTag::EXTERNAL_FILE_CACHE, nr_bytes);
 		buffer = result.Ptr();
 		nr_bytes = NumericCast<idx_t>(GetFileHandle().Read(context, buffer, nr_bytes));

duckdb-1.5.5.dev13/external/duckdb/src/storage/compression/dict_fsst/analyze.cpp

@@ -0,0 +1,90 @@
+#include "duckdb/storage/compression/dict_fsst/analyze.hpp"
+
+namespace duckdb {
+namespace dict_fsst {
+
+//! Determine the size requirements for the worst case, which is when a single string fills an
+//! entire segment on its own.
+static idx_t GetStringSizeLimit(const idx_t available_space, const bool fsst_encoded) {
+	idx_t max_str_len = DictFSSTCompression::STRING_SIZE_LIMIT - 1;
+	if (fsst_encoded) {
+		// In the worst case FSST may double the string length by prepending every byte with an exception
+		max_str_len *= 2;
+	}
+
+	// Dictionary contains NULL and current string
+	const bitpacking_width_t string_lengths_width = BitpackingPrimitives::MinimumBitWidth(max_str_len);
+	const idx_t string_lengths_space = BitpackingPrimitives::GetRequiredSize(2, string_lengths_width);
+
+	// Dictionary stores only one valid string
+	const bitpacking_width_t dict_indices_width = BitpackingPrimitives::MinimumBitWidth(1);
+	const idx_t dict_indices_space = BitpackingPrimitives::GetRequiredSize(1, dict_indices_width);
+
+	idx_t metadata_size = 0;
+	metadata_size += AlignValue<idx_t>(sizeof(dict_fsst_compression_header_t));
+	if (fsst_encoded) {
+		// As denoted in fsst.h
+		metadata_size += 7;
+	}
+	// Reserve maximum alignment padding for variable length string
+	metadata_size += sizeof(idx_t) - 1;
+	if (fsst_encoded) {
+		metadata_size += AlignValue<idx_t>(DictFSSTCompression::FSST_SYMBOL_TABLE_SIZE);
+	}
+	metadata_size += AlignValue<idx_t>(string_lengths_space);
+	metadata_size += dict_indices_space;
+
+	D_ASSERT(metadata_size < available_space);
+	idx_t max_string_size = available_space - metadata_size;
+
+	if (fsst_encoded) {
+		max_string_size = max_string_size / 2;
+	}
+
+	return MinValue(DictFSSTCompression::STRING_SIZE_LIMIT, max_string_size + 1);
+}
+
+DictFSSTAnalyzeState::DictFSSTAnalyzeState(const CompressionInfo &info) : AnalyzeState(info) {
+	const auto block_size = info.GetBlockSize();
+
+	string_size_limit = GetStringSizeLimit(block_size, false);
+	fsst_string_size_limit = GetStringSizeLimit(block_size, true);
+}
+
+bool DictFSSTAnalyzeState::Analyze(Vector &input, idx_t count) {
+	UnifiedVectorFormat vector_format;
+	input.ToUnifiedFormat(count, vector_format);
+	const auto strings = vector_format.GetData<string_t>(vector_format);
+
+	for (idx_t i = 0; i < count; i++) {
+		const auto idx = vector_format.sel->get_index(i);
+		if (!vector_format.validity.RowIsValid(idx)) {
+			contains_nulls = true;
+		} else {
+			const auto &str = strings[idx];
+			const auto str_len = str.GetSize();
+			total_string_length += str_len;
+			if (str_len > max_string_length) {
+				max_string_length = str_len;
+			}
+			if (str_len >= string_size_limit) {
+				// A segment cannot be spread out over multiple blocks, so if a string cannot fit in an empty segment
+				// the encoding will fail
+				return false;
+			}
+			if (str_len >= fsst_string_size_limit) {
+				// FSST strings may be up to two times larger than their plain equivalent
+				disable_fsst = true;
+			}
+		}
+	}
+	total_count += count;
+	return true;
+}
+
+idx_t DictFSSTAnalyzeState::FinalAnalyze() {
+	return LossyNumericCast<idx_t>((double)total_string_length / 2.0);
+}
+
+} // namespace dict_fsst
+} // namespace duckdb

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/src/storage/compression/dict_fsst/compression.cpp

@@ -30,7 +30,6 @@ DictFSSTCompressionState::~DictFSSTCompressionState() {
 	}
 }
 
-static constexpr uint16_t FSST_SYMBOL_TABLE_SIZE = sizeof(duckdb_fsst_decoder_t);
 static constexpr idx_t DICTIONARY_ENCODE_THRESHOLD = 4096;
 
 static inline bool IsEncoded(DictionaryAppendState state) {
@@ -53,6 +52,9 @@ static DictFSSTMode ConvertToMode(DictionaryAppendState &state) {
 
 idx_t DictFSSTCompressionState::Finalize() {
 	const bool is_fsst_encoded = IsEncoded(append_state);
+	if (is_fsst_encoded) {
+		D_ASSERT(analyze->disable_fsst == false);
+	}
 
 // calculate sizes
 #ifdef DEBUG
@@ -248,7 +250,8 @@ void DictFSSTCompressionState::CreateEmptySegment() {
 	auto &buffer_manager = BufferManager::GetBufferManager(checkpoint_data.GetDatabase());
 	current_handle = buffer_manager.Pin(current_segment->block);
 
-	append_state = DictionaryAppendState::REGULAR;
+	// If analysis determined that FSST cannot be used, skip the decision phase.
+	append_state = analyze->disable_fsst ? DictionaryAppendState::NOT_ENCODED : DictionaryAppendState::REGULAR;
 	string_lengths_width = 0;
 	real_string_lengths_width = 0;
 	dictionary_indices_width = 0;
@@ -338,7 +341,7 @@ static inline bool AddLookup(DictFSSTCompressionState &state, idx_t lookup, cons
 
 	idx_t available_space = state.info.GetBlockSize();
 	if (APPEND_STATE == DictionaryAppendState::REGULAR) {
-		available_space -= FSST_SYMBOL_TABLE_SIZE;
+		available_space -= DictFSSTCompression::FSST_SYMBOL_TABLE_SIZE;
 	}
 	if (required_space > available_space) {
 		if (fail_on_no_space) {
@@ -421,7 +424,7 @@ static inline bool AddToDictionary(DictFSSTCompressionState &state, const string
 
 	idx_t available_space = state.info.GetBlockSize();
 	if (APPEND_STATE == DictionaryAppendState::REGULAR) {
-		available_space -= FSST_SYMBOL_TABLE_SIZE;
+		available_space -= DictFSSTCompression::FSST_SYMBOL_TABLE_SIZE;
 	}
 	if (required_space > available_space) {
 		if (fail_on_no_space) {

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/src/storage/compression/dict_fsst.cpp

@@ -232,6 +232,34 @@ static void DictFSSTFilter(ColumnSegment &segment, ColumnScanState &state, idx_t
 	ColumnSegment::FilterSelection(sel, result, vdata, filter, filter_state, vector_count, sel_count);
 }
 
+static string DictFSSTModeToString(const DictFSSTMode mode) {
+	switch (mode) {
+	case DictFSSTMode::DICTIONARY:
+		return "DICTIONARY";
+	case DictFSSTMode::DICT_FSST:
+		return "DICT_FSST";
+	case DictFSSTMode::FSST_ONLY:
+		return "FSST_ONLY";
+	default:
+		return "UNKNOWN";
+	}
+}
+
+//===--------------------------------------------------------------------===//
+// GetSegmentInfo
+//===--------------------------------------------------------------------===//
+static InsertionOrderPreservingMap<string> DictFSSTGetSegmentInfo(QueryContext, ColumnSegment &segment) {
+	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
+	auto state = make_uniq<CompressedStringScanState>(segment, buffer_manager.Pin(segment.block));
+	state->Initialize(false);
+
+	const auto tuple_count = segment.count.load();
+
+	InsertionOrderPreservingMap<string> result;
+	result[DictFSSTModeToString(state->mode)] = StringUtil::Format("%d", tuple_count);
+	return result;
+}
+
 } // namespace dict_fsst
 
 //===--------------------------------------------------------------------===//
@@ -250,6 +278,8 @@ CompressionFunction DictFSSTCompressionFun::GetFunction(PhysicalType data_type)
 	res.validity = CompressionValidity::NO_VALIDITY_REQUIRED;
 	res.select = dict_fsst::DictFSSTSelect;
 	res.filter = dict_fsst::DictFSSTFilter;
+	res.get_segment_info = dict_fsst::DictFSSTGetSegmentInfo;
+
 	return res;
 }
 

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/external/duckdb/src/storage/compression/rle.cpp

@@ -268,15 +268,18 @@ struct RLEScanState : public SegmentScanState {
 	                    static_cast<idx_t>(sizeof(rle_count_t))) {
 		if (rle_count_offset < RLEConstants::RLE_HEADER_SIZE) {
 			//! This would make the index_pointer point into a region reserved for the header data
-			throw IOException("Corrupted RLE segment: rle_count_offset is corrupted");
+			throw IOException("Corrupted RLE segment: rle_count_offset is smaller than the header size. The "
+			                  "index_pointer would point into the region reserved for the header data");
 		}
 		if (segment.GetBlockOffset() + rle_count_offset > segment.GetBlockSize()) {
 			//! This would make the index_pointer start outside of the segment
-			throw IOException("Corrupted RLE segment: rle_count_offset is corrupted");
+			throw IOException("Corrupted RLE segment: rle_count_offset exceeds the block size. The index_pointer would "
+			                  "start outside of the segment");
 		}
-		if ((rle_count_offset - RLEConstants::RLE_HEADER_SIZE) / sizeof(T) > max_entry_pos) {
+		if (rle_count_offset > AlignValue(RLEConstants::RLE_HEADER_SIZE + max_entry_pos * sizeof(T))) {
 			//! This would make the indexing of the index_pointer[entry_pos] reach outside of the segment
-			throw IOException("Corrupted RLE segment: rle_count_offset is corrupted");
+			throw IOException("Corrupted RLE segment: rle_count_offset has more values than fit in the segment. "
+			                  "index_pointer[entry_pos] would reach outside of the segment");
 		}
 	}
 

{duckdb-1.5.5.dev3 → duckdb-1.5.5.dev13}/pyproject.toml

@@ -333,7 +333,7 @@ packages = ["duckdb", "_duckdb"]
 strict = true
 warn_unreachable = true
 pretty = true
-python_version = "3.10"
+python_version = "3.12"
 exclude = [
     "duckdb/experimental/", # not checking the pyspark API
     "duckdb/query_graph/",  # old and unmaintained (should probably remove)

duckdb-1.5.5.dev3/duckdb_packaging/duckdb_version.txt

@@ -1 +0,0 @@
-v1.5.4-53-g4abd06ce01

duckdb-1.5.5.dev3/external/duckdb/src/storage/compression/dict_fsst/analyze.cpp

@@ -1,40 +0,0 @@
-#include "duckdb/storage/compression/dict_fsst/analyze.hpp"
-
-namespace duckdb {
-namespace dict_fsst {
-
-DictFSSTAnalyzeState::DictFSSTAnalyzeState(const CompressionInfo &info) : AnalyzeState(info) {
-}
-
-bool DictFSSTAnalyzeState::Analyze(Vector &input, idx_t count) {
-	UnifiedVectorFormat vector_format;
-	input.ToUnifiedFormat(count, vector_format);
-	auto strings = vector_format.GetData<string_t>(vector_format);
-
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vector_format.sel->get_index(i);
-		if (!vector_format.validity.RowIsValid(i)) {
-			contains_nulls = true;
-		} else {
-			auto &str = strings[idx];
-			auto str_len = str.GetSize();
-			total_string_length += str_len;
-			if (str_len > max_string_length) {
-				max_string_length = str_len;
-			}
-			if (str_len >= DictFSSTCompression::STRING_SIZE_LIMIT) {
-				//! This string is too long, we don't want to use DICT_FSST for this rowgroup
-				return false;
-			}
-		}
-	}
-	total_count += count;
-	return true;
-}
-
-idx_t DictFSSTAnalyzeState::FinalAnalyze() {
-	return LossyNumericCast<idx_t>((double)total_string_length / 2.0);
-}
-
-} // namespace dict_fsst
-} // namespace duckdb