duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/storage/buffer/buffer_pool.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/storage/buffer/buffer_pool.hpp"
-#include "duckdb/parallel/concurrentqueue.hpp"
+
 #include "duckdb/common/exception.hpp"
+#include "duckdb/parallel/concurrentqueue.hpp"
+#include "duckdb/storage/temporary_memory_manager.hpp"
 
 namespace duckdb {
 
@@ -33,7 +35,11 @@ shared_ptr<BlockHandle> BufferEvictionNode::TryGetBlockHandle() {
 }
 
 BufferPool::BufferPool(idx_t maximum_memory)
-    : current_memory(0), maximum_memory(maximum_memory), queue(make_uniq<EvictionQueue>()), queue_insertions(0) {
+    : current_memory(0), maximum_memory(maximum_memory), queue(make_uniq<EvictionQueue>()), queue_insertions(0),
+      temporary_memory_manager(make_uniq<TemporaryMemoryManager>()) {
+	for (idx_t i = 0; i < MEMORY_TAG_COUNT; i++) {
+		memory_usage_per_tag[i] = 0;
+	}
 }
 BufferPool::~BufferPool() {
 }
@@ -50,21 +56,31 @@ void BufferPool::AddToEvictionQueue(shared_ptr<BlockHandle> &handle) {
 	queue->q.enqueue(BufferEvictionNode(weak_ptr<BlockHandle>(handle), handle->eviction_timestamp));
 }
 
-void BufferPool::IncreaseUsedMemory(idx_t size) {
+void BufferPool::IncreaseUsedMemory(MemoryTag tag, idx_t size) {
 	current_memory += size;
+	memory_usage_per_tag[uint8_t(tag)] += size;
 }
 
-idx_t BufferPool::GetUsedMemory() {
+idx_t BufferPool::GetUsedMemory() const {
 	return current_memory;
 }
-idx_t BufferPool::GetMaxMemory() {
+
+idx_t BufferPool::GetMaxMemory() const {
 	return maximum_memory;
 }
 
-BufferPool::EvictionResult BufferPool::EvictBlocks(idx_t extra_memory, idx_t memory_limit,
+idx_t BufferPool::GetQueryMaxMemory() const {
+	return GetMaxMemory();
+}
+
+TemporaryMemoryManager &BufferPool::GetTemporaryMemoryManager() {
+	return *temporary_memory_manager;
+}
+
+BufferPool::EvictionResult BufferPool::EvictBlocks(MemoryTag tag, idx_t extra_memory, idx_t memory_limit,
                                                    unique_ptr<FileBuffer> *buffer) {
 	BufferEvictionNode node;
-	TempBufferPoolReservation r(*this, extra_memory);
+	TempBufferPoolReservation r(tag, *this, extra_memory);
 	while (current_memory > memory_limit) {
 		// get a block to unpin from the queue
 		if (!queue->q.try_dequeue(node)) {
@@ -115,7 +131,7 @@ void BufferPool::PurgeQueue() {
 void BufferPool::SetLimit(idx_t limit, const char *exception_postscript) {
 	lock_guard<mutex> l_lock(limit_lock);
 	// try to evict until the limit is reached
-	if (!EvictBlocks(0, limit).success) {
+	if (!EvictBlocks(MemoryTag::EXTENSION, 0, limit).success) {
 		throw OutOfMemoryException(
 		    "Failed to change memory limit to %lld: could not free up enough memory for the new limit%s", limit,
 		    exception_postscript);
@@ -124,7 +140,7 @@ void BufferPool::SetLimit(idx_t limit, const char *exception_postscript) {
 	// set the global maximum memory to the new limit if successful
 	maximum_memory = limit;
 	// evict again
-	if (!EvictBlocks(0, limit).success) {
+	if (!EvictBlocks(MemoryTag::EXTENSION, 0, limit).success) {
 		// failed: go back to old limit
 		maximum_memory = old_limit;
 		throw OutOfMemoryException(

package/src/duckdb/src/storage/buffer/buffer_pool_reservation.cpp

@@ -3,15 +3,16 @@
 
 namespace duckdb {
 
-BufferPoolReservation::BufferPoolReservation(BufferPool &pool) : pool(pool) {
+BufferPoolReservation::BufferPoolReservation(MemoryTag tag, BufferPool &pool) : tag(tag), pool(pool) {
 }
 
-BufferPoolReservation::BufferPoolReservation(BufferPoolReservation &&src) noexcept : pool(src.pool) {
+BufferPoolReservation::BufferPoolReservation(BufferPoolReservation &&src) noexcept : tag(src.tag), pool(src.pool) {
 	size = src.size;
 	src.size = 0;
 }
 
 BufferPoolReservation &BufferPoolReservation::operator=(BufferPoolReservation &&src) noexcept {
+	tag = src.tag;
 	size = src.size;
 	src.size = 0;
 	return *this;
@@ -23,7 +24,7 @@ BufferPoolReservation::~BufferPoolReservation() {
 
 void BufferPoolReservation::Resize(idx_t new_size) {
 	int64_t delta = (int64_t)new_size - size;
-	pool.IncreaseUsedMemory(delta);
+	pool.IncreaseUsedMemory(tag, delta);
 	size = new_size;
 }
 

package/src/duckdb/src/storage/buffer_manager.cpp

@@ -1,7 +1,9 @@
 #include "duckdb/storage/buffer_manager.hpp"
+
 #include "duckdb/common/allocator.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/file_buffer.hpp"
+#include "duckdb/storage/buffer/buffer_pool.hpp"
 #include "duckdb/storage/standard_buffer_manager.hpp"
 
 namespace duckdb {
@@ -37,10 +39,14 @@ const string &BufferManager::GetTemporaryDirectory() {
 	throw InternalException("This type of BufferManager does not allow a temporary directory");
 }
 
-BufferPool &BufferManager::GetBufferPool() {
+BufferPool &BufferManager::GetBufferPool() const {
 	throw InternalException("This type of BufferManager does not have a buffer pool");
 }
 
+TemporaryMemoryManager &BufferManager::GetTemporaryMemoryManager() {
+	throw NotImplementedException("This type of BufferManager does not have a TemporaryMemoryManager");
+}
+
 void BufferManager::SetTemporaryDirectory(const string &new_dir) {
 	throw NotImplementedException("This type of BufferManager can not set a temporary directory");
 }
@@ -53,6 +59,11 @@ bool BufferManager::HasTemporaryDirectory() const {
 	return false;
 }
 
+//! Returns the maximum available memory for a given query
+idx_t BufferManager::GetQueryMaxMemory() const {
+	return GetBufferPool().GetQueryMaxMemory();
+}
+
 unique_ptr<FileBuffer> BufferManager::ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
                                                              FileBufferType type) {
 	throw NotImplementedException("This type of BufferManager can not construct managed buffers");
@@ -64,11 +75,11 @@ void BufferManager::AddToEvictionQueue(shared_ptr<BlockHandle> &handle) {
 	throw NotImplementedException("This type of BufferManager does not support 'AddToEvictionQueue");
 }
 
-void BufferManager::WriteTemporaryBuffer(block_id_t block_id, FileBuffer &buffer) {
+void BufferManager::WriteTemporaryBuffer(MemoryTag tag, block_id_t block_id, FileBuffer &buffer) {
 	throw NotImplementedException("This type of BufferManager does not support 'WriteTemporaryBuffer");
 }
 
-unique_ptr<FileBuffer> BufferManager::ReadTemporaryBuffer(block_id_t id, unique_ptr<FileBuffer> buffer) {
+unique_ptr<FileBuffer> BufferManager::ReadTemporaryBuffer(MemoryTag tag, block_id_t id, unique_ptr<FileBuffer> buffer) {
 	throw NotImplementedException("This type of BufferManager does not support 'ReadTemporaryBuffer");
 }
 

package/src/duckdb/src/storage/checkpoint/row_group_writer.cpp

@@ -9,14 +9,6 @@ CompressionType RowGroupWriter::GetColumnCompressionType(idx_t i) {
 	return table.GetColumn(LogicalIndex(i)).CompressionType();
 }
 
-void RowGroupWriter::RegisterPartialBlock(PartialBlockAllocation &&allocation) {
-	partial_block_manager.RegisterPartialBlock(std::move(allocation));
-}
-
-PartialBlockAllocation RowGroupWriter::GetBlockAllocation(uint32_t segment_size) {
-	return partial_block_manager.GetBlockAllocation(segment_size);
-}
-
 void SingleFileRowGroupWriter::WriteColumnDataPointers(ColumnCheckpointState &column_checkpoint_state,
                                                        Serializer &serializer) {
 	const auto &data_pointers = column_checkpoint_state.data_pointers;

package/src/duckdb/src/storage/checkpoint/table_data_writer.cpp

@@ -2,9 +2,10 @@
 
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
 #include "duckdb/storage/table/column_checkpoint_state.hpp"
 #include "duckdb/storage/table/table_statistics.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/parallel/task_scheduler.hpp"
 
 namespace duckdb {
 
@@ -29,6 +30,10 @@ void TableDataWriter::AddRowGroup(RowGroupPointer &&row_group_pointer, unique_pt
 	writer.reset();
 }
 
+TaskScheduler &TableDataWriter::GetScheduler() {
+	return TaskScheduler::GetScheduler(table.ParentCatalog().GetDatabase());
+}
+
 SingleFileTableDataWriter::SingleFileTableDataWriter(SingleFileCheckpointWriter &checkpoint_manager,
                                                      TableCatalogEntry &table, MetadataWriter &table_data_writer)
     : TableDataWriter(table), checkpoint_manager(checkpoint_manager), table_data_writer(table_data_writer) {
@@ -39,7 +44,7 @@ unique_ptr<RowGroupWriter> SingleFileTableDataWriter::GetRowGroupWriter(RowGroup
 }
 
 void SingleFileTableDataWriter::FinalizeTable(TableStatistics &&global_stats, DataTableInfo *info,
-                                              Serializer &metadata_serializer) {
+                                              Serializer &serializer) {
 	// store the current position in the metadata writer
 	// this is where the row groups for this table start
 	auto pointer = table_data_writer.GetMetaBlockPointer();
@@ -66,13 +71,16 @@ void SingleFileTableDataWriter::FinalizeTable(TableStatistics &&global_stats, Da
 		row_group_serializer.End();
 	}
 
-	auto index_pointers = info->indexes.SerializeIndexes(table_data_writer);
-
 	// Now begin the metadata as a unit
 	// Pointer to the table itself goes to the metadata stream.
-	metadata_serializer.WriteProperty(101, "table_pointer", pointer);
-	metadata_serializer.WriteProperty(102, "total_rows", total_rows);
-	metadata_serializer.WriteProperty(103, "index_pointers", index_pointers);
+	serializer.WriteProperty(101, "table_pointer", pointer);
+	serializer.WriteProperty(102, "total_rows", total_rows);
+
+	auto index_storage_infos = info->indexes.GetStorageInfos();
+	// write empty block pointers for forwards compatibility
+	vector<BlockPointer> compat_block_pointers;
+	serializer.WriteProperty(103, "index_pointers", compat_block_pointers);
+	serializer.WritePropertyWithDefault(104, "index_storage_infos", index_storage_infos);
 }
 
 } // namespace duckdb

package/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp

@@ -40,7 +40,7 @@ void WriteOverflowStringsToDisk::WriteString(UncompressedStringSegmentState &sta
                                              block_id_t &result_block, int32_t &result_offset) {
 	auto &buffer_manager = block_manager.buffer_manager;
 	if (!handle.IsValid()) {
-		handle = buffer_manager.Allocate(Storage::BLOCK_SIZE);
+		handle = buffer_manager.Allocate(MemoryTag::OVERFLOW_STRINGS, Storage::BLOCK_SIZE);
 	}
 	// first write the length of the string
 	if (block_id == INVALID_BLOCK || offset + 2 * sizeof(uint32_t) >= STRING_SPACE) {

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -1,14 +1,17 @@
 #include "duckdb/storage/checkpoint_manager.hpp"
 
-#include "duckdb/catalog/duck_catalog.hpp"
 #include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
-#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
+#include "duckdb/catalog/duck_catalog.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/main/attached_database.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/main/connection.hpp"
@@ -25,9 +28,8 @@
 #include "duckdb/storage/metadata/metadata_reader.hpp"
 #include "duckdb/storage/table/column_checkpoint_state.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
+#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/execution/index/unknown_index.hpp"
 
 namespace duckdb {
 
@@ -184,8 +186,11 @@ void SingleFileCheckpointWriter::CreateCheckpoint() {
 	// CHECKPOINT "meta_block_id", and the id MATCHES the head idin the file we know that the database was successfully
 	// checkpointed, so we know that we should avoid replaying the WAL to avoid duplicating data
 	auto wal = storage_manager.GetWriteAheadLog();
-	wal->WriteCheckpoint(meta_block);
-	wal->Flush();
+	bool wal_is_empty = wal->GetWALSize() == 0;
+	if (!wal_is_empty) {
+		wal->WriteCheckpoint(meta_block);
+		wal->Flush();
+	}
 
 	if (config.options.checkpoint_abort == CheckpointAbort::DEBUG_ABORT_BEFORE_HEADER) {
 		throw FatalException("Checkpoint aborted before header write because of PRAGMA checkpoint_abort flag");
@@ -194,6 +199,8 @@ void SingleFileCheckpointWriter::CreateCheckpoint() {
 	// finally write the updated header
 	DatabaseHeader header;
 	header.meta_block = meta_block.block_pointer;
+	header.block_size = Storage::BLOCK_ALLOC_SIZE;
+	header.vector_size = STANDARD_VECTOR_SIZE;
 	block_manager.WriteHeader(header);
 
 	if (config.options.checkpoint_abort == CheckpointAbort::DEBUG_ABORT_BEFORE_TRUNCATE) {
@@ -204,7 +211,9 @@ void SingleFileCheckpointWriter::CreateCheckpoint() {
 	block_manager.Truncate();
 
 	// truncate the WAL
-	wal->Truncate(0);
+	if (!wal_is_empty) {
+		wal->Truncate(0);
+	}
 }
 
 void CheckpointReader::LoadCheckpoint(ClientContext &context, MetadataReader &reader) {
@@ -375,38 +384,47 @@ void CheckpointReader::ReadSequence(ClientContext &context, Deserializer &deseri
 //===--------------------------------------------------------------------===//
 // Indexes
 //===--------------------------------------------------------------------===//
-void CheckpointWriter::WriteIndex(IndexCatalogEntry &index_catalog, Serializer &serializer) {
-	// The index data is written as part of WriteTableData.
-	// Here, we need only serialize the pointer to that data.
-	auto root_block_pointer = index_catalog.index->GetRootBlockPointer();
-	serializer.WriteProperty(100, "index", &index_catalog);
-	serializer.WriteProperty(101, "root_block_pointer", root_block_pointer);
+void CheckpointWriter::WriteIndex(IndexCatalogEntry &index_catalog_entry, Serializer &serializer) {
+	// The index data is written as part of WriteTableData
+	// Here, we serialize the index catalog entry
+
+	// we need to keep the tag "index", even though it is slightly misleading
+	serializer.WriteProperty(100, "index", &index_catalog_entry);
 }
 
 void CheckpointReader::ReadIndex(ClientContext &context, Deserializer &deserializer) {
 
-	// deserialize the index create info
+	// we need to keep the tag "index", even though it is slightly misleading.
 	auto create_info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(100, "index");
 	auto &info = create_info->Cast<CreateIndexInfo>();
 
+	// also, we have to read the root_block_pointer, which will not be valid for newer storage versions.
+	// This leads to different code paths in this function.
+	auto root_block_pointer =
+	    deserializer.ReadPropertyWithDefault<BlockPointer>(101, "root_block_pointer", BlockPointer());
+
 	// create the index in the catalog
-	auto &schema = catalog.GetSchema(context, create_info->schema);
+
+	// look for the table in the catalog
 	auto &table =
 	    catalog.GetEntry(context, CatalogType::TABLE_ENTRY, create_info->schema, info.table).Cast<DuckTableEntry>();
 
-	auto &index = schema.CreateIndex(context, info, table)->Cast<DuckIndexEntry>();
+	// we also need to make sure the index type is loaded
+	// backwards compatability:
+	// if the index type is not specified, we default to ART
+	if (info.index_type.empty()) {
+		info.index_type = ART::TYPE_NAME;
+	}
+
+	// now we can look for the index in the catalog and assign the table info
+	auto &index = catalog.CreateIndex(context, info)->Cast<DuckIndexEntry>();
+	index.info = make_shared<IndexDataTableInfo>(table.GetStorage().info, info.index_name);
 
-	index.info = table.GetStorage().info;
-	// insert the parsed expressions into the stored index so that we correctly (de)serialize it during consecutive
-	// checkpoints
+	// insert the parsed expressions into the index so that we can (de)serialize them during consecutive checkpoints
 	for (auto &parsed_expr : info.parsed_expressions) {
 		index.parsed_expressions.push_back(parsed_expr->Copy());
 	}
 
-	// we deserialize the index lazily, i.e., we do not need to load any node information
-	// except the root block pointer
-	auto root_block_pointer = deserializer.ReadProperty<BlockPointer>(101, "root_block_pointer");
-
 	// obtain the parsed expressions of the ART from the index metadata
 	vector<unique_ptr<ParsedExpression>> parsed_expressions;
 	for (auto &parsed_expr : info.parsed_expressions) {
@@ -435,18 +453,37 @@ void CheckpointReader::ReadIndex(ClientContext &context, Deserializer &deseriali
 		unbound_expressions.push_back(idx_binder.Bind(expr));
 	}
 
-	// create the index and add it to the storage
-	switch (info.index_type) {
-	case IndexType::ART: {
-		auto &storage = table.GetStorage();
-		auto art = make_uniq<ART>(info.column_ids, TableIOManager::Get(storage), std::move(unbound_expressions),
-		                          info.constraint_type, storage.db, nullptr, root_block_pointer);
+	auto &data_table = table.GetStorage();
+	IndexStorageInfo index_storage_info;
+	if (root_block_pointer.IsValid()) {
+		// this code path is necessary to read older duckdb files
+		index_storage_info.name = info.index_name;
+		index_storage_info.root_block_ptr = root_block_pointer;
+
+	} else {
+		// get the matching index storage info
+		for (auto const &elem : data_table.info->index_storage_infos) {
+			if (elem.name == info.index_name) {
+				index_storage_info = elem;
+				break;
+			}
+		}
+	}
+
+	D_ASSERT(index_storage_info.IsValid() && !index_storage_info.name.empty());
 
-		index.index = art.get();
-		storage.info->indexes.AddIndex(std::move(art));
-	} break;
-	default:
-		throw InternalException("Unknown index type for ReadIndex");
+	// This is executed before any extensions can be loaded, which is why we must treat any index type that is not
+	// built-in (ART) as unknown
+	if (info.index_type == ART::TYPE_NAME) {
+		data_table.info->indexes.AddIndex(make_uniq<ART>(info.index_name, info.constraint_type, info.column_ids,
+		                                                 TableIOManager::Get(data_table), unbound_expressions,
+		                                                 data_table.db, nullptr, index_storage_info));
+	} else {
+		auto unknown_index = make_uniq<UnknownIndex>(info.index_name, info.index_type, info.constraint_type,
+		                                             info.column_ids, TableIOManager::Get(data_table),
+		                                             unbound_expressions, data_table.db, info, index_storage_info);
+
+		data_table.info->indexes.AddIndex(std::move(unknown_index));
 	}
 }
 
@@ -490,7 +527,7 @@ void CheckpointReader::ReadTableMacro(ClientContext &context, Deserializer &dese
 // Table Metadata
 //===--------------------------------------------------------------------===//
 void CheckpointWriter::WriteTable(TableCatalogEntry &table, Serializer &serializer) {
-	// Write the table meta data
+	// Write the table metadata
 	serializer.WriteProperty(100, "table", &table);
 
 	// Write the table data
@@ -506,7 +543,7 @@ void CheckpointReader::ReadTable(ClientContext &context, Deserializer &deseriali
 	auto &schema = catalog.GetSchema(context, info->schema);
 	auto bound_info = binder->BindCreateTableInfo(std::move(info), schema);
 
-	// now read the actual table data and place it into the create table info
+	// now read the actual table data and place it into the CreateTableInfo
 	ReadTableData(context, deserializer, *bound_info);
 
 	// finally create the table in the catalog
@@ -516,10 +553,27 @@ void CheckpointReader::ReadTable(ClientContext &context, Deserializer &deseriali
 void CheckpointReader::ReadTableData(ClientContext &context, Deserializer &deserializer,
                                      BoundCreateTableInfo &bound_info) {
 
-	// This is written in "SingleFileTableDataWriter::FinalizeTable"
+	// written in "SingleFileTableDataWriter::FinalizeTable"
 	auto table_pointer = deserializer.ReadProperty<MetaBlockPointer>(101, "table_pointer");
 	auto total_rows = deserializer.ReadProperty<idx_t>(102, "total_rows");
-	auto index_pointers = deserializer.ReadProperty<vector<BlockPointer>>(103, "index_pointers");
+
+	// old file read
+	auto index_pointers = deserializer.ReadPropertyWithDefault<vector<BlockPointer>>(103, "index_pointers", {});
+	// new file read
+	auto index_storage_infos =
+	    deserializer.ReadPropertyWithDefault<vector<IndexStorageInfo>>(104, "index_storage_infos", {});
+
+	if (!index_storage_infos.empty()) {
+		bound_info.indexes = index_storage_infos;
+
+	} else {
+		// old duckdb file containing index pointers
+		for (idx_t i = 0; i < index_pointers.size(); i++) {
+			IndexStorageInfo index_storage_info;
+			index_storage_info.root_block_ptr = index_pointers[i];
+			bound_info.indexes.push_back(index_storage_info);
+		}
+	}
 
 	// FIXME: icky downcast to get the underlying MetadataReader
 	auto &binary_deserializer = dynamic_cast<BinaryDeserializer &>(deserializer);
@@ -530,7 +584,6 @@ void CheckpointReader::ReadTableData(ClientContext &context, Deserializer &deser
 	data_reader.ReadTableData();
 
 	bound_info.data->total_rows = total_rows;
-	bound_info.indexes = index_pointers;
 }
 
 } // namespace duckdb

package/src/duckdb/src/storage/compression/alp/alp.cpp

@@ -0,0 +1,57 @@
+#include "duckdb/storage/compression/alp/alp_compress.hpp"
+#include "duckdb/storage/compression/alp/alp_scan.hpp"
+#include "duckdb/storage/compression/alp/alp_fetch.hpp"
+#include "duckdb/storage/compression/alp/alp_analyze.hpp"
+
+#include "duckdb/function/compression/compression.hpp"
+#include "duckdb/function/compression_function.hpp"
+#include "duckdb/main/config.hpp"
+
+#include <cmath>
+#include <functional>
+
+namespace duckdb {
+
+template <class T>
+CompressionFunction GetAlpFunction(PhysicalType data_type) {
+	throw NotImplementedException("GetAlpFunction not implemented for the given datatype");
+}
+
+template <>
+CompressionFunction GetAlpFunction<float>(PhysicalType data_type) {
+	return CompressionFunction(CompressionType::COMPRESSION_ALP, data_type, AlpInitAnalyze<float>, AlpAnalyze<float>,
+	                           AlpFinalAnalyze<float>, AlpInitCompression<float>, AlpCompress<float>,
+	                           AlpFinalizeCompress<float>, AlpInitScan<float>, AlpScan<float>, AlpScanPartial<float>,
+	                           AlpFetchRow<float>, AlpSkip<float>);
+}
+
+template <>
+CompressionFunction GetAlpFunction<double>(PhysicalType data_type) {
+	return CompressionFunction(CompressionType::COMPRESSION_ALP, data_type, AlpInitAnalyze<double>, AlpAnalyze<double>,
+	                           AlpFinalAnalyze<double>, AlpInitCompression<double>, AlpCompress<double>,
+	                           AlpFinalizeCompress<double>, AlpInitScan<double>, AlpScan<double>,
+	                           AlpScanPartial<double>, AlpFetchRow<double>, AlpSkip<double>);
+}
+
+CompressionFunction AlpCompressionFun::GetFunction(PhysicalType type) {
+	switch (type) {
+	case PhysicalType::FLOAT:
+		return GetAlpFunction<float>(type);
+	case PhysicalType::DOUBLE:
+		return GetAlpFunction<double>(type);
+	default:
+		throw InternalException("Unsupported type for Alp");
+	}
+}
+
+bool AlpCompressionFun::TypeIsSupported(PhysicalType type) {
+	switch (type) {
+	case PhysicalType::FLOAT:
+	case PhysicalType::DOUBLE:
+		return true;
+	default:
+		return false;
+	}
+}
+
+} // namespace duckdb

package/src/duckdb/src/storage/compression/alp/alp_constants.cpp

@@ -0,0 +1,13 @@
+#include "duckdb/storage/compression/alp/alp_constants.hpp"
+
+namespace duckdb {
+
+constexpr int64_t AlpConstants::FACT_ARR[];
+
+constexpr float AlpTypedConstants<float>::EXP_ARR[];
+constexpr float AlpTypedConstants<float>::FRAC_ARR[];
+
+constexpr double AlpTypedConstants<double>::EXP_ARR[];
+constexpr double AlpTypedConstants<double>::FRAC_ARR[];
+
+} // namespace duckdb

package/src/duckdb/src/storage/compression/alprd.cpp

@@ -0,0 +1,57 @@
+#include "duckdb/storage/compression/alprd/alprd_analyze.hpp"
+#include "duckdb/storage/compression/alprd/alprd_compress.hpp"
+#include "duckdb/storage/compression/alprd/alprd_fetch.hpp"
+#include "duckdb/storage/compression/alprd/alprd_scan.hpp"
+
+#include "duckdb/common/limits.hpp"
+#include "duckdb/function/compression/compression.hpp"
+#include "duckdb/function/compression_function.hpp"
+
+#include <cmath>
+#include <functional>
+
+namespace duckdb {
+
+template <class T>
+CompressionFunction GetAlpRDFunction(PhysicalType data_type) {
+	throw NotImplementedException("GetAlpFunction not implemented for the given datatype");
+}
+
+template <>
+CompressionFunction GetAlpRDFunction<float>(PhysicalType data_type) {
+	return CompressionFunction(CompressionType::COMPRESSION_ALPRD, data_type, AlpRDInitAnalyze<float>,
+	                           AlpRDAnalyze<float>, AlpRDFinalAnalyze<float>, AlpRDInitCompression<float>,
+	                           AlpRDCompress<float>, AlpRDFinalizeCompress<float>, AlpRDInitScan<float>,
+	                           AlpRDScan<float>, AlpRDScanPartial<float>, AlpRDFetchRow<float>, AlpRDSkip<float>);
+}
+
+template <>
+CompressionFunction GetAlpRDFunction<double>(PhysicalType data_type) {
+	return CompressionFunction(CompressionType::COMPRESSION_ALPRD, data_type, AlpRDInitAnalyze<double>,
+	                           AlpRDAnalyze<double>, AlpRDFinalAnalyze<double>, AlpRDInitCompression<double>,
+	                           AlpRDCompress<double>, AlpRDFinalizeCompress<double>, AlpRDInitScan<double>,
+	                           AlpRDScan<double>, AlpRDScanPartial<double>, AlpRDFetchRow<double>, AlpRDSkip<double>);
+}
+
+CompressionFunction AlpRDCompressionFun::GetFunction(PhysicalType type) {
+	switch (type) {
+	case PhysicalType::FLOAT:
+		return GetAlpRDFunction<float>(type);
+	case PhysicalType::DOUBLE:
+		return GetAlpRDFunction<double>(type);
+	default:
+		throw InternalException("Unsupported type for Alp");
+	}
+}
+
+bool AlpRDCompressionFun::TypeIsSupported(PhysicalType type) {
+	switch (type) {
+	case PhysicalType::FLOAT:
+	case PhysicalType::DOUBLE:
+		return true;
+	default:
+		return false;
+	}
+}
+
+} // namespace duckdb