Comparison of data-serialization formats

<person>
    <isMarried>true</isMarried>
    <hobby />
    <height>1.85</height>
    <name>Bob Peterson</name>
</person>

A data mapping (the key is a data value):

<competition>
    <measurement>
        <name>John</name>
        <height>3.14</height>
    </measurement>
    <measurement>
        <name>Jane</name>
        <height>2.718</height>
    </measurement>
</competition>

^a

42,1
A to Z,1,2,3

null
null.null
null.bool
null.int
null.float
null.decimal
null.timestamp
null.string
null.symbol
null.blob
null.clob
null.struct
null.list
null.sexp

true
null
-42.1e7
"A to Z"

(true, null, -42.1e7, "A to Z")

42
  true
"A to Z"
  1
  2
  3

42
  true
"A to Z", (1, 2, 3)

int32 {1, 2, 3, 4, 5}

Heterogeneous array:

array
{
    bool {true}
    ref {null}
    float {-42.1e7}
    string {"A to Z"}
}

dict
{
    value (key = "42") {bool {true}}
    value (key = "A to Z") {int32 {1, 2, 3}}
}

{
    "42" = <*BY>;
    "A to Z" = ( <*I1>, <*I2>, <*I3> );
}

field1: "value1"
field1: "value2"
field1: "value3

anotherfield {
  foo: 123
  bar: 456
}
anotherfield {
  foo: 222
  bar: 333
}

- y
-
- -42.1e7
- A to Z

42: y
A to Z: [1, 2, 3]

• BER: as 1 byte in binary form;
• PER: as 1 bit;
• OER: as 1 byte

• BER: variable-length big-endian binary representation (up to 2^(2^1024) bits);
• PER Unaligned: a fixed number of bits if the integer type has a finite range; a variable number of bits otherwise;
• PER Aligned: a fixed number of bits if the integer type has a finite range and the size of the range is less than 65536; a variable number of octets otherwise;
• OER: one, two, or four octets (either signed or unsigned) if the integer type has a finite range that fits in that number of octets; a variable number of octets otherwise

base-10 real values are represented as character strings in ISO 6093 format;

binary real values are represented in a binary format that includes the mantissa, the base (2, 8, or 16), and the exponent;

the special values NaN, -INF, +INF, and negative zero are also supported

8-bit: positive \x18, negative \x38 (+1 byte)
16-bit: positive \x19, negative \x39 (+2 bytes)
32-bit: positive \x1A, negative \x3A (+4 bytes)
64-bit: positive \x1B, negative \x3B (+8 bytes)
Negative x encoded as (-x-1)

Decimals and bigfloats (4+ bytes) encoded as \xc4 tag + 2-item array of integer mantissa & exponent

Bytestring \x40 - \x5f
UTF-8 \x60 - \x7f
Indefinite partial strings \x5f and \x7f stitched together until \xff.

Indefinite list \x9f terminated by \xff entry.

Indefinite map \xbf terminated by \xff key.

(Unpreserved lexical values format)

Unsigned skips the boolean flag.

Decimal: boolean sign, integer whole value, integer fractional

doubles: little-endian binary64

False: \x10

Zero is always encoded in tag byte
BigInts over 13 bytes (104 bits) have 1+ byte overhead for length

Zero is always encoded in tag byte

Other strings: \x9x
Arbitrary length and overhead

Arbitrary length and overhead. Length in octets.

Annotations (named fields): \xex

or typecode (one byte) + big-endian (u)int8/16/32/64

or typecode (one byte) + 2–4 bytes length + array items

or typecode (one byte) + 2–4 bytes length + key-value pairs

Length counts only octets between ':' and ','

Variable encoding length signed 64-bit: varint encoding of "ZigZag"-encoded (n << 1) XOR (n >> 63)
Constant encoding length 32-bit: 32 bits in little-endian 2's complement
Constant encoding length 64-bit: 64 bits in little-endian 2's complement

doubles: little-endian binary64

or, for varint-encoded integers only, values packed contiguously and prefixed by tag and total byte length

\x80 (zero-length string) often used

Other values: Strings of big-endian encoded bytes, of arbitrary length, beginning with \x80 - \xbf

56+ bytes: \xb8 - \xbf followed by 1-8 byte integer length of string followed by data.

56+ bytes: \xf8 - \xff followed by 1-8 byte integer length of data followed by data.
Length is always in bytes, not in list items.

zigzag-encoded varints (1–11 data bytes), or BigInteger