duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

package/src/duckdb/src/include/duckdb/execution/index/art/swizzleable_pointer.hpp

@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/swizzleable_pointer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-#pragma once
-
-#include "duckdb/common/constants.hpp"
-
-namespace duckdb {
-
-// classes
-class MetaBlockReader;
-
-// structs
-struct BlockPointer;
-
-//! SwizzleablePointer provides functions on a (possibly) swizzled pointer. If the swizzle flag is set, then the
-//! pointer points to a storage address (and has no type), otherwise the pointer has a type and stores
-//! other information (e.g., a buffer location)
-class SwizzleablePointer {
-public:
-	//! Constructs an empty SwizzleablePointer
-	SwizzleablePointer() : swizzle_flag(0), type(0), offset(0), buffer_id(0) {};
-	//! Constructs a swizzled pointer from a buffer ID and an offset
-	explicit SwizzleablePointer(MetaBlockReader &reader);
-	//! Constructs a non-swizzled pointer from a buffer ID and an offset
-	SwizzleablePointer(uint32_t offset, uint32_t buffer_id)
-	    : swizzle_flag(0), type(0), offset(offset), buffer_id(buffer_id) {};
-
-	//! The swizzle flag, set if swizzled, not set otherwise
-	uint8_t swizzle_flag : 1;
-	//! The type of the pointer, zero if not set
-	uint8_t type : 7;
-	//! The offset of a memory location
-	uint32_t offset : 24;
-	//! The buffer ID of a memory location
-	uint32_t buffer_id : 32;
-
-public:
-	//! Checks if the pointer is swizzled
-	inline bool IsSwizzled() const {
-		return swizzle_flag;
-	}
-	//! Returns true, if neither the swizzle flag nor the type is set, and false otherwise
-	inline bool IsSet() const {
-		return swizzle_flag || type;
-	}
-	//! Reset the pointer
-	inline void Reset() {
-		swizzle_flag = 0;
-		type = 0;
-	}
-};
-
-} // 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/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/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/operator/logical_asof_join.cpp

@@ -1,14 +0,0 @@
-#include "duckdb/planner/operator/logical_asof_join.hpp"
-
-namespace duckdb {
-
-LogicalAsOfJoin::LogicalAsOfJoin(JoinType type) : LogicalComparisonJoin(type, LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-}
-
-unique_ptr<LogicalOperator> LogicalAsOfJoin::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto result = make_uniq<LogicalAsOfJoin>(JoinType::INVALID);
-	LogicalComparisonJoin::Deserialize(*result, state, reader);
-	return std::move(result);
-}
-
-} // namespace duckdb

package/src/duckdb/src/planner/operator/logical_delim_join.cpp

@@ -1,27 +0,0 @@
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
-
-namespace duckdb {
-
-LogicalDelimJoin::LogicalDelimJoin(JoinType type)
-    : LogicalComparisonJoin(type, LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-}
-
-void LogicalDelimJoin::Serialize(FieldWriter &writer) const {
-	LogicalComparisonJoin::Serialize(writer);
-	if (type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		D_ASSERT(duplicate_eliminated_columns.empty());
-		// if the delim join has no delim columns anymore it is turned into a regular comparison join
-		return;
-	}
-	writer.WriteSerializableList(duplicate_eliminated_columns);
-}
-
-unique_ptr<LogicalOperator> LogicalDelimJoin::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto result = make_uniq<LogicalDelimJoin>(JoinType::INVALID);
-	LogicalComparisonJoin::Deserialize(*result, state, reader);
-	result->duplicate_eliminated_columns = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	return std::move(result);
-}
-
-} // namespace duckdb

package/src/duckdb/src/storage/meta_block_reader.cpp

@@ -1,78 +0,0 @@
-#include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/main/connection_manager.hpp"
-#include "duckdb/main/database.hpp"
-
-#include <cstring>
-
-namespace duckdb {
-
-MetaBlockReader::MetaBlockReader(BlockManager &block_manager, block_id_t block_id, bool free_blocks_on_read)
-    : block_manager(block_manager), offset(0), next_block(-1), free_blocks_on_read(free_blocks_on_read) {
-	ReadNewBlock(block_id);
-}
-
-MetaBlockReader::~MetaBlockReader() {
-}
-
-void MetaBlockReader::ReadData(data_ptr_t buffer, idx_t read_size) {
-	while (offset + read_size > handle.GetFileBuffer().size) {
-		// cannot read entire entry from block
-		// first read what we can from this block
-		idx_t to_read = handle.GetFileBuffer().size - offset;
-		if (to_read > 0) {
-			memcpy(buffer, handle.Ptr() + offset, to_read);
-			read_size -= to_read;
-			buffer += to_read;
-		}
-		// then move to the next block
-		if (next_block == INVALID_BLOCK) {
-			throw IOException("Cannot read from INVALID_BLOCK.");
-		}
-		ReadNewBlock(next_block);
-	}
-	// we have enough left in this block to read from the buffer
-	memcpy(buffer, handle.Ptr() + offset, read_size);
-	offset += read_size;
-}
-
-ClientContext &MetaBlockReader::GetContext() {
-	if (!context) {
-		throw InternalException("Meta Block Reader is missing context");
-	}
-	return *context;
-}
-
-optional_ptr<Catalog> MetaBlockReader::GetCatalog() {
-	return catalog;
-}
-
-void MetaBlockReader::ReadNewBlock(block_id_t id) {
-	auto &buffer_manager = block_manager.buffer_manager;
-
-	// Marking these blocks as modified will cause them to be moved to the free
-	// list upon the next successful checkpoint. Marking them modified here
-	// assumes MetaBlockReader is exclusively used for reading checkpoint data,
-	// and thus any blocks we're reading will be obviated by the next checkpoint.
-	if (free_blocks_on_read) {
-		block_manager.MarkBlockAsModified(id);
-	}
-	block = block_manager.RegisterBlock(id, true);
-	handle = buffer_manager.Pin(block);
-
-	next_block = Load<block_id_t>(handle.Ptr());
-	D_ASSERT(next_block >= -1);
-	offset = sizeof(block_id_t);
-}
-
-void MetaBlockReader::SetCatalog(Catalog &catalog_p) {
-	D_ASSERT(!catalog);
-	catalog = &catalog_p;
-}
-
-void MetaBlockReader::SetContext(ClientContext &context_p) {
-	D_ASSERT(!context);
-	context = &context_p;
-}
-
-} // namespace duckdb

package/src/duckdb/src/storage/meta_block_writer.cpp

@@ -1,80 +0,0 @@
-#include "duckdb/storage/meta_block_writer.hpp"
-
-#include <cstring>
-
-namespace duckdb {
-
-MetaBlockWriter::MetaBlockWriter(BlockManager &block_manager, block_id_t initial_block_id)
-    : block_manager(block_manager) {
-	if (initial_block_id == INVALID_BLOCK) {
-		initial_block_id = MetaBlockWriter::GetNextBlockId();
-	}
-	block = block_manager.CreateBlock(initial_block_id, nullptr);
-	Store<block_id_t>(-1, block->buffer);
-	offset = sizeof(block_id_t);
-}
-
-MetaBlockWriter::~MetaBlockWriter() {
-	// If there's an exception during checkpoint, this can get destroyed without
-	// flushing the data...which is fine, because none of the unwritten data
-	// will be referenced.
-	//
-	// Otherwise, we should have explicitly flushed (and thereby nulled the block).
-	D_ASSERT(!block || Exception::UncaughtException());
-}
-
-block_id_t MetaBlockWriter::GetNextBlockId() {
-	return block_manager.GetFreeBlockId();
-}
-
-BlockPointer MetaBlockWriter::GetBlockPointer() {
-	BlockPointer pointer;
-	pointer.block_id = block->id;
-	pointer.offset = offset;
-	return pointer;
-}
-
-void MetaBlockWriter::Flush() {
-	if (offset < block->size) {
-		// clear remaining bytes of block (if any)
-		memset(block->buffer + offset, 0, block->size - offset);
-	}
-	AdvanceBlock();
-	block = nullptr;
-}
-
-void MetaBlockWriter::AdvanceBlock() {
-	written_blocks.insert(block->id);
-	if (offset > sizeof(block_id_t)) {
-		block_manager.Write(*block);
-		offset = sizeof(block_id_t);
-	}
-}
-
-void MetaBlockWriter::WriteData(const_data_ptr_t buffer, idx_t write_size) {
-	while (offset + write_size > block->size) {
-		// we need to make a new block
-		// first copy what we can
-		D_ASSERT(offset <= block->size);
-		idx_t copy_amount = block->size - offset;
-		if (copy_amount > 0) {
-			memcpy(block->buffer + offset, buffer, copy_amount);
-			buffer += copy_amount;
-			offset += copy_amount;
-			write_size -= copy_amount;
-		}
-		// now we need to get a new block id
-		block_id_t new_block_id = GetNextBlockId();
-		// write the block id of the new block to the start of the current block
-		Store<block_id_t>(new_block_id, block->buffer);
-		// first flush the old block
-		AdvanceBlock();
-		// now update the block id of the block
-		block->id = new_block_id;
-		Store<block_id_t>(-1, block->buffer);
-	}
-	memcpy(block->buffer + offset, buffer, write_size);
-	offset += write_size;
-}
-
-} // namespace duckdb