duckdb 0.8.2-dev87.0 → 0.9.0

package/src/duckdb/src/include/duckdb/execution/operator/persistent/buffered_csv_reader.hpp

@@ -1,133 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/base_csv_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/operator/persistent/base_csv_reader.hpp"
-
-namespace duckdb {
-struct CopyInfo;
-struct CSVFileHandle;
-struct FileHandle;
-struct StrpTimeFormat;
-
-class FileOpener;
-class FileSystem;
-
-//! The shifts array allows for linear searching of multi-byte values. For each position, it determines the next
-//! position given that we encounter a byte with the given value.
-/*! For example, if we have a string "ABAC", the shifts array will have the following values:
- *  [0] --> ['A'] = 1, all others = 0
- *  [1] --> ['B'] = 2, ['A'] = 1, all others = 0
- *  [2] --> ['A'] = 3, all others = 0
- *  [3] --> ['C'] = 4 (match), 'B' = 2, 'A' = 1, all others = 0
- * Suppose we then search in the following string "ABABAC", our progression will be as follows:
- * 'A' -> [1], 'B' -> [2], 'A' -> [3], 'B' -> [2], 'A' -> [3], 'C' -> [4] (match!)
- */
-struct TextSearchShiftArray {
-	TextSearchShiftArray();
-	explicit TextSearchShiftArray(string search_term);
-
-	inline bool Match(uint8_t &position, uint8_t byte_value) {
-		if (position >= length) {
-			return false;
-		}
-		position = shifts[position * 255 + byte_value];
-		return position == length;
-	}
-
-	idx_t length;
-	unique_ptr<uint8_t[]> shifts;
-};
-
-//! Buffered CSV reader is a class that reads values from a stream and parses them as a CSV file
-class BufferedCSVReader : public BaseCSVReader {
-	//! Initial buffer read size; can be extended for long lines
-	static constexpr idx_t INITIAL_BUFFER_SIZE = 16384;
-	//! Larger buffer size for non disk files
-	static constexpr idx_t INITIAL_BUFFER_SIZE_LARGE = 10000000; // 10MB
-
-public:
-	BufferedCSVReader(ClientContext &context, BufferedCSVReaderOptions options,
-	                  const vector<LogicalType> &requested_types = vector<LogicalType>());
-	BufferedCSVReader(ClientContext &context, string filename, BufferedCSVReaderOptions options,
-	                  const vector<LogicalType> &requested_types = vector<LogicalType>());
-	virtual ~BufferedCSVReader() {
-	}
-
-	unsafe_unique_array<char> buffer;
-	idx_t buffer_size;
-	idx_t position;
-	idx_t start = 0;
-
-	vector<unsafe_unique_array<char>> cached_buffers;
-
-	unique_ptr<CSVFileHandle> file_handle;
-
-	TextSearchShiftArray delimiter_search, escape_search, quote_search;
-
-public:
-	//! Extract a single DataChunk from the CSV file and stores it in insert_chunk
-	void ParseCSV(DataChunk &insert_chunk);
-	static string ColumnTypesError(case_insensitive_map_t<idx_t> sql_types_per_column, const vector<string> &names);
-
-private:
-	//! Initialize Parser
-	void Initialize(const vector<LogicalType> &requested_types);
-	//! Skips skip_rows, reads header row from input stream
-	void SkipRowsAndReadHeader(idx_t skip_rows, bool skip_header);
-	//! Jumps back to the beginning of input stream and resets necessary internal states
-	void JumpToBeginning(idx_t skip_rows, bool skip_header);
-	//! Resets the buffer
-	void ResetBuffer();
-	//! Resets the steam
-	void ResetStream();
-	//! Reads a new buffer from the CSV file if the current one has been exhausted
-	bool ReadBuffer(idx_t &start, idx_t &line_start);
-	//! Jumps back to the beginning of input stream and resets necessary internal states
-	bool JumpToNextSample();
-	//! Initializes the TextSearchShiftArrays for complex parser
-	void PrepareComplexParser();
-	//! Try to parse a single datachunk from the file. Throws an exception if anything goes wrong.
-	void ParseCSV(ParserMode mode);
-	//! Try to parse a single datachunk from the file. Returns whether or not the parsing is successful
-	bool TryParseCSV(ParserMode mode);
-	//! Extract a single DataChunk from the CSV file and stores it in insert_chunk
-	bool TryParseCSV(ParserMode mode, DataChunk &insert_chunk, string &error_message);
-
-	//! Parses a CSV file with a one-byte delimiter, escape and quote character
-	bool TryParseSimpleCSV(DataChunk &insert_chunk, string &error_message);
-	//! Parses more complex CSV files with multi-byte delimiters, escapes or quotes
-	bool TryParseComplexCSV(DataChunk &insert_chunk, string &error_message);
-	//! Sniffs CSV dialect and determines skip rows, header row, column types and column names
-	vector<LogicalType> SniffCSV(const vector<LogicalType> &requested_types);
-
-	//! First phase of auto detection: detect CSV dialect (i.e. delimiter, quote rules, etc)
-	void DetectDialect(const vector<LogicalType> &requested_types, BufferedCSVReaderOptions &original_options,
-	                   vector<BufferedCSVReaderOptions> &info_candidates, idx_t &best_num_cols);
-	//! Second phase of auto detection: detect candidate types for each column
-	void DetectCandidateTypes(const vector<LogicalType> &type_candidates,
-	                          const map<LogicalTypeId, vector<const char *>> &format_template_candidates,
-	                          const vector<BufferedCSVReaderOptions> &info_candidates,
-	                          BufferedCSVReaderOptions &original_options, idx_t best_num_cols,
-	                          vector<vector<LogicalType>> &best_sql_types_candidates,
-	                          std::map<LogicalTypeId, vector<string>> &best_format_candidates,
-	                          DataChunk &best_header_row);
-	//! Third phase of auto detection: detect header of CSV file
-	void DetectHeader(const vector<vector<LogicalType>> &best_sql_types_candidates, const DataChunk &best_header_row);
-	//! Fourth phase of auto detection: refine the types of each column and select which types to use for each column
-	vector<LogicalType> RefineTypeDetection(const vector<LogicalType> &type_candidates,
-	                                        const vector<LogicalType> &requested_types,
-	                                        vector<vector<LogicalType>> &best_sql_types_candidates,
-	                                        map<LogicalTypeId, vector<string>> &best_format_candidates);
-
-	//! Skip Empty lines for tables with over one column
-	void SkipEmptyLines();
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_buffer.hpp

@@ -1,74 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/operator/persistent/csv_buffer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-#include "duckdb/execution/operator/persistent/csv_file_handle.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-
-namespace duckdb {
-
-class CSVBuffer {
-public:
-	//! Colossal buffer size for multi-threading
-	static constexpr idx_t INITIAL_BUFFER_SIZE_COLOSSAL = 32000000; // 32MB
-
-	//! Constructor for Initial Buffer
-	CSVBuffer(ClientContext &context, idx_t buffer_size_p, CSVFileHandle &file_handle,
-	          idx_t &global_csv_current_position, idx_t file_number);
-
-	//! Constructor for `Next()` Buffers
-	CSVBuffer(ClientContext &context, BufferHandle handle, idx_t buffer_size_p, idx_t actual_size_p, bool final_buffer,
-	          idx_t global_csv_current_position, idx_t file_number);
-
-	//! Creates a new buffer with the next part of the CSV File
-	unique_ptr<CSVBuffer> Next(CSVFileHandle &file_handle, idx_t buffer_size, idx_t &global_csv_current_position,
-	                           idx_t file_number);
-
-	//! Gets the buffer actual size
-	idx_t GetBufferSize();
-
-	//! Gets the start position of the buffer, only relevant for the first time it's scanned
-	idx_t GetStart();
-
-	//! If this buffer is the last buffer of the CSV File
-	bool IsCSVFileLastBuffer();
-
-	//! If this buffer is the first buffer of the CSV File
-	bool IsCSVFileFirstBuffer();
-
-	idx_t GetCSVGlobalStart();
-
-	idx_t GetFileNumber();
-
-	BufferHandle AllocateBuffer(idx_t buffer_size);
-
-	char *Ptr() {
-		return char_ptr_cast(handle.Ptr());
-	}
-
-private:
-	ClientContext &context;
-
-	BufferHandle handle;
-	//! Actual size can be smaller than the buffer size in case we allocate it too optimistically.
-	idx_t actual_size;
-	//! We need to check for Byte Order Mark, to define the start position of this buffer
-	//! https://en.wikipedia.org/wiki/Byte_order_mark#UTF-8
-	idx_t start_position = 0;
-	//! If this is the last buffer of the CSV File
-	bool last_buffer = false;
-	//! If this is the first buffer of the CSV File
-	bool first_buffer = false;
-	//! Global position from the CSV File where this buffer starts
-	idx_t global_csv_start = 0;
-	//! Number of the file that is in this buffer
-	idx_t file_number = 0;
-};
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/partitionable_hashtable.hpp

@@ -1,69 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/partitionable_hashtable.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/execution/aggregate_hashtable.hpp"
-
-namespace duckdb {
-
-struct RadixPartitionInfo {
-	explicit RadixPartitionInfo(idx_t n_partitions_upper_bound);
-	const idx_t n_partitions;
-	const idx_t radix_bits;
-	const hash_t radix_mask;
-	const idx_t radix_shift;
-
-	inline hash_t GetHashPartition(hash_t hash) const {
-		return (hash & radix_mask) >> radix_shift;
-	}
-};
-
-typedef vector<unique_ptr<GroupedAggregateHashTable>> HashTableList; // NOLINT
-
-class PartitionableHashTable {
-public:
-	PartitionableHashTable(ClientContext &context, Allocator &allocator, RadixPartitionInfo &partition_info_p,
-	                       vector<LogicalType> group_types_p, vector<LogicalType> payload_types_p,
-	                       vector<BoundAggregateExpression *> bindings_p);
-
-	idx_t AddChunk(DataChunk &groups, DataChunk &payload, bool do_partition, const unsafe_vector<idx_t> &filter);
-	void Partition();
-	bool IsPartitioned();
-
-	HashTableList GetPartition(idx_t partition);
-	HashTableList GetUnpartitioned();
-
-	void Finalize();
-
-private:
-	ClientContext &context;
-	Allocator &allocator;
-	vector<LogicalType> group_types;
-	vector<LogicalType> payload_types;
-	vector<BoundAggregateExpression *> bindings;
-
-	bool is_partitioned;
-	RadixPartitionInfo &partition_info;
-	vector<SelectionVector> sel_vectors;
-	unsafe_vector<idx_t> sel_vector_sizes;
-	DataChunk group_subset, payload_subset;
-	Vector hashes, hashes_subset;
-	AggregateHTAppendState append_state;
-
-	HashTableList unpartitioned_hts;
-	vector<HashTableList> radix_partitioned_hts;
-	idx_t tuple_size;
-
-private:
-	idx_t ListAddChunk(HashTableList &list, DataChunk &groups, Vector &group_hashes, DataChunk &payload,
-	                   const unsafe_vector<idx_t> &filter);
-	//! Returns the HT entry size used for intermediate hash tables
-	HtEntryType GetHTEntrySize();
-};
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_asof_join.hpp

@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_asof_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-
-namespace duckdb {
-
-//! LogicalAsOfJoin represents a temporal-style join with one less-than inequality.
-//! This inequality matches the greatest value on the right that satisfies the condition.
-class LogicalAsOfJoin : public LogicalComparisonJoin {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_ASOF_JOIN;
-
-public:
-	explicit LogicalAsOfJoin(JoinType type);
-
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_delim_join.hpp

@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_delim_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-
-namespace duckdb {
-
-//! LogicalDelimJoin represents a special "duplicate eliminated" join. This join type is only used for subquery
-//! flattening, and involves performing duplicate elimination on the LEFT side which is then pushed into the RIGHT side.
-class LogicalDelimJoin : public LogicalComparisonJoin {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DELIM_JOIN;
-
-public:
-	explicit LogicalDelimJoin(JoinType type);
-
-	//! The set of columns that will be duplicate eliminated from the LHS and pushed into the RHS
-	vector<unique_ptr<Expression>> duplicate_eliminated_columns;
-
-public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/plan_serialization.hpp

@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/plan_serialization.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/logical_operator_type.hpp"
-#include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/planner/bound_parameter_map.hpp"
-
-namespace duckdb {
-class ClientContext;
-class LogicalOperator;
-struct BoundParameterData;
-
-struct PlanDeserializationState {
-	PlanDeserializationState(ClientContext &context);
-	~PlanDeserializationState();
-
-	ClientContext &context;
-	bound_parameter_map_t parameter_data;
-};
-
-struct LogicalDeserializationState {
-	LogicalDeserializationState(PlanDeserializationState &gstate, LogicalOperatorType type,
-	                            vector<unique_ptr<LogicalOperator>> &children);
-
-	PlanDeserializationState &gstate;
-	LogicalOperatorType type;
-	vector<unique_ptr<LogicalOperator>> &children;
-};
-
-struct ExpressionDeserializationState {
-	ExpressionDeserializationState(PlanDeserializationState &gstate, ExpressionType type);
-
-	PlanDeserializationState &gstate;
-	ExpressionType type;
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/meta_block_reader.hpp

@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/meta_block_reader.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/serializer.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
-
-namespace duckdb {
-class BlockHandle;
-class BlockManager;
-class BufferHandle;
-class DatabaseInstance;
-
-//! This struct is responsible for reading meta data from disk
-class MetaBlockReader : public Deserializer {
-public:
-	MetaBlockReader(BlockManager &block_manager, block_id_t block, bool free_blocks_on_read = true);
-	~MetaBlockReader() override;
-
-	BlockManager &block_manager;
-	shared_ptr<BlockHandle> block;
-	BufferHandle handle;
-	idx_t offset;
-	block_id_t next_block;
-	bool free_blocks_on_read;
-
-public:
-	//! Read content of size read_size into the buffer
-	void ReadData(data_ptr_t buffer, idx_t read_size) override;
-
-	ClientContext &GetContext() override;
-	optional_ptr<Catalog> GetCatalog() override;
-	void SetCatalog(Catalog &catalog_p);
-	void SetContext(ClientContext &context_p);
-
-private:
-	void ReadNewBlock(block_id_t id);
-	optional_ptr<ClientContext> context;
-	optional_ptr<Catalog> catalog;
-};
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/meta_block_writer.hpp

@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/meta_block_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/serializer.hpp"
-#include "duckdb/storage/block.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/common/set.hpp"
-
-namespace duckdb {
-class DatabaseInstance;
-
-//! This struct is responsible for writing data to disk in a stream of blocks.
-class MetaBlockWriter : public Serializer {
-public:
-	MetaBlockWriter(BlockManager &block_manager, block_id_t initial_block_id = INVALID_BLOCK);
-	~MetaBlockWriter() override;
-
-	BlockManager &block_manager;
-
-protected:
-	unique_ptr<Block> block;
-	set<block_id_t> written_blocks;
-	idx_t offset;
-
-public:
-	BlockPointer GetBlockPointer();
-	virtual void Flush();
-
-	void WriteData(const_data_ptr_t buffer, idx_t write_size) override;
-
-	void MarkWrittenBlocks() {
-		for (auto &block_id : written_blocks) {
-			block_manager.MarkBlockAsModified(block_id);
-		}
-	}
-
-protected:
-	virtual block_id_t GetNextBlockId();
-	void AdvanceBlock();
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/verification/deserialized_statement_verifier_v2.hpp

@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/verification/deserialized_statement_verifier_v2.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/verification/statement_verifier.hpp"
-
-namespace duckdb {
-
-//------------------------------------------------------------------------------
-// This is a temporary statement verifier that uses the new de/serialization
-// infrastructure to verify the correctness of the de/serialization process.
-// This verifier will be removed once the new de/serialization infrastructure
-// (FormatDe/Serializer) replaces the old one.
-class DeserializedStatementVerifierV2 : public StatementVerifier {
-public:
-	explicit DeserializedStatementVerifierV2(unique_ptr<SQLStatement> statement_p);
-	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement);
-};
-
-} // namespace duckdb

package/src/duckdb/src/optimizer/statistics/expression/propagate_and_compress.cpp

@@ -1,118 +0,0 @@
-#include "duckdb/function/scalar/operators.hpp"
-#include "duckdb/optimizer/statistics_propagator.hpp"
-#include "duckdb/planner/bound_result_modifier.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-
-namespace duckdb {
-
-template <class T>
-bool GetCastType(T signed_range, LogicalType &cast_type) {
-	auto range = static_cast<typename std::make_unsigned<decltype(signed_range)>::type>(signed_range);
-
-	// Check if this range fits in a smaller type
-	if (range < NumericLimits<uint8_t>::Maximum()) {
-		cast_type = LogicalType::UTINYINT;
-	} else if (sizeof(T) > sizeof(uint16_t) && range < NumericLimits<uint16_t>::Maximum()) {
-		cast_type = LogicalType::USMALLINT;
-	} else if (sizeof(T) > sizeof(uint32_t) && range < NumericLimits<uint32_t>::Maximum()) {
-		cast_type = LogicalType::UINTEGER;
-	} else {
-		return false;
-	}
-	return true;
-}
-
-template <>
-bool GetCastType(hugeint_t range, LogicalType &cast_type) {
-	if (range < NumericLimits<uint8_t>().Maximum()) {
-		cast_type = LogicalType::UTINYINT;
-	} else if (range < NumericLimits<uint16_t>().Maximum()) {
-		cast_type = LogicalType::USMALLINT;
-	} else if (range < NumericLimits<uint32_t>().Maximum()) {
-		cast_type = LogicalType::UINTEGER;
-	} else if (range < NumericLimits<uint64_t>().Maximum()) {
-		cast_type = LogicalType::UBIGINT;
-	} else {
-		return false;
-	}
-	return true;
-}
-
-template <class T>
-unique_ptr<Expression> TemplatedCastToSmallestType(unique_ptr<Expression> expr, BaseStatistics &stats) {
-	// Compute range
-	if (!NumericStats::HasMinMax(stats)) {
-		return expr;
-	}
-
-	auto signed_min_val = NumericStats::Min(stats).GetValue<T>();
-	auto signed_max_val = NumericStats::Max(stats).GetValue<T>();
-	if (signed_max_val < signed_min_val) {
-		return expr;
-	}
-
-	// Compute range, cast to unsigned to prevent comparing signed with unsigned
-	T signed_range;
-	if (!TrySubtractOperator::Operation(signed_max_val, signed_min_val, signed_range)) {
-		// overflow in subtraction: cannot do any simplification
-		return expr;
-	}
-
-	// Check if this range fits in a smaller type
-	LogicalType cast_type;
-	if (!GetCastType(signed_range, cast_type)) {
-		return expr;
-	}
-
-	// Create expression to map to a smaller range
-	auto input_type = expr->return_type;
-	auto minimum_expr = make_uniq<BoundConstantExpression>(Value::CreateValue(signed_min_val));
-	vector<unique_ptr<Expression>> arguments;
-	arguments.push_back(std::move(expr));
-	arguments.push_back(std::move(minimum_expr));
-	auto minus_expr = make_uniq<BoundFunctionExpression>(input_type, SubtractFun::GetFunction(input_type, input_type),
-	                                                     std::move(arguments), nullptr, true);
-
-	// Cast to smaller type
-	return BoundCastExpression::AddDefaultCastToType(std::move(minus_expr), cast_type);
-}
-
-unique_ptr<Expression> CastToSmallestType(unique_ptr<Expression> expr, BaseStatistics &num_stats) {
-	auto physical_type = expr->return_type.InternalType();
-	switch (physical_type) {
-	case PhysicalType::UINT8:
-	case PhysicalType::INT8:
-		return expr;
-	case PhysicalType::UINT16:
-		return TemplatedCastToSmallestType<uint16_t>(std::move(expr), num_stats);
-	case PhysicalType::INT16:
-		return TemplatedCastToSmallestType<int16_t>(std::move(expr), num_stats);
-	case PhysicalType::UINT32:
-		return TemplatedCastToSmallestType<uint32_t>(std::move(expr), num_stats);
-	case PhysicalType::INT32:
-		return TemplatedCastToSmallestType<int32_t>(std::move(expr), num_stats);
-	case PhysicalType::UINT64:
-		return TemplatedCastToSmallestType<uint64_t>(std::move(expr), num_stats);
-	case PhysicalType::INT64:
-		return TemplatedCastToSmallestType<int64_t>(std::move(expr), num_stats);
-	case PhysicalType::INT128:
-		return TemplatedCastToSmallestType<hugeint_t>(std::move(expr), num_stats);
-	default:
-		throw NotImplementedException("Unknown integer type!");
-	}
-}
-
-void StatisticsPropagator::PropagateAndCompress(unique_ptr<Expression> &expr, unique_ptr<BaseStatistics> &stats) {
-	stats = PropagateExpression(expr);
-	if (stats) {
-		if (expr->return_type.IsIntegral()) {
-			expr = CastToSmallestType(std::move(expr), *stats);
-		}
-	}
-}
-
-} // namespace duckdb

package/src/duckdb/src/parser/common_table_expression_info.cpp

@@ -1,19 +0,0 @@
-#include "duckdb/parser/common_table_expression_info.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
-
-namespace duckdb {
-
-void CommonTableExpressionInfo::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("aliases", aliases);
-	serializer.WriteProperty("query", query);
-}
-
-unique_ptr<CommonTableExpressionInfo> CommonTableExpressionInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = make_uniq<CommonTableExpressionInfo>();
-	result->aliases = deserializer.ReadProperty<vector<string>>("aliases");
-	result->query = deserializer.ReadProperty<unique_ptr<SelectStatement>>("query");
-	return result;
-}
-
-} // namespace duckdb

package/src/duckdb/src/planner/expression/bound_default_expression.cpp

@@ -1,16 +0,0 @@
-#include "duckdb/planner/expression/bound_default_expression.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
-
-namespace duckdb {
-
-void BoundDefaultExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(return_type);
-}
-
-unique_ptr<Expression> BoundDefaultExpression::Deserialize(ExpressionDeserializationState &state, FieldReader &reader) {
-	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	return make_uniq<BoundDefaultExpression>(return_type);
-}
-
-} // namespace duckdb