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

_{%342=true A%20to%20Z=(1, 2, 3)}

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

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

Encoded as zero bytes.

True: 0x01 False: 0x00

• u8, u16, u32, u64

Big-endian fixed size unsigned integers.

• i8, i16, i32, i64

Big-endian two's complement signed integers.

• uv

Variable length unsigned integer with a compact encoding.

Single and double precision big-endian floats.

Length-prefixed sequence of bytes.

• array x

Length-prefixed sequence of any type.

• n x

Fixed-length array.

• tuple

Fixed size object, encoded as the concatenation of all members.

• map k v

Key-value map of arbitrary size, encoded as an array of pairs.

Fixed length integers for 8-bits, 16-bits, 32-bits, and 64-bits integers.

Encoded as two's complement little-endian values.

8-bit: positive \x18\xhh, negative \x38\xhh
16-bit: positive \x19<uint16_t>, negative \x39<uint16_t>
32-bit: positive \x1A<uint32_t>, negative \x3A<uint32_t>
64-bit: positive \x1B<uint64_t>, negative \x3B<uint64_t>
Negative number x encoded as ~x (binary inversion) or as (-x-1)
Byte order – Big-endian

Bytestring and UTF-8 have different typecode

doubles: little-endian binary64

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

False: 1:0,

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 typecode (one byte) + "varint" encoded variable length integer or typecode (one byte) + "zigzag" encoded variable length integer

or typecode (one byte, including boolean UTF8-encoding flag) + "varint" encoded length + raw bytes

or typecode (one byte) + "varint" encoded length + array items

or typecode (one byte) + "varint" encoded length + key-value pairs. Distinguishes hashmaps from objects / class instances.

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

unsigned integers, little-endian, 1 to 8 bytes: 0x28-0x2f + uint;
small integers 0, 1, ... 9: 0x30-0x39;
small negative integers -6, -5, ..., -1: 0x3a-0x3f;
UTC-date in milliseconds since the epoch, little-endian, 2's complement: 0x1c + uint64

positive long packed BCD-encoded float: 0xc8-0xcf + 8 bytes;
negative long packed BCD-encoded float: 0xd0-0xd7 + 8 bytes

variable length UTF-8 string, little-endian, unsigned integer, not zero-terminated and may contain zero bytes: 0xbf + 8 bytes byte-length + string

array without index table, all sub items 1/2/4/8 bytes byte-length;
array with 1/2/4/8 byte index table offsets, byte-length and number of sub values;
compact array, no index table: 0x13

object with 1/2/4/8 byte index table offsets, sorted by attribute name, 1/2/4/8 byte byte-length and number of sub values;
object with 1/2/4/8 byte index table offsets, not sorted by attribute name, 1/2/4/8 byte byte-length and number of sub values;
compact object, no index table: 0x14