duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

package/src/duckdb/src/transaction/transaction_context.cpp

@@ -1,12 +1,13 @@
 #include "duckdb/transaction/transaction_context.hpp"
-#include "duckdb/common/exception/transaction_exception.hpp"
+
 #include "duckdb/common/exception.hpp"
-#include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/main/database_manager.hpp"
+#include "duckdb/common/exception/transaction_exception.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_context_state.hpp"
+#include "duckdb/main/config.hpp"
+#include "duckdb/main/database_manager.hpp"
+#include "duckdb/transaction/meta_transaction.hpp"
+#include "duckdb/transaction/transaction_manager.hpp"
 
 namespace duckdb {
 
@@ -17,7 +18,7 @@ TransactionContext::TransactionContext(ClientContext &context)
 TransactionContext::~TransactionContext() {
 	if (current_transaction) {
 		try {
-			Rollback();
+			Rollback(nullptr);
 		} catch (...) { // NOLINT
 		}
 	}
@@ -28,12 +29,11 @@ void TransactionContext::BeginTransaction() {
 		throw TransactionException("cannot start a transaction within a transaction");
 	}
 	auto start_timestamp = Timestamp::GetCurrentTimestamp();
-	auto catalog_version = Catalog::GetSystemCatalog(context).GetCatalogVersion();
-	current_transaction = make_uniq<MetaTransaction>(context, start_timestamp, catalog_version);
+	current_transaction = make_uniq<MetaTransaction>(context, start_timestamp);
 
 	// Notify any registered state of transaction begin
-	for (auto const &s : context.registered_state) {
-		s.second->TransactionBegin(*current_transaction, context);
+	for (auto &state : context.registered_state->States()) {
+		state->TransactionBegin(*current_transaction, context);
 	}
 }
 
@@ -46,13 +46,13 @@ void TransactionContext::Commit() {
 	auto error = transaction->Commit();
 	// Notify any registered state of transaction commit
 	if (error.HasError()) {
-		for (auto const &s : context.registered_state) {
-			s.second->TransactionRollback(*transaction, context);
+		for (auto const &s : context.registered_state->States()) {
+			s->TransactionRollback(*transaction, context, error);
 		}
 		throw TransactionException("Failed to commit: %s", error.RawMessage());
 	} else {
-		for (auto const &s : context.registered_state) {
-			s.second->TransactionCommit(*transaction, context);
+		for (auto &state : context.registered_state->States()) {
+			state->TransactionCommit(*transaction, context);
 		}
 	}
 }
@@ -64,7 +64,11 @@ void TransactionContext::SetAutoCommit(bool value) {
 	}
 }
 
-void TransactionContext::Rollback() {
+void TransactionContext::SetReadOnly() {
+	current_transaction->SetReadOnly();
+}
+
+void TransactionContext::Rollback(optional_ptr<ErrorData> error) {
 	if (!current_transaction) {
 		throw TransactionException("failed to rollback: no transaction active");
 	}
@@ -72,8 +76,8 @@ void TransactionContext::Rollback() {
 	ClearTransaction();
 	transaction->Rollback();
 	// Notify any registered state of transaction rollback
-	for (auto const &s : context.registered_state) {
-		s.second->TransactionRollback(*transaction, context);
+	for (auto const &s : context.registered_state->States()) {
+		s->TransactionRollback(*transaction, context, error);
 	}
 }
 

package/src/duckdb/src/transaction/undo_buffer.cpp

@@ -11,6 +11,8 @@
 #include "duckdb/transaction/commit_state.hpp"
 #include "duckdb/transaction/rollback_state.hpp"
 #include "duckdb/execution/index/bound_index.hpp"
+#include "duckdb/transaction/wal_write_state.hpp"
+#include "duckdb/transaction/delete_info.hpp"
 
 namespace duckdb {
 constexpr uint32_t UNDO_ENTRY_HEADER_SIZE = sizeof(UndoFlags) + sizeof(uint32_t);
@@ -122,9 +124,14 @@ UndoBufferProperties UndoBuffer::GetProperties() {
 		case UndoFlags::UPDATE_TUPLE:
 			properties.has_updates = true;
 			break;
-		case UndoFlags::DELETE_TUPLE:
+		case UndoFlags::DELETE_TUPLE: {
+			auto info = reinterpret_cast<DeleteInfo *>(data);
+			if (info->is_consecutive) {
+				properties.estimated_size += sizeof(row_t) * info->count;
+			}
 			properties.has_deletes = true;
 			break;
+		}
 		case UndoFlags::CATALOG_ENTRY: {
 			properties.has_catalog_changes = true;
 
@@ -151,7 +158,7 @@ UndoBufferProperties UndoBuffer::GetProperties() {
 	return properties;
 }
 
-void UndoBuffer::Cleanup() {
+void UndoBuffer::Cleanup(transaction_t lowest_active_transaction) {
 	// garbage collect everything in the Undo Chunk
 	// this should only happen if
 	//  (1) the transaction this UndoBuffer belongs to has successfully
@@ -160,7 +167,7 @@ void UndoBuffer::Cleanup() {
 	//      the chunks)
 	//  (2) there is no active transaction with start_id < commit_id of this
 	//  transaction
-	CleanupState state;
+	CleanupState state(lowest_active_transaction);
 	UndoBuffer::IteratorState iterator_state;
 	IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CleanupEntry(type, data); });
 
@@ -170,20 +177,19 @@ void UndoBuffer::Cleanup() {
 	}
 }
 
-void UndoBuffer::Commit(UndoBuffer::IteratorState &iterator_state, optional_ptr<WriteAheadLog> log,
-                        transaction_t commit_id) {
-	CommitState state(commit_id, log);
-	if (log) {
-		// commit WITH write ahead log
-		IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CommitEntry<true>(type, data); });
-	} else {
-		// commit WITHOUT write ahead log
-		IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CommitEntry<false>(type, data); });
-	}
+void UndoBuffer::WriteToWAL(WriteAheadLog &wal, optional_ptr<StorageCommitState> commit_state) {
+	WALWriteState state(wal, commit_state);
+	UndoBuffer::IteratorState iterator_state;
+	IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CommitEntry(type, data); });
+}
+
+void UndoBuffer::Commit(UndoBuffer::IteratorState &iterator_state, transaction_t commit_id) {
+	CommitState state(commit_id);
+	IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CommitEntry(type, data); });
 }
 
 void UndoBuffer::RevertCommit(UndoBuffer::IteratorState &end_state, transaction_t transaction_id) {
-	CommitState state(transaction_id, nullptr);
+	CommitState state(transaction_id);
 	UndoBuffer::IteratorState start_state;
 	IterateEntries(start_state, end_state, [&](UndoFlags type, data_ptr_t data) { state.RevertCommit(type, data); });
 }

package/src/duckdb/src/transaction/wal_write_state.cpp

@@ -0,0 +1,292 @@
+#include "duckdb/transaction/wal_write_state.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/type_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_set.hpp"
+#include "duckdb/catalog/duck_catalog.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
+#include "duckdb/common/serializer/memory_stream.hpp"
+#include "duckdb/storage/data_table.hpp"
+#include "duckdb/storage/table/chunk_info.hpp"
+#include "duckdb/storage/table/column_data.hpp"
+#include "duckdb/storage/table/row_group.hpp"
+#include "duckdb/storage/table/row_version_manager.hpp"
+#include "duckdb/storage/table/update_segment.hpp"
+#include "duckdb/storage/write_ahead_log.hpp"
+#include "duckdb/transaction/append_info.hpp"
+#include "duckdb/transaction/delete_info.hpp"
+#include "duckdb/transaction/update_info.hpp"
+
+namespace duckdb {
+
+WALWriteState::WALWriteState(WriteAheadLog &log, optional_ptr<StorageCommitState> commit_state)
+    : log(log), commit_state(commit_state), current_table_info(nullptr) {
+}
+
+void WALWriteState::SwitchTable(DataTableInfo *table_info, UndoFlags new_op) {
+	if (current_table_info != table_info) {
+		// write the current table to the log
+		log.WriteSetTable(table_info->GetSchemaName(), table_info->GetTableName());
+		current_table_info = table_info;
+	}
+}
+
+void WALWriteState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) {
+	if (entry.temporary || entry.Parent().temporary) {
+		return;
+	}
+
+	// look at the type of the parent entry
+	auto &parent = entry.Parent();
+
+	switch (parent.type) {
+	case CatalogType::TABLE_ENTRY:
+	case CatalogType::VIEW_ENTRY:
+	case CatalogType::INDEX_ENTRY:
+	case CatalogType::SEQUENCE_ENTRY:
+	case CatalogType::TYPE_ENTRY:
+	case CatalogType::MACRO_ENTRY:
+	case CatalogType::TABLE_MACRO_ENTRY:
+		if (entry.type == CatalogType::RENAMED_ENTRY || entry.type == parent.type) {
+			// ALTER statement, read the extra data after the entry
+			auto extra_data_size = Load<idx_t>(dataptr);
+			auto extra_data = data_ptr_cast(dataptr + sizeof(idx_t));
+
+			MemoryStream source(extra_data, extra_data_size);
+			BinaryDeserializer deserializer(source);
+			deserializer.Begin();
+			auto column_name = deserializer.ReadProperty<string>(100, "column_name");
+			auto parse_info = deserializer.ReadProperty<unique_ptr<ParseInfo>>(101, "alter_info");
+			deserializer.End();
+
+			auto &alter_info = parse_info->Cast<AlterInfo>();
+			log.WriteAlter(alter_info);
+		} else {
+			switch (parent.type) {
+			case CatalogType::TABLE_ENTRY:
+				// CREATE TABLE statement
+				log.WriteCreateTable(parent.Cast<TableCatalogEntry>());
+				break;
+			case CatalogType::VIEW_ENTRY:
+				// CREATE VIEW statement
+				log.WriteCreateView(parent.Cast<ViewCatalogEntry>());
+				break;
+			case CatalogType::INDEX_ENTRY:
+				// CREATE INDEX statement
+				log.WriteCreateIndex(parent.Cast<IndexCatalogEntry>());
+				break;
+			case CatalogType::SEQUENCE_ENTRY:
+				// CREATE SEQUENCE statement
+				log.WriteCreateSequence(parent.Cast<SequenceCatalogEntry>());
+				break;
+			case CatalogType::TYPE_ENTRY:
+				// CREATE TYPE statement
+				log.WriteCreateType(parent.Cast<TypeCatalogEntry>());
+				break;
+			case CatalogType::MACRO_ENTRY:
+				log.WriteCreateMacro(parent.Cast<ScalarMacroCatalogEntry>());
+				break;
+			case CatalogType::TABLE_MACRO_ENTRY:
+				log.WriteCreateTableMacro(parent.Cast<TableMacroCatalogEntry>());
+				break;
+			default:
+				throw InternalException("Don't know how to create this type!");
+			}
+		}
+		break;
+	case CatalogType::SCHEMA_ENTRY:
+		if (entry.type == CatalogType::RENAMED_ENTRY || entry.type == CatalogType::SCHEMA_ENTRY) {
+			// ALTER TABLE statement, skip it
+			return;
+		}
+		log.WriteCreateSchema(parent.Cast<SchemaCatalogEntry>());
+		break;
+	case CatalogType::RENAMED_ENTRY:
+		// This is a rename, nothing needs to be done for this
+		break;
+	case CatalogType::DELETED_ENTRY:
+		switch (entry.type) {
+		case CatalogType::TABLE_ENTRY: {
+			auto &table_entry = entry.Cast<DuckTableEntry>();
+			D_ASSERT(table_entry.IsDuckTable());
+			log.WriteDropTable(table_entry);
+			break;
+		}
+		case CatalogType::SCHEMA_ENTRY:
+			log.WriteDropSchema(entry.Cast<SchemaCatalogEntry>());
+			break;
+		case CatalogType::VIEW_ENTRY:
+			log.WriteDropView(entry.Cast<ViewCatalogEntry>());
+			break;
+		case CatalogType::SEQUENCE_ENTRY:
+			log.WriteDropSequence(entry.Cast<SequenceCatalogEntry>());
+			break;
+		case CatalogType::MACRO_ENTRY:
+			log.WriteDropMacro(entry.Cast<ScalarMacroCatalogEntry>());
+			break;
+		case CatalogType::TABLE_MACRO_ENTRY:
+			log.WriteDropTableMacro(entry.Cast<TableMacroCatalogEntry>());
+			break;
+		case CatalogType::TYPE_ENTRY:
+			log.WriteDropType(entry.Cast<TypeCatalogEntry>());
+			break;
+		case CatalogType::INDEX_ENTRY: {
+			log.WriteDropIndex(entry.Cast<IndexCatalogEntry>());
+			break;
+		}
+		case CatalogType::RENAMED_ENTRY:
+		case CatalogType::PREPARED_STATEMENT:
+		case CatalogType::SCALAR_FUNCTION_ENTRY:
+		case CatalogType::DEPENDENCY_ENTRY:
+		case CatalogType::SECRET_ENTRY:
+		case CatalogType::SECRET_TYPE_ENTRY:
+		case CatalogType::SECRET_FUNCTION_ENTRY:
+			// do nothing, prepared statements and scalar functions aren't persisted to disk
+			break;
+		default:
+			throw InternalException("Don't know how to drop this type!");
+		}
+		break;
+	case CatalogType::PREPARED_STATEMENT:
+	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
+	case CatalogType::SCALAR_FUNCTION_ENTRY:
+	case CatalogType::TABLE_FUNCTION_ENTRY:
+	case CatalogType::COPY_FUNCTION_ENTRY:
+	case CatalogType::PRAGMA_FUNCTION_ENTRY:
+	case CatalogType::COLLATION_ENTRY:
+	case CatalogType::DEPENDENCY_ENTRY:
+	case CatalogType::SECRET_ENTRY:
+	case CatalogType::SECRET_TYPE_ENTRY:
+	case CatalogType::SECRET_FUNCTION_ENTRY:
+		// do nothing, these entries are not persisted to disk
+		break;
+	default:
+		throw InternalException("UndoBuffer - don't know how to write this entry to the WAL");
+	}
+}
+
+void WALWriteState::WriteDelete(DeleteInfo &info) {
+	// switch to the current table, if necessary
+	SwitchTable(info.table->GetDataTableInfo().get(), UndoFlags::DELETE_TUPLE);
+
+	if (!delete_chunk) {
+		delete_chunk = make_uniq<DataChunk>();
+		vector<LogicalType> delete_types = {LogicalType::ROW_TYPE};
+		delete_chunk->Initialize(Allocator::DefaultAllocator(), delete_types);
+	}
+	auto rows = FlatVector::GetData<row_t>(delete_chunk->data[0]);
+	if (info.is_consecutive) {
+		for (idx_t i = 0; i < info.count; i++) {
+			rows[i] = UnsafeNumericCast<int64_t>(info.base_row + i);
+		}
+	} else {
+		auto delete_rows = info.GetRows();
+		for (idx_t i = 0; i < info.count; i++) {
+			rows[i] = UnsafeNumericCast<int64_t>(info.base_row) + delete_rows[i];
+		}
+	}
+	delete_chunk->SetCardinality(info.count);
+	log.WriteDelete(*delete_chunk);
+}
+
+void WALWriteState::WriteUpdate(UpdateInfo &info) {
+	// switch to the current table, if necessary
+	auto &column_data = info.segment->column_data;
+	auto &table_info = column_data.GetTableInfo();
+
+	SwitchTable(&table_info, UndoFlags::UPDATE_TUPLE);
+
+	// initialize the update chunk
+	vector<LogicalType> update_types;
+	if (column_data.type.id() == LogicalTypeId::VALIDITY) {
+		update_types.emplace_back(LogicalType::BOOLEAN);
+	} else {
+		update_types.push_back(column_data.type);
+	}
+	update_types.emplace_back(LogicalType::ROW_TYPE);
+
+	update_chunk = make_uniq<DataChunk>();
+	update_chunk->Initialize(Allocator::DefaultAllocator(), update_types);
+
+	// fetch the updated values from the base segment
+	info.segment->FetchCommitted(info.vector_index, update_chunk->data[0]);
+
+	// write the row ids into the chunk
+	auto row_ids = FlatVector::GetData<row_t>(update_chunk->data[1]);
+	idx_t start = column_data.start + info.vector_index * STANDARD_VECTOR_SIZE;
+	for (idx_t i = 0; i < info.N; i++) {
+		row_ids[info.tuples[i]] = UnsafeNumericCast<int64_t>(start + info.tuples[i]);
+	}
+	if (column_data.type.id() == LogicalTypeId::VALIDITY) {
+		// zero-initialize the booleans
+		// FIXME: this is only required because of NullValue<T> in Vector::Serialize...
+		auto booleans = FlatVector::GetData<bool>(update_chunk->data[0]);
+		for (idx_t i = 0; i < info.N; i++) {
+			auto idx = info.tuples[i];
+			booleans[idx] = false;
+		}
+	}
+	SelectionVector sel(info.tuples);
+	update_chunk->Slice(sel, info.N);
+
+	// construct the column index path
+	vector<column_t> column_indexes;
+	reference<ColumnData> current_column_data = column_data;
+	while (current_column_data.get().parent) {
+		column_indexes.push_back(current_column_data.get().column_index);
+		current_column_data = *current_column_data.get().parent;
+	}
+	column_indexes.push_back(info.column_index);
+	std::reverse(column_indexes.begin(), column_indexes.end());
+
+	log.WriteUpdate(*update_chunk, column_indexes);
+}
+
+void WALWriteState::CommitEntry(UndoFlags type, data_ptr_t data) {
+	switch (type) {
+	case UndoFlags::CATALOG_ENTRY: {
+		// set the commit timestamp of the catalog entry to the given id
+		auto catalog_entry = Load<CatalogEntry *>(data);
+		D_ASSERT(catalog_entry->HasParent());
+		// push the catalog update to the WAL
+		WriteCatalogEntry(*catalog_entry, data + sizeof(CatalogEntry *));
+		break;
+	}
+	case UndoFlags::INSERT_TUPLE: {
+		// append:
+		auto info = reinterpret_cast<AppendInfo *>(data);
+		if (!info->table->IsTemporary()) {
+			info->table->WriteToLog(log, info->start_row, info->count, commit_state.get());
+		}
+		break;
+	}
+	case UndoFlags::DELETE_TUPLE: {
+		// deletion:
+		auto info = reinterpret_cast<DeleteInfo *>(data);
+		if (!info->table->IsTemporary()) {
+			WriteDelete(*info);
+		}
+		break;
+	}
+	case UndoFlags::UPDATE_TUPLE: {
+		// update:
+		auto info = reinterpret_cast<UpdateInfo *>(data);
+		if (!info->segment->column_data.GetTableInfo().IsTemporary()) {
+			WriteUpdate(*info);
+		}
+		break;
+	}
+	case UndoFlags::SEQUENCE_VALUE: {
+		auto info = reinterpret_cast<SequenceValue *>(data);
+		log.WriteSequenceValue(*info);
+		break;
+	}
+	default:
+		throw InternalException("UndoBuffer - don't know how to commit this type!");
+	}
+}
+
+} // namespace duckdb

package/src/duckdb/src/verification/prepared_statement_verifier.cpp

@@ -22,7 +22,6 @@ void PreparedStatementVerifier::Extract() {
 	// replace all the constants from the select statement and replace them with parameter expressions
 	ParsedExpressionIterator::EnumerateQueryNodeChildren(
 	    *select.node, [&](unique_ptr<ParsedExpression> &child) { ConvertConstants(child); });
-	statement->n_param = values.size();
 	for (auto &kv : values) {
 		statement->named_param_map[kv.first] = 0;
 	}

package/src/duckdb/third_party/brotli/common/brotli_constants.h

@@ -0,0 +1,204 @@
+/* Copyright 2016 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+/**
+ * @file
+ * Common constants used in decoder and encoder API.
+ */
+
+#ifndef BROTLI_COMMON_CONSTANTS_H_
+#define BROTLI_COMMON_CONSTANTS_H_
+
+#include <brotli/port.h>
+#include <brotli/types.h>
+
+#include "brotli_platform.h"
+
+namespace  duckdb_brotli {
+
+/* Specification: 7.3. Encoding of the context map */
+#define BROTLI_CONTEXT_MAP_MAX_RLE 16
+
+/* Specification: 2. Compressed representation overview */
+#define BROTLI_MAX_NUMBER_OF_BLOCK_TYPES 256
+
+/* Specification: 3.3. Alphabet sizes: insert-and-copy length */
+#define BROTLI_NUM_LITERAL_SYMBOLS 256
+#define BROTLI_NUM_COMMAND_SYMBOLS 704
+#define BROTLI_NUM_BLOCK_LEN_SYMBOLS 26
+#define BROTLI_MAX_CONTEXT_MAP_SYMBOLS (BROTLI_MAX_NUMBER_OF_BLOCK_TYPES + \
+                                        BROTLI_CONTEXT_MAP_MAX_RLE)
+#define BROTLI_MAX_BLOCK_TYPE_SYMBOLS (BROTLI_MAX_NUMBER_OF_BLOCK_TYPES + 2)
+
+/* Specification: 3.5. Complex prefix codes */
+#define BROTLI_REPEAT_PREVIOUS_CODE_LENGTH 16
+#define BROTLI_REPEAT_ZERO_CODE_LENGTH 17
+#define BROTLI_CODE_LENGTH_CODES (BROTLI_REPEAT_ZERO_CODE_LENGTH + 1)
+/* "code length of 8 is repeated" */
+#define BROTLI_INITIAL_REPEATED_CODE_LENGTH 8
+
+/* "Large Window Brotli" */
+
+/**
+ * The theoretical maximum number of distance bits specified for large window
+ * brotli, for 64-bit encoders and decoders. Even when in practice 32-bit
+ * encoders and decoders only support up to 30 max distance bits, the value is
+ * set to 62 because it affects the large window brotli file format.
+ * Specifically, it affects the encoding of simple huffman tree for distances,
+ * see Specification RFC 7932 chapter 3.4.
+ */
+#define BROTLI_LARGE_MAX_DISTANCE_BITS 62U
+#define BROTLI_LARGE_MIN_WBITS 10
+/**
+ * The maximum supported large brotli window bits by the encoder and decoder.
+ * Large window brotli allows up to 62 bits, however the current encoder and
+ * decoder, designed for 32-bit integers, only support up to 30 bits maximum.
+ */
+#define BROTLI_LARGE_MAX_WBITS 30
+
+/* Specification: 4. Encoding of distances */
+#define BROTLI_NUM_DISTANCE_SHORT_CODES 16
+/**
+ * Maximal number of "postfix" bits.
+ *
+ * Number of "postfix" bits is stored as 2 bits in meta-block header.
+ */
+#define BROTLI_MAX_NPOSTFIX 3
+#define BROTLI_MAX_NDIRECT 120
+#define BROTLI_MAX_DISTANCE_BITS 24U
+#define BROTLI_DISTANCE_ALPHABET_SIZE(NPOSTFIX, NDIRECT, MAXNBITS) ( \
+    BROTLI_NUM_DISTANCE_SHORT_CODES + (NDIRECT) +                    \
+    ((MAXNBITS) << ((NPOSTFIX) + 1)))
+/* BROTLI_NUM_DISTANCE_SYMBOLS == 1128 */
+#define BROTLI_NUM_DISTANCE_SYMBOLS \
+    BROTLI_DISTANCE_ALPHABET_SIZE(  \
+        BROTLI_MAX_NDIRECT, BROTLI_MAX_NPOSTFIX, BROTLI_LARGE_MAX_DISTANCE_BITS)
+
+/* ((1 << 26) - 4) is the maximal distance that can be expressed in RFC 7932
+   brotli stream using NPOSTFIX = 0 and NDIRECT = 0. With other NPOSTFIX and
+   NDIRECT values distances up to ((1 << 29) + 88) could be expressed. */
+#define BROTLI_MAX_DISTANCE 0x3FFFFFC
+
+/* ((1 << 31) - 4) is the safe distance limit. Using this number as a limit
+   allows safe distance calculation without overflows, given the distance
+   alphabet size is limited to corresponding size
+   (see kLargeWindowDistanceCodeLimits). */
+#define BROTLI_MAX_ALLOWED_DISTANCE 0x7FFFFFFC
+
+
+/* Specification: 4. Encoding of Literal Insertion Lengths and Copy Lengths */
+#define BROTLI_NUM_INS_COPY_CODES 24
+
+/* 7.1. Context modes and context ID lookup for literals */
+/* "context IDs for literals are in the range of 0..63" */
+#define BROTLI_LITERAL_CONTEXT_BITS 6
+
+/* 7.2. Context ID for distances */
+#define BROTLI_DISTANCE_CONTEXT_BITS 2
+
+/* 9.1. Format of the Stream Header */
+/* Number of slack bytes for window size. Don't confuse
+   with BROTLI_NUM_DISTANCE_SHORT_CODES. */
+#define BROTLI_WINDOW_GAP 16
+#define BROTLI_MAX_BACKWARD_LIMIT(W) (((size_t)1 << (W)) - BROTLI_WINDOW_GAP)
+
+typedef struct BrotliDistanceCodeLimit {
+  uint32_t max_alphabet_size;
+  uint32_t max_distance;
+} BrotliDistanceCodeLimit;
+
+/* This function calculates maximal size of distance alphabet, such that the
+   distances greater than the given values can not be represented.
+
+   This limits are designed to support fast and safe 32-bit decoders.
+   "32-bit" means that signed integer values up to ((1 << 31) - 1) could be
+   safely expressed.
+
+   Brotli distance alphabet symbols do not represent consecutive distance
+   ranges. Each distance alphabet symbol (excluding direct distances and short
+   codes), represent interleaved (for NPOSTFIX > 0) range of distances.
+   A "group" of consecutive (1 << NPOSTFIX) symbols represent non-interleaved
+   range. Two consecutive groups require the same amount of "extra bits".
+
+   It is important that distance alphabet represents complete "groups".
+   To avoid complex logic on encoder side about interleaved ranges
+   it was decided to restrict both sides to complete distance code "groups".
+ */
+BROTLI_UNUSED_FUNCTION BrotliDistanceCodeLimit BrotliCalculateDistanceCodeLimit(
+    uint32_t max_distance, uint32_t npostfix, uint32_t ndirect) {
+  BrotliDistanceCodeLimit result;
+  /* Marking this function as unused, because not all files
+     including "constants.h" use it -> compiler warns about that. */
+  BROTLI_UNUSED(&BrotliCalculateDistanceCodeLimit);
+  if (max_distance <= ndirect) {
+    /* This case never happens / exists only for the sake of completeness. */
+    result.max_alphabet_size = max_distance + BROTLI_NUM_DISTANCE_SHORT_CODES;
+    result.max_distance = max_distance;
+    return result;
+  } else {
+    /* The first prohibited value. */
+    uint32_t forbidden_distance = max_distance + 1;
+    /* Subtract "directly" encoded region. */
+    uint32_t offset = forbidden_distance - ndirect - 1;
+    uint32_t ndistbits = 0;
+    uint32_t tmp;
+    uint32_t half;
+    uint32_t group;
+    /* Postfix for the last dcode in the group. */
+    uint32_t postfix = (1u << npostfix) - 1;
+    uint32_t extra;
+    uint32_t start;
+    /* Remove postfix and "head-start". */
+    offset = (offset >> npostfix) + 4;
+    /* Calculate the number of distance bits. */
+    tmp = offset / 2;
+    /* Poor-man's log2floor, to avoid extra dependencies. */
+    while (tmp != 0) {ndistbits++; tmp = tmp >> 1;}
+    /* One bit is covered with subrange addressing ("half"). */
+    ndistbits--;
+    /* Find subrange. */
+    half = (offset >> ndistbits) & 1;
+    /* Calculate the "group" part of dcode. */
+    group = ((ndistbits - 1) << 1) | half;
+    /* Calculated "group" covers the prohibited distance value. */
+    if (group == 0) {
+      /* This case is added for correctness; does not occur for limit > 128. */
+      result.max_alphabet_size = ndirect + BROTLI_NUM_DISTANCE_SHORT_CODES;
+      result.max_distance = ndirect;
+      return result;
+    }
+    /* Decrement "group", so it is the last permitted "group". */
+    group--;
+    /* After group was decremented, ndistbits and half must be recalculated. */
+    ndistbits = (group >> 1) + 1;
+    /* The last available distance in the subrange has all extra bits set. */
+    extra = (1u << ndistbits) - 1;
+    /* Calculate region start. NB: ndistbits >= 1. */
+    start = (1u << (ndistbits + 1)) - 4;
+    /* Move to subregion. */
+    start += (group & 1) << ndistbits;
+    /* Calculate the alphabet size. */
+    result.max_alphabet_size = ((group << npostfix) | postfix) + ndirect +
+        BROTLI_NUM_DISTANCE_SHORT_CODES + 1;
+    /* Calculate the maximal distance representable by alphabet. */
+    result.max_distance = ((start + extra) << npostfix) + postfix + ndirect + 1;
+    return result;
+  }
+}
+
+/* Represents the range of values belonging to a prefix code:
+   [offset, offset + 2^nbits) */
+typedef struct {
+  uint16_t offset;
+  uint8_t nbits;
+} BrotliPrefixCodeRange;
+
+/* "Soft-private", it is exported, but not "advertised" as API. */
+BROTLI_COMMON_API extern const BrotliPrefixCodeRange
+    _kBrotliPrefixCodeRanges[BROTLI_NUM_BLOCK_LEN_SYMBOLS];
+
+}
+#endif  /* BROTLI_COMMON_CONSTANTS_H_ */