WoWDev Wiki

https://wowdev.wiki/DB/
Admin
WoWDev Wiki is a comprehensive technical documentation resource for World of Warcraft development,...
Tokens:18,206
Snippets:132
Trust Score:8.2
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example Record Structure with String Reference

Source: https://wowdev.wiki/DBC

Illustrates a record structure that includes an ID and a reference to a string stored in the string block.

```cpp
using stringrefⁱ = uint32_t;
struct example_record
{
  uint32_t id;
  stringrefⁱ name;
};
```

--------------------------------

### WDB2 File Structure

Source: https://wowdev.wiki/DB2

Defines the structure of a WDB2 file, used in World of Warcraft from Cataclysm to early Legion. It includes header information, record mapping, and string table size.

```c++
struct db2_header
{
  uint32_t magic;                                               // 'WDB2'
  uint32_t record_count;
  uint32_t field_count;                                         // array fields count as the size of array for WDB2
  uint32_t record_size;
  uint32_t string_table_size;                                   // string block almost always contains at least one zero-byte
  uint32_t table_hash;
  uint32_t build;
  uint32_t timestamp_last_written;                              // set to time(0); when writing in WowClientDB2_Base::Save()
  uint32_t min_id;
  uint32_t max_id;
  uint32_t locale;                                              // as seen in TextWowEnum
  uint32_t copy_table_size;                                     // always zero in WDB2 (?) - see WDB3 for information on how to parse this
};

template<typename record_type>
struct db2_file
{
  db2_header header;

  if (header.max_id = 0)
  {
    int indices[header.max_id - header.min_id + 1];             // maps from id to row index in records[] below
    short string_lengths[header.max_id - header.min_id + 1];    // sum of lengths of all strings in row
  }
 
  record_type records[header.record_count];*
  char string_table[header.string_table_size];
};
```

--------------------------------

### Accessing DBC Record Data by Offset

Source: https://wowdev.wiki/DBC

Shows how to access and print record data, including ID and name, by directly calculating offsets within the raw file data.

```c
// const char* file;
uint32_t record_count = *(uint32_t*) (file + 1 * sizeof (uint32_t));
uint32_t record_size = *(uint32_t*) (file + 3 * sizeof (uint32_t));
const char* records = file + 5 * sizeof (uint32_t) /* header */;
const char* string_block = records + record_size * record_count;
printf ("record %u: %u, %s\n", *(uint32_t*)(records + i * record_size /* id */), string_block + *(uint32_t*)(records + i * record_size + sizeof (uint32_t) /* name */));
```

--------------------------------

### WDC2 Data Structure

Source: https://wowdev.wiki/DB2

Illustrates the arrangement of records and string data across multiple sections in the WDC2 file format. The client loads all data into a single binary array.

```text
 section[0].records, section[1].records, ..., section[section_count-1].records, section[0].string_data, section[1].string_data, ..., section[section_count-1].string_data

```

--------------------------------

### Printing Record ID and Name

Source: https://wowdev.wiki/DBC

Demonstrates how to print the ID and name of a record from a DBC file, accessing the string block using the string reference.

```c
// dbc_file<example_record> file;
printf ("record %u: %u, %s\n", file.records[i].id, file.string_block[file.records[i].name]);
```

--------------------------------

### WDB6 File Structure Template

Source: https://wowdev.wiki/DB2

Generic template for a WDB6 file, accommodating different record types.

```c++
template<typename record_type>
struct wdb6_file
{
  wdb6_db2_header header;
  struct field_structure
  {
    int16_t size;                                               // size in bits as calculated by: byteSize = (32 - size) / 8; this value can be negative to indicate field sizes larger than 32-bits
    uint16_t position;                                          // position of the field within the record, relative to the start of the record
  };
  field_structure fields[header.field_count];
  record_type records[header.record_count];
  char string_table[header.string_table_size];
  if (header.flags & 0x01 << 0 != 0)
  {
    struct offset_map_entry
    {
      uint32_t offset;                                          // this offset is absolute, not relative to another structure; this can (and often will) be zero, in which case you should ignore that entry and move on
      uint16_t length;                                          // this is the length of the record located at the specified offset
    };
    offset_map_entry offset_map[header.max_id - header.min_id + 1];
  }
  if (header.flags & 0x02 << 0 != 0)
  {
    uint32_t relationship_IDs[header.max_id - header.min_id + 1]; // only ever used by wmominimaptexture.db2 to record WMOIDs
  }
  if (header.flags & 0x04 << 0 != 0)
  {
    uint32_t IDs[header.record_count];
  }
  if (header.copy_table_size > 0)
  {
    struct copy_table_entry
    {
      uint32_t id_of_new_row;
      uint32_t id_of_copied_row;
    };
    copy_table_entry copy_table[header.copy_table_size / sizeof(copy_table_entry)];
  }
  if (header.common_data_table_size > 0)
  {
    uint32_t num_columns_in_table;
    struct common_data_map_entry
    {
      uint32_t id;
      uint32_t value;                                            // Calling this 'uint32_t' is an oversimplification - the size of this field depends on the 'type' from the enum 
                                                                 // (From Patch 7.3.0 Build 24473 onwards, this is no longer true. Values are always padded out to 4 bytes.)
    };
    struct common_data_table_entry
    {
      uint32_t count;
      uint8_t type;                                              // New enum: string = 0, short = 1, byte = 2, float = 3, int = 4 (int64 = 5??)
      common_data_map_entry common_data_map[count];
    };
    common_data_table_entry common_data_table[num_columns_in_table];
  }
};
```

--------------------------------

### WDB3 File Structure

Source: https://wowdev.wiki/DB2

Defines the structure of a WDB3 file, used briefly in Legion. It includes an optional offset map for inline strings and other optional blocks for IDs and deduplicated data.

```c++
template<typename record_type>
struct wdb3_file
{
  db2_header header;
  struct offset_map_entry
  {
    uint32_t offset;                                             // This offset is absolute, not relative to another structure; this can (and often will) be zero, in which case you should ignore that entry and move on
    uint16_t length;                                             // This is the length of the record located at the specified offset
  };
  offset_map_entry offset_map[header.max_id - header.min_id + 1];*
  uint32_t relationship_IDs[header.max_id - header.min_id + 1];* // only ever used by wmominimaptexture.db2 to record WMOIDs
  record_type records[header.record_count]; 
  char string_table[header.string_table_size];
  uint32_t IDs[header.record_count];*
  if (header.copy_table_size > 0)
  {
    struct copy_table_entry
    {
      uint32_t id_of_new_row;
      uint32_t id_of_copied_row;
    };
    copy_table_entry copy_table[header.copy_table_size / sizeof(copy_table_entry)];
  }
};
```

--------------------------------

### WDB5 File Structure Template

Source: https://wowdev.wiki/DB2

A template structure for WDB5 files, accommodating generic record types. It includes header, field definitions, records, and conditional data sections based on flags.

```cpp
template<typename record_type>
struct wdb5_file
{
  wdb5_db2_header header;
  struct field_structure
  {
    int16_t size;                                               // size in bits as calculated by: byteSize = (32 - size) / 8; this value can be negative to indicate field sizes larger than 32-bits
    uint16_t position;                                          // position of the field within the record, relative to the start of the record
  };
  field_structure fields[header.field_count];
  record_type records[header.record_count];
  char string_table[header.string_table_size];
  if (flags & 0x01 != 0)
  {
    struct offset_map_entry
    {
      uint32_t offset;                                          // this offset is absolute, not relative to another structure; this can (and often will) be zero, in which case you should ignore that entry and move on
      uint16_t length;                                          // this is the length of the record located at the specified offset
    };
    offset_map_entry offset_map[header.max_id - header.min_id + 1];
  }
  if (flags & 0x02 != 0)
  {
    uint32_t relationship_IDs[header.max_id - header.min_id + 1]; // only ever used by wmominimaptexture.db2 to record WMOIDs
  }
  if (flags & 0x04 != 0)
  {
    uint32_t IDs[header.record_count];
  }
  if (header.copy_table_size > 0)
  {
    struct copy_table_entry
    {
      uint32_t id_of_new_row;
      uint32_t id_of_copied_row;
    };
    copy_table_entry copy_table[header.copy_table_size / sizeof(copy_table_entry)];
  }
};
```

--------------------------------

### Database Data Storage Layout

Source: https://wowdev.wiki/DB2

Illustrates the layout of various data storage sections within the database, including ID lists, copy tables, field storage info, palette data, common data, and relationship mappings.

```c
uint32_t id_list[header.id_list_size / 4];
if (header.copy_table_size > 0) {
  struct copy_table_entry
  {
    uint32_t id_of_new_row;
    uint32_t id_of_copied_row;
  };
  copy_table_entry copy_table[header.copy_table_size / sizeof(copy_table_entry)];
}
field_storage_info field_info[header.field_storage_info_size / sizeof(field_storage_info)];
char pallet_data[header.pallet_data_size];
char common_data[header.common_data_size];
```

```c
if (header.relationship_data_size > 0) {
  // In some tables, this relationship mapping replaced columns that were used
  // only as a lookup, such as the SpellID in SpellX* tables.
  struct relationship_entry
  {
    // This is the id of the foreign key for the record, e.g. SpellID in
    // SpellX* tables.
    uint32_t foreign_id;
    // This is the index of the record in record_data.  Note that this is
    // *not* the record's own ID.
    uint32_t record_index;
  };
  struct relationship_mapping
  {
    uint32_t            num_entries;
    uint32_t            min_id;
    uint32_t            max_id;
    relationship_entry  entries[num_entries];
  };
  relationship_mapping relationship_map;
}
```

--------------------------------

### WDC5 DB2 Header Structure

Source: https://wowdev.wiki/DB2

Defines the main header for WDC5 DB2 files. Contains metadata about the table, record counts, and layout.

```c++
struct wdc5_db2_header
{
  uint32_t magic;                  // 'WDC5'
  uint32_t versionNum;             // 5, probably numeric version?
  char schemaString[128];          // "WowStatic_Patch_10_2_5" + padding in 10.2.5.52432
  uint32_t record_count;           // this is for all sections combined now
  uint32_t field_count;
  uint32_t record_size;
  uint32_t string_table_size;      // this is for all sections combined now
  uint32_t table_hash;             // hash of the table name
  uint32_t layout_hash;            // this is a hash field that changes only when the structure of the data changes
  uint32_t min_id;
  uint32_t max_id;
  uint32_t locale;                 // as seen in TextWowEnum
  uint16_t flags;                  // possible values are listed in Known Flag Meanings
  uint16_t id_index;               // this is the index of the field containing ID values; this is ignored if flags & 0x04 == 0
  uint32_t total_field_count;      // from WDC1 onwards, this value seems to always be the same as the 'field_count' value
  uint32_t bitpacked_data_offset;  // relative position in record where bitpacked data begins; not important for parsing the file
  uint32_t lookup_column_count;
  uint32_t field_storage_info_size;
  uint32_t common_data_size;
  uint32_t pallet_data_size;
  uint32_t section_count;          // new to WDC2, this is number of sections of data
};
wdc5_db2_header header;
```

--------------------------------

### Field Storage Info Structure

Source: https://wowdev.wiki/DB2

Provides details on how a field's data is stored, including bit offset and size, crucial for bitpacked fields.

```c++
struct field_storage_info
{
  uint16_t          field_offset_bits;
  uint16_t          field_size_bits; // very important for reading bitpacked fields; size is the sum of all array pieces in bits - for example, uint32[3] will appear here as '96'
  // additional_data_size is the size in bytes of the corresponding section in
  // common_data or pallet_data.  These sections are in the same order as the
  // field_info, so to find the offset, add up the additional_data_size of any
```

--------------------------------

### Generic DBC File Structure

Source: https://wowdev.wiki/DBC

A template structure representing a generic DBC file, including its header, records, and string block.

```cpp
template<typename record_type>
struct dbc_file
{
  dbc_header header;
  // static_assert (header.record_size == sizeof (record_type));
  record_type records[header.record_count];
  char string_block[header.string_block_size];
};
```

--------------------------------

### Field Compression Data Structures

Source: https://wowdev.wiki/DB2

Defines the structure for different field compression types used in the database. Includes fields for bitpacking, flags, and default values depending on the compression method.

```c
case field_compression.field_compression_common_data:
      uint32_t default_value;
      uint32_t unk_or_unused2;
      uint32_t unk_or_unused3;
      break;
    case field_compression.field_compression_bitpacked_indexed:
      uint32_t bitpacking_offset_bits; // not useful for most purposes; formula they use to calculate is bitpacking_offset_bits = field_offset_bits - (header.bitpacked_data_offset * 8)
      uint32_t bitpacking_size_bits; // not useful for most purposes
      uint32_t unk_or_unused3;
      break;
    case field_compression.field_compression_bitpacked_indexed_array:
      uint32_t bitpacking_offset_bits; // not useful for most purposes; formula they use to calculate is bitpacking_offset_bits = field_offset_bits - (header.bitpacked_data_offset * 8)
      uint32_t bitpacking_size_bits; // not useful for most purposes
      uint32_t array_count;
      break;
    default:
      uint32_t unk_or_unused1;
      uint32_t unk_or_unused2;
      uint32_t unk_or_unused3;
      break;
```

--------------------------------

### Field Storage Info Structure

Source: https://wowdev.wiki/DB2

Provides detailed information about how a field's data is stored, especially for bitpacked or indexed fields. Includes bit offsets, sizes, and the storage type.

```c++
struct field_storage_info
{
  uint16_t          field_offset_bits;
  uint16_t          field_size_bits;
  uint32_t          additional_data_size;
  field_compression storage_type;
  switch (storage_type)
  {
    case field_compression.field_compression_bitpacked:
    case field_compression.field_compression_bitpacked_signed:
      uint32_t bitpacking_offset_bits;
  }
};
```

--------------------------------

### Field Compression Logic

Source: https://wowdev.wiki/DB2

This C++ code snippet illustrates the conditional logic for handling different field compression types within a data block. It shows how `additional_data_size` and `storage_type` determine the subsequent fields.

```cpp
uint32_t          additional_data_size;
  field_compression storage_type;
  switch (storage_type)
  {
    case field_compression.field_compression_bitpacked:
    case field_compression.field_compression_bitpacked_signed:
      uint32_t bitpacking_offset_bits; // not useful for most purposes; formula they use to calculate is bitpacking_offset_bits = field_offset_bits - (header.bitpacked_data_offset * 8)
      uint32_t bitpacking_size_bits; // not useful for most purposes
      uint32_t flags; // known values - 0x01: sign-extend (signed)
      break;
    case field_compression.field_compression_common_data:
      uint32_t default_value;
      uint32_t unk_or_unused2;
      uint32_t unk_or_unused3;
      break;
    case field_compression.field_compression_bitpacked_indexed:
      uint32_t bitpacking_offset_bits; // not useful for most purposes; formula they use to calculate is bitpacking_offset_bits = field_offset_bits - (header.bitpacked_data_offset * 8)
      uint32_t bitpacking_size_bits; // not useful for most purposes
      uint32_t unk_or_unused3;
      break;
    case field_compression.field_compression_bitpacked_indexed_array:
      uint32_t bitpacking_offset_bits; // not useful for most purposes; formula they use to calculate is bitpacking_offset_bits = field_offset_bits - (header.bitpacked_data_offset * 8)
      uint32_t bitpacking_size_bits; // not useful for most purposes
      uint32_t array_count;
      break;
    default:
      uint32_t unk_or_unused1;
      uint32_t unk_or_unused2;
      uint32_t unk_or_unused3;
      break;
  }
};
```

--------------------------------

### Table Hash Naming Convention

Source: https://wowdev.wiki/DB2

Explains how table names are converted into hashes for use with `SStrHash`. The process involves removing the `.db2` extension and path, and implicitly uppercasing the name before hashing.

```plaintext
# Table Hashes
Table Hashes are the name without .db2 or path, e.g. "ZoneStory", slapped into `SStrHash (table_name, false, 0)` (i.e. implicitly uppercased).

```

--------------------------------

### WDC1 DB2 File Header Structure

Source: https://wowdev.wiki/DB2

Defines the header structure for WDC1 DB2 files, containing metadata like record counts, string table size, and various hashes.

```c
struct wdc1_db2_header
{
  uint32_t magic;
  uint32_t record_count;
  uint32_t field_count;
  uint32_t record_size;
  uint32_t string_table_size;
  uint32_t table_hash;
  uint32_t layout_hash;
  uint32_t min_id;
  uint32_t max_id;
  uint32_t locale;
  uint32_t copy_table_size;
  uint16_t flags;
  uint16_t id_index;
  uint32_t total_field_count;
  uint32_t bitpacked_data_offset;
  uint32_t lookup_column_count;
  uint32_t offset_map_offset;
  uint32_t id_list_size;
  uint32_t field_storage_info_size;
  uint32_t common_data_size;
  uint32_t pallet_data_size;
  uint32_t relationship_data_size;
};

wdc1_db2_header header;
```

--------------------------------

### Field Compression Types in C

Source: https://wowdev.wiki/DB2

Defines different field compression types used in WDC5 files. These include bitpacked, bitpacked_signed, common_data, and indexed variants.

```c
case field_compression.field_compression_bitpacked:
    case field_compression.field_compression_bitpacked_signed:
      uint32_t bitpacking_offset_bits; // not useful for most purposes; formula they use to calculate is bitpacking_offset_bits = field_offset_bits - (header.bitpacked_data_offset * 8)
      uint32_t bitpacking_size_bits; // not useful for most purposes
      uint32_t flags; // known values - 0x01: sign-extend (signed)
      break;
    case field_compression.field_compression_common_data:
      uint32_t default_value;
      uint32_t unk_or_unused2;
      uint32_t unk_or_unused3;
      break;
    case field_compression.field_compression_bitpacked_indexed:
      uint32_t bitpacking_offset_bits; // not useful for most purposes; formula they use to calculate is bitpacking_offset_bits = field_offset_bits - (header.bitpacked_data_offset * 8)
      uint32_t bitpacking_size_bits; // not useful for most purposes
      uint32_t unk_or_unused3;
      break;
    case field_compression.field_compression_bitpacked_indexed_array:
      uint32_t bitpacking_offset_bits; // not useful for most purposes; formula they use to calculate is bitpacking_offset_bits = field_offset_bits - (header.bitpacked_data_offset * 8)
      uint32_t bitpacking_size_bits; // not useful for most purposes
      uint32_t array_count;
      break;
    default:
      uint32_t unk_or_unused1;
      uint32_t unk_or_unused2;
      uint32_t unk_or_unused3;
      break;
  }
};
```

--------------------------------

### WDC2 DB2 Header Structure

Source: https://wowdev.wiki/DB2

Defines the main header structure for WDC2 DB2 files. Contains metadata about the table, record counts, and file layout.

```c++
struct wdc2_db2_header
{
  uint32_t magic;
  uint32_t record_count;
  uint32_t field_count;
  uint32_t record_size;
  uint32_t string_table_size;
  uint32_t table_hash;
  uint32_t layout_hash;
  uint32_t min_id;
  uint32_t max_id;
  uint32_t locale;
  uint16_t flags;
  uint16_t id_index;
  uint32_t total_field_count;
  uint32_t bitpacked_data_offset;
  uint32_t lookup_column_count;
  uint32_t field_storage_info_size;
  uint32_t common_data_size;
  uint32_t pallet_data_size;
  uint32_t section_count;
};
wdc2_db2_header header;
```

--------------------------------

### WDC1 Common Data Block Pseudocode

Source: https://wowdev.wiki/DB2

This pseudocode illustrates how to read common data blocks in WDC1, utilizing field_storage_info and additional_data_size. It treats map values as 32-bit integers and iterates through fields to determine common data counts.

```pseudocode
if (header.common_data_size) {
  local int i;
  local int count = 0;
  for (i = 0; i < header.total_field_count; ++i) {
    if (field_info[i].storage_type == field_compression_common_data) {
      count = field_info[i].additional_data_size / 8;
      struct common_data_table_entry {
        for (; count > 0; --count) {
          struct common_data_map_entry {
            uint id;
            uint raw_value;
           } common_data_map;
        }
      } common_data_table;
    }
  }
}
```

--------------------------------

### DBC File Header Structure

Source: https://wowdev.wiki/DBC

Defines the structure of the DBC file header, containing metadata about the file's contents.

```cpp
struct dbc_header
{
  uint32_t magic; // always 'WDBC'
  uint32_t record_count; // records per file
  uint32_t field_count; // fields per record
  uint32_t record_size; // sum (sizeof (field_type_i)) | 0 <= i < field_count. field_type_i is NOT defined in the files.
  uint32_t string_block_size;
};
```

--------------------------------

### DB2 Record Data Structures

Source: https://wowdev.wiki/DB2

Defines structures for handling normal and offset map records based on file flags.

```c
if ((header.flags & 1) == 0) {
  struct record_data
  {
    char data[header.record_size];
  };
  record_data records[header.record_count];
  char string_data[header.string_table_size];
} else {
  char variable_record_data[header.offset_map_offset - sizeof(wdc1_db2_header) - (sizeof(field_structure) * header.total_field_count)];
  struct offset_map_entry
  {
    uint32_t offset;
    uint16_t size;
  };
  offset_map_entry offset_map[header.max_id - header.min_id + 1];
}
```

--------------------------------

### Field Compression Data Structures

Source: https://wowdev.wiki/DB2

Defines structures for different field compression types used in the database. Includes common data, bitpacked indexed, and bitpacked indexed array formats.

```c
case field_compression.field_compression_common_data:
      uint32_t default_value;
      uint32_t unk_or_unused2;
      uint32_t unk_or_unused3;
      break;
    case field_compression.field_compression_bitpacked_indexed:
      uint32_t bitpacking_offset_bits; // not useful for most purposes; formula they use to calculate is bitpacking_offset_bits = field_offset_bits - (header.bitpacked_data_offset * 8)
      uint32_t bitpacking_size_bits; // not useful for most purposes
      uint32_t unk_or_unused3;
      break;
    case field_compression.field_compression_bitpacked_indexed_array:
      uint32_t bitpacking_offset_bits; // not useful for most purposes; formula they use to calculate is bitpacking_offset_bits = field_offset_bits - (header.bitpacked_data_offset * 8)
      uint32_t bitpacking_size_bits; // not useful for most purposes
      uint32_t array_count;
      break;
    default:
      uint32_t unk_or_unused1;
      uint32_t unk_or_unused2;
      uint32_t unk_or_unused3;
      break;
  }
};
```

--------------------------------

### WDB5 Database Header Structure

Source: https://wowdev.wiki/DB2

Defines the header for WDB5 database files, containing metadata like record counts, field counts, and table hashes. Note the 'magic' field indicates a .db2 file.

```cpp
struct wdb5_db2_header
{
  uint32_t magic;                                               // 'WDB5' for .db2 (database) 
  uint32_t record_count;
  uint32_t field_count;                                         // for the first time, this counts arrays as '1'; in the past, only the ADB variants have counted arrays as 1 field
  uint32_t record_size;
  uint32_t string_table_size;                                   // if flags & 0x01 != 0, this field takes on a new meaning - it becomes an absolute offset to the beginning of the offset_map
  uint32_t table_hash;
  uint32_t layout_hash;                                         // used to be 'build', but after build 21737, this is a new hash field that changes only when the structure of the data changes
  uint32_t min_id;
  uint32_t max_id;
  uint32_t locale;                                              // as seen in TextWowEnum
  uint32_t copy_table_size;
  uint16_t flags;                                               // possible values are listed in Known Flag Meanings
  uint16_t id_index;                                            // new in WDB5 (and only after build 21737), this is the index of the field containing ID values; this is ignored if flags & 0x04 != 0
};
```

--------------------------------

### Field Storage Info Structure

Source: https://wowdev.wiki/DB2

Contains detailed information about how a field's data is stored, including bit offset, size, additional data size, and storage type. Essential for accurate data retrieval.

```cpp
struct field_storage_info
{
  uint16_t          field_offset_bits;
  uint16_t          field_size_bits; // very important for reading bitpacked fields; size is the sum of all array pieces in bits - for example, uint32[3] will appear here as '96'
  // additional_data_size is the size in bytes of the corresponding section in
  // common_data or pallet_data.  These sections are in the same order as the
  // field_info, so to find the offset, add up the additional_data_size of any
  // previous fields which are stored in the same block (common_data or
  // pallet_data).
  uint32_t          additional_data_size;
  field_compression storage_type;
  switch (storage_type)
  {

```

--------------------------------

### Section Data Declaration in C

Source: https://wowdev.wiki/DB2

Declares arrays for field storage info, pallet data, and common data based on header sizes. Also includes a loop to process sections with non-zero tact_key_hash, initializing an encrypted_status structure.

```c
field_storage_info field_info[header.field_storage_info_size / sizeof(field_storage_info)];
char pallet_data[header.pallet_data_size];
char common_data[header.common_data_size];

// encrypted_status structure is only used on sections where tact_key_hash is not 0
local int i;
for (i = 0; i < header.section_count; ++i)
{
  if (section_headers[i].tact_key_hash == 0)
    continue;

  encrypted_status encrypted_records;
}
```

--------------------------------

### WDB4 File Structure Template

Source: https://wowdev.wiki/DB2

A C++ template defining the overall structure of a WDB4 file, including the header, records, string table, and optional offset map, relationship IDs, IDs, and copy table based on header flags.

```c++
template<typename record_type>
struct wdb4_file
{
  wdb4_db2_header header;
  record_type records[header.record_count]; 
  char string_table[header.string_table_size];
  if (flags & 0x01 << 0 != 0)
  {
    struct offset_map_entry
    {
      uint32_t offset;                                           // this offset is absolute, not relative to another structure; this can (and often will) be zero, in which case you should ignore that entry and move on
      uint16_t length;                                           // this is the length of the record located at the specified offset
    };
    offset_map_entry offset_map[header.max_id - header.min_id + 1];
  }
  if (flags & 0x02 << 0 != 0)
  {
    uint32_t relationship_IDs[header.max_id - header.min_id + 1]; // only ever used by wmominimaptexture.db2 to record WMOIDs
  }
  if (flags & 0x04 << 0 != 0)
  {
    uint32_t IDs[header.record_count];
  }
  if (header.copy_table_size > 0)
  {
    struct copy_table_entry
    {
      uint32_t id_of_new_row;
      uint32_t id_of_copied_row;
    };
    copy_table_entry copy_table[header.copy_table_size / sizeof(copy_table_entry)];
  }
};
```

--------------------------------

### Field Storage Info Structure

Source: https://wowdev.wiki/DB2

Provides detailed information about how a field's data is stored, including bit offset, size, additional data size, and storage type. Crucial for decompressing and reading field values.

```c++
struct field_storage_info
{
  uint16_t          field_offset_bits;
  uint16_t          field_size_bits; // very important for reading bitpacked fields; size is the sum of all array pieces in bits - for example, uint32[3] will appear here as '96'
  // additional_data_size is the size in bytes of the corresponding section in
  // common_data or pallet_data.  These sections are in the same order as the
  // field_info, so to find the offset, add up the additional_data_size of any
  // previous fields which are stored in the same block (common_data or
  // pallet_data).
  uint32_t          additional_data_size;
  field_compression storage_type;
  switch (storage_type)
  {
```

--------------------------------

### WDC4 DB2 File Header Structure

Source: https://wowdev.wiki/DB2

Defines the main header for WDC4 DB2 files, containing metadata about the table such as record counts, sizes, and hashes. Used for initial file parsing.

```c++
struct wdc4_db2_header
{
  uint32_t magic;                  // 'WDC4'
  uint32_t record_count;           // this is for all sections combined now
  uint32_t field_count;
  uint32_t record_size;
  uint32_t string_table_size;      // this is for all sections combined now
  uint32_t table_hash;             // hash of the table name
  uint32_t layout_hash;            // this is a hash field that changes only when the structure of the data changes
  uint32_t min_id;
  uint32_t max_id;
  uint32_t locale;                 // as seen in TextWowEnum
  uint16_t flags;                  // possible values are listed in Known Flag Meanings
  uint16_t id_index;               // this is the index of the field containing ID values; this is ignored if flags & 0x04 != 0
  uint32_t total_field_count;      // from WDC1 onwards, this value seems to always be the same as the 'field_count' value
  uint32_t bitpacked_data_offset;  // relative position in record where bitpacked data begins; not important for parsing the file
  uint32_t lookup_column_count;
  uint32_t field_storage_info_size;
  uint32_t common_data_size;
  uint32_t pallet_data_size;
  uint32_t section_count;          // new to WDC2, this is number of sections of data
};
wdc4_db2_header header;
```

--------------------------------

### WDC3 DB Header Structure

Source: https://wowdev.wiki/DB2

Defines the header for WDC3 DB files, containing metadata like record count, field count, and table hashes. Used for overall file information.

```cpp
struct wdc3_db2_header
{
  uint32_t magic;                  // 'WDC3'
  uint32_t record_count;           // this is for all sections combined now
  uint32_t field_count;
  uint32_t record_size;
  uint32_t string_table_size;      // this is for all sections combined now
  uint32_t table_hash;             // hash of the table name
  uint32_t layout_hash;            // this is a hash field that changes only when the structure of the data changes
  uint32_t min_id;
  uint32_t max_id;
  uint32_t locale;                 // as seen in TextWowEnum
  uint16_t flags;                  // possible values are listed in Known Flag Meanings
  uint16_t id_index;               // this is the index of the field containing ID values; this is ignored if flags & 0x04 != 0
  uint32_t total_field_count;      // from WDC1 onwards, this value seems to always be the same as the 'field_count' value
  uint32_t bitpacked_data_offset;  // relative position in record where bitpacked data begins; not important for parsing the file
  uint32_t lookup_column_count;
  uint32_t field_storage_info_size;
  uint32_t common_data_size;
  uint32_t pallet_data_size;
  uint32_t section_count;          // new to WDC2, this is number of sections of data
};
wdc3_db2_header header;
```

--------------------------------

### WDC5 Section Header Structure

Source: https://wowdev.wiki/DB2

Defines the header for each data section within a WDC5 DB2 file. Includes offsets, record counts, and sizes specific to the section.

```c++
// a section = records + string block + id list + copy table + offset map + offset map id list + relationship map
struct wdc5_section_header
{
  uint64_t tact_key_hash;          // TactKeyLookup hash
  uint32_t file_offset;            // absolute position to the beginning of the section
  uint32_t record_count;           // 'record_count' for the section
  uint32_t string_table_size;      // 'string_table_size' for the section
  uint32_t offset_records_end;     // Offset to the spot where the records end in a file with an offset map structure;
  uint32_t id_list_size;           // Size of the list of ids present in the section
  uint32_t relationship_data_size; // Size of the relationship data in the section
  uint32_t offset_map_id_count;    // Count of ids present in the offset map in the section
  uint32_t copy_table_count;       // Count of the number of deduplication entries (you can multiply by 8 to mimic the old 'copy_table_size' field)
};
wdc5_section_header section_headers[header.section_count];
```

--------------------------------

### WDB6 DB2 Header Structure

Source: https://wowdev.wiki/DB2

Defines the header for WDB6 files, containing metadata about the data.

```c++
struct wdb6_db2_header
{
  uint32_t magic;                                               // 'WDB6'
  uint32_t record_count;
  uint32_t field_count;                                         // this counts arrays as '1' field
  uint32_t record_size;
  uint32_t string_table_size;                                   // if flags & 0x01 << 0 != 0, this field takes on a new meaning - it becomes an absolute offset to the beginning of the offset_map
  uint32_t table_hash;
  uint32_t layout_hash;                                         // used to be 'build', but now this is a hash field that changes only when the structure of the data changes
  uint32_t min_id;
  uint32_t max_id;
  uint32_t locale;                                              // as seen in TextWowEnum
  uint32_t copy_table_size;
  uint16_t flags;                                               // possible values are listed in Known Flag Meanings
  uint16_t id_index;                                            // this is the index of the field containing ID values; this is ignored if flags & 0x04 << 0 != 0
  uint32_t total_field_count;                                   // new in WDB6, includes columns only expressed in the 'common_data_table', unlike field_count
  uint32_t common_data_table_size;                              // new in WDB6, size of new block called 'common_data_table'
};
```

--------------------------------

### Field Compression Enum

Source: https://wowdev.wiki/DB2

Enumerates the different compression types that can be applied to fields within a DB2 file.

```c
enum field_compression
{
  field_compression_none,
  field_compression_bitpacked,
  field_compression_common_data,
  field_compression_bitpacked_indexed,
  field_compression_bitpacked_indexed_array,
};
```

--------------------------------

### Field Compression Enum

Source: https://wowdev.wiki/DB2

Enumerates the different compression types used for fields, including none, bitpacked, common data, and pallet-indexed types. Essential for correct data decompression.

```cpp
enum field_compression
{
  // None -- usually the field is a 8-, 16-, 32-, or 64-bit integer in the record data. But can contain 96-bit value representing 3 floats as well
  field_compression_none,
  // Bitpacked -- the field is a bitpacked integer in the record data.  It
  // is field_size_bits long and starts at field_offset_bits.
  // A bitpacked value occupies
  //   (field_size_bits + (field_offset_bits & 7) + 7) / 8
  // bytes starting at byte
  //   field_offset_bits / 8
  // in the record data.  These bytes should be read as a little-endian value,
  // then the value is shifted to the right by (field_offset_bits & 7) and
  // masked with ((1ull << field_size_bits) - 1).
  field_compression_bitpacked,
  // Common data -- the field is assumed to be a default value, and exceptions
  // from that default value are stored in the corresponding section in
  // common_data as pairs of { uint32_t record_id; uint32_t value; }.
  field_compression_common_data,
  // Bitpacked indexed -- the field has a bitpacked index in the record data.
  // This index is used as an index into the corresponding section in
  // pallet_data.  The pallet_data section is an array of uint32_t, so the index
  // should be multiplied by 4 to obtain a byte offset.
  field_compression_bitpacked_indexed,
  // Bitpacked indexed array -- the field has a bitpacked index in the record
  // data.  This index is used as an index into the corresponding section in
  // pallet_data.  The pallet_data section is an array of uint32_t[array_count],
  //
  field_compression_bitpacked_indexed_array,
  // Same as field_compression_bitpacked
  field_compression_bitpacked_signed,
};
```

--------------------------------

### Field Storage Information Structure

Source: https://wowdev.wiki/DB2

Defines the structure for storing information about how a field is stored, including its size, offset, and compression type.

```c
struct field_storage_info
{
  uint16_t          field_offset_bits;
  uint16_t          field_size_bits;
  uint32_t          additional_data_size;
  field_compression storage_type;
  switch (storage_type)
  {
    case field_compression.field_compression_bitpacked:
      uint32_t bitpacking_offset_bits;
      uint32_t bitpacking_size_bits;
      uint32_t flags;
      break;
  }
};
```

--------------------------------

### Field Compression Enum

Source: https://wowdev.wiki/DB2

Enumerates the different compression and storage types that can be applied to fields in WDC2 DB2 files. Includes standard integer types, bitpacked, common data, and pallet data.

```c++
enum field_compression
{
  field_compression_none,
  field_compression_bitpacked,
  field_compression_common_data,
  field_compression_bitpacked_indexed,
  field_compression_bitpacked_indexed_array,
  field_compression_bitpacked_signed,
};
```

--------------------------------

### WDC3 Section Header Structure

Source: https://wowdev.wiki/DB2

Defines the header for individual sections within a WDC3 DB file. Includes section-specific record counts, string table sizes, and offsets. Used for parsing data in chunks.

```cpp
struct wdc3_section_header
{
  uint64_t tact_key_hash;          // TactKeyLookup hash
  uint32_t file_offset;            // absolute position to the beginning of the section
  uint32_t record_count;           // 'record_count' for the section
  uint32_t string_table_size;      // 'string_table_size' for the section
  uint32_t offset_records_end;     // Offset to the spot where the records end in a file with an offset map structure;
  uint32_t id_list_size;           // Size of the list of ids present in the section
  uint32_t relationship_data_size; // Size of the relationship data in the section
  uint32_t offset_map_id_count;    // Count of ids present in the offset map in the section
  uint32_t copy_table_count;       // Count of the number of deduplication entries (you can multiply by 8 to mimic the old 'copy_table_size' field)
};
wdc3_section_header section_headers[header.section_count];
```

--------------------------------

### Field Structure Definition

Source: https://wowdev.wiki/DB2

Defines the structure for individual fields within a DB2 file, specifying size and position.

```c
struct field_structure
{
   int16_t size;
   uint16_t position;
};

field_structure fields[header.total_field_count];
```

--------------------------------

### WDB4 DB2 Header Structure

Source: https://wowdev.wiki/DB2

Defines the structure of the WDB4 file header, including fields for record counts, sizes, hashes, build information, and flags. Note the special meaning of 'string_table_size' when the offset map is present.

```c++
struct wdb4_db2_header
{
  uint32_t magic;                                               // 'WDB4'
  uint32_t record_count;
  uint32_t field_count;                                         // array fields count as the size of array for WDB4
  uint32_t record_size;
  uint32_t string_table_size;                                   // if flags & 0x01 << 0 != 0, this field takes on a new meaning - it becomes an absolute offset to the beginning of the offset_map
  uint32_t table_hash;
  uint32_t build;
  uint32_t timestamp_last_written;                              // set to time(0); when writing in WowClientDB2_Base::Save()
  uint32_t min_id;
  uint32_t max_id;
  uint32_t locale;                                              // as seen in TextWowEnum
  uint32_t copy_table_size;
  uint32_t flags;                                               // in WDB3, this field was in the WoW executable's DBCMeta instead; possible values are listed in Known Flag Meanings
};
```

--------------------------------

### Field Compression Types in WDC4

Source: https://wowdev.wiki/DB2

Defines various field compression types used in WDC4 files. Includes bitpacked, bitpacked_signed, common_data, and bitpacked_indexed variants.

```c
case field_compression.field_compression_bitpacked:
    case field_compression.field_compression_bitpacked_signed:
      uint32_t bitpacking_offset_bits; // not useful for most purposes; formula they use to calculate is bitpacking_offset_bits = field_offset_bits - (header.bitpacked_data_offset * 8)
      uint32_t bitpacking_size_bits; // not useful for most purposes
      uint32_t flags; // known values - 0x01: sign-extend (signed)
      break;
    case field_compression.field_compression_common_data:
      uint32_t default_value;
      uint32_t unk_or_unused2;
      uint32_t unk_or_unused3;
      break;
    case field_compression.field_compression_bitpacked_indexed:
      uint32_t bitpacking_offset_bits; // not useful for most purposes; formula they use to calculate is bitpacking_offset_bits = field_offset_bits - (header.bitpacked_data_offset * 8)
      uint32_t bitpacking_size_bits; // not useful for most purposes
      uint32_t unk_or_unused3;
      break;
    case field_compression.field_compression_bitpacked_indexed_array:
      uint32_t bitpacking_offset_bits; // not useful for most purposes; formula they use to calculate is bitpacking_offset_bits = field_offset_bits - (header.bitpacked_data_offset * 8)
      uint32_t bitpacking_size_bits; // not useful for most purposes
      uint32_t array_count;
      break;
    default:
      uint32_t unk_or_unused1;
      uint32_t unk_or_unused2;
      uint32_t unk_or_unused3;
      break;
  }
};
field_storage_info field_info[header.field_storage_info_size / sizeof(field_storage_info)];
char pallet_data[header.pallet_data_size];
char common_data[header.common_data_size];
```
Tokens:
Raw