A | B | C | D | E | F | G | H | I | J | K | L | |
---|---|---|---|---|---|---|---|---|---|---|---|---|
1 | ENUM# | Minor Type | BYTES | CommonType | Description/Notes | Also Known As | PROTO DEF | |||||
2 | 0 | LATE | n/a | Late | late binding type | LATE = 0; // late binding type | ||||||
3 | 1 | MAP | n/a | Map | an empty map column. Useful for conceptual setup. Children listed within here | MAP = 1; // an empty map column. Useful for conceptual setup. Children listed within here | ||||||
4 | 2 | REPEATMAP | n/a | RepeatMap | a repeated map column (means that multiple children sit below this) | REPEATMAP = 2; // a repeated map column (means that multiple children sit below this) | case REPEATMAP: return RepeatMap.class; | |||||
5 | 3 | TINYINT | 1 | Fixed1 | single byte signed integer | TINYINT = 3; // single byte signed integer | case TINYINT: return Fixed1.class; | case TINYINT: return NullableFixed1.class; | case TINYINT: return RepeatedFixed1.class; | case TINYINT: return 1; | case TINYINT: return new Fixed1(field, allocator); | |
6 | 4 | SMALLINT | 2 | Fixed2 | two byte signed integer | SMALLINT = 4; // two byte signed integer | case SMALLINT: return Fixed2.class; | case SMALLINT: return NullableFixed2.class; | case SMALLINT: return RepeatedFixed2.class; | case SMALLINT: return 2; | case SMALLINT: return new Fixed2(field, allocator); | |
7 | 5 | INT | 4 | Fixed4 | four byte signed integer | INT = 5; // four byte signed integer | case INT: return Fixed4.class; | case INT: return NullableFixed4.class; | case INT: return RepeatedFixed4.class; | case INT: return 4; | case INT: return new Fixed4(field, allocator); | |
8 | 6 | BIGINT | 8 | Fixed8 | eight byte signed integer | BIGINT = 6; // eight byte signed integer | case BIGINT: return Fixed8.class; | case BIGINT: return NullableFixed8.class; | case BIGINT: return RepeatedFixed8.class; | case BIGINT: return 8; | case BIGINT: return new Fixed8(field, allocator); | |
9 | 7 | DECIMAL4 | 4 | Fixed4 | a decimal supporting precision between 1 and 8 (4 bits for decimal location, 1 sign) | numeric | DECIMAL4 = 7; // a decimal supporting precision between 1 and 8 (4 bits for decimal location, 1 sign) | case DECIMAL4: return Fixed4.class; | case DECIMAL4: return NullableFixed4.class; | case DECIMAL4: return RepeatedFixed4.class; | case DECIMAL4: return 4; | case DECIMAL4: return new Fixed4(field, allocator); |
10 | 8 | DECIMAL8 | 8 | Fixed8 | a decimal supporting precision between 9 and 18 (5 bits for decimal location, 1 sign) | numeric | DECIMAL8 = 8; // a decimal supporting precision between 9 and 18 (5 bits for decimal location, 1 sign) | case DECIMAL8: return Fixed8.class; | case DECIMAL8: return NullableFixed8.class; | case DECIMAL8: return RepeatedFixed8.class; | case DECIMAL8: return 8; | case DECIMAL8: return new Fixed8(field, allocator); |
11 | 9 | DECIMAL12 | 12 | Fixed12 | a decimal supporting precision between19 and 28 (5 bits for decimal location, 1 sign) | numeric | DECIMAL12 = 9; // a decimal supporting precision between19 and 28 (5 bits for decimal location, 1 sign) | case DECIMAL12: return Fixed12.class; | case DECIMAL12: return NullableFixed12.class; | case DECIMAL12: return RepeatedFixed12.class; | case DECIMAL12: return 12; | case DECIMAL12: return new Fixed12(field, allocator); |
12 | 10 | DECIMAL16 | 16 | Fixed16 | a decimal supporting precision between 29 and 37 (6 bits for decimal location, 1 sign) | numeric | DECIMAL16 = 10; // a decimal supporting precision between 29 and 37 (6 bits for decimal location, 1 sign) | case DECIMAL16: return Fixed16.class; | case DECIMAL16: return NullableFixed16.class; | case DECIMAL16: return RepeatedFixed16.class; | case DECIMAL16: return 16; | case DECIMAL16: return new Fixed16(field, allocator); |
13 | 11 | MONEY | 8 | Fixed8 | signed decimal with two digit precision | MONEY = 11; // signed decimal with two digit precision | case MONEY: return Fixed8.class; | case MONEY: return NullableFixed8.class; | case MONEY: return RepeatedFixed8.class; | case MONEY: return 8; | case MONEY: return new Fixed8(field, allocator); | |
14 | 12 | DATE | 4 | Fixed4 | days since 4713bc | DATE = 12; // days since 4713bc | case DATE: return Fixed4.class; | case DATE: return NullableFixed4.class; | case DATE: return RepeatedFixed4.class; | case DATE: return 4; | case DATE: return new Fixed4(field, allocator); | |
15 | 13 | TIME | 8 | Fixed8 | time in micros before or after 2000/1/1 | TIME = 13; // time in micros before or after 2000/1/1 | case TIME: return Fixed8.class; | case TIME: return NullableFixed8.class; | case TIME: return RepeatedFixed8.class; | case TIME: return 8; | case TIME: return new Fixed8(field, allocator); | |
16 | 14 | TIMETZ | 12 | Fixed12 | time in micros before or after 2000/1/1 with timezone | TIMETZ = 14; // time in micros before or after 2000/1/1 with timezone | case TIMETZ: return Fixed12.class; | case TIMETZ: return NullableFixed12.class; | case TIMETZ: return RepeatedFixed12.class; | case TIMETZ: return 12; | case TIMETZ: return new Fixed12(field, allocator); | |
17 | 15 | TIMESTAMP | 8 | Fixed8 | unix epoch time in millis | TIMESTAMP = 15; // unix epoch time in millis | case TIMESTAMP: return Fixed8.class; | case TIMESTAMP: return NullableFixed8.class; | case TIMESTAMP: return RepeatedFixed8.class; | case TIMESTAMP: return 8; | case TIMESTAMP: return new Fixed8(field, allocator); | |
18 | 16 | DATETIME | 8 | Fixed8 | TBD | DATETIME = 16; // TBD | case DATETIME: return Fixed8.class; | case DATETIME: return NullableFixed8.class; | case DATETIME: return RepeatedFixed8.class; | case DATETIME: return 8; | case DATETIME: return new Fixed8(field, allocator); | |
19 | 17 | INTERVAL | 12 | Fixed12 | TBD | INTERVAL = 17; // TBD | case INTERVAL: return Fixed12.class; | case INTERVAL: return NullableFixed12.class; | case INTERVAL: return RepeatedFixed12.class; | case INTERVAL: return 12; | case INTERVAL: return new Fixed12(field, allocator); | |
20 | 18 | FLOAT4 | 4 | Fixed4 | 4 byte ieee 754 | real, float | FLOAT4 = 18; // 4 byte ieee 754 | case FLOAT4: return Fixed4.class; | case FLOAT4: return NullableFixed4.class; | case FLOAT4: return RepeatedFixed4.class; | case FLOAT4: return 4; | case FLOAT4: return new Fixed4(field, allocator); |
21 | 19 | FLOAT8 | 8 | Fixed8 | 8 byte ieee 754 | double, double precision | FLOAT8 = 19; // 8 byte ieee 754 | case FLOAT8: return Fixed8.class; | case FLOAT8: return NullableFixed8.class; | case FLOAT8: return RepeatedFixed8.class; | case FLOAT8: return 8; | case FLOAT8: return new Fixed8(field, allocator); |
22 | 20 | BOOLEAN | 1/8 | Bit | single bit value | BOOLEAN = 20; // single bit value | case BOOLEAN: return Bit.class; | case BOOLEAN: return NullableBit.class; | case BOOLEAN: return RepeatedBit.class; | case BOOLEAN: return 1/8; | case BOOLEAN: return new Bit(field, allocator); | |
23 | 21 | FIXEDCHAR | len | FixedLen | utf8 fixed length string, padded with spaces | FIXEDCHAR = 21; // utf8 fixed length string, padded with spaces | case FIXEDCHAR: return FixedLen.class; | case FIXEDCHAR: return NullableFixedLen.class; | case FIXEDCHAR: return RepeatedFixedLen.class; | case FIXEDCHAR: return len; | case FIXEDCHAR: return new FixedLen(field, allocator); | |
24 | 22 | VARCHAR2 | 2 + len | VarLen2 | utf8 variable length string (up to 2^16 in length) | VARCHAR2 = 22; // utf8 variable length string (up to 2^16 in length) | case VARCHAR2: return VarLen2.class; | case VARCHAR2: return NullableVarLen2.class; | case VARCHAR2: return RepeatedVarLen2.class; | case VARCHAR2: return 2 + len; | case VARCHAR2: return new VarLen2(field, allocator); | |
25 | 23 | VARCHAR4 | 4 + len | VarLen4 | utf8 variable length string (up to 2^32 in length) | VARCHAR4 = 23; // utf8 variable length string (up to 2^32 in length) | case VARCHAR4: return VarLen4.class; | case VARCHAR4: return NullableVarLen4.class; | case VARCHAR4: return RepeatedVarLen4.class; | case VARCHAR4: return 4 + len; | case VARCHAR4: return new VarLen4(field, allocator); | |
26 | 24 | FIXEDBINARY | len | FixedLen | fixed length binary, padded with 0 bytes | FIXEDBINARY = 24; // fixed length binary, padded with 0 bytes | case FIXEDBINARY: return FixedLen.class; | case FIXEDBINARY: return NullableFixedLen.class; | case FIXEDBINARY: return RepeatedFixedLen.class; | case FIXEDBINARY: return len; | case FIXEDBINARY: return new FixedLen(field, allocator); | |
27 | 25 | VARBINARY2 | 2 + len | VarLen2 | variable length binary (up to 2^16 in length) | VARBINARY2 = 25; // variable length binary (up to 2^16 in length) | case VARBINARY2: return VarLen2.class; | case VARBINARY2: return NullableVarLen2.class; | case VARBINARY2: return RepeatedVarLen2.class; | case VARBINARY2: return 2 + len; | case VARBINARY2: return new VarLen2(field, allocator); | |
28 | 26 | VARBINARY4 | 4 + len | VarLen4 | variable length binary (up to 2^32 in length) | VARBINARY4 = 26; // variable length binary (up to 2^32 in length) | case VARBINARY4: return VarLen4.class; | case VARBINARY4: return NullableVarLen4.class; | case VARBINARY4: return RepeatedVarLen4.class; | case VARBINARY4: return 4 + len; | case VARBINARY4: return new VarLen4(field, allocator); | |
29 | 27 | UINT1 | 1 | Fixed1 | unsigned 1 byte integer | UINT1 = 27; // unsigned 1 byte integer | case UINT1: return Fixed1.class; | case UINT1: return NullableFixed1.class; | case UINT1: return RepeatedFixed1.class; | case UINT1: return 1; | case UINT1: return new Fixed1(field, allocator); | |
30 | 28 | UINT2 | 2 | Fixed2 | unsigned 2 byte integer | UINT2 = 28; // unsigned 2 byte integer | case UINT2: return Fixed2.class; | case UINT2: return NullableFixed2.class; | case UINT2: return RepeatedFixed2.class; | case UINT2: return 2; | case UINT2: return new Fixed2(field, allocator); | |
31 | 29 | UINT4 | 4 | Fixed4 | unsigned 4 byte integer | UINT4 = 29; // unsigned 4 byte integer | case UINT4: return Fixed4.class; | case UINT4: return NullableFixed4.class; | case UINT4: return RepeatedFixed4.class; | case UINT4: return 4; | case UINT4: return new Fixed4(field, allocator); | |
32 | 30 | UINT8 | 8 | Fixed8 | unsigned 8 byte integer | UINT8 = 30; // unsigned 8 byte integer | case UINT8: return Fixed8.class; | case UINT8: return NullableFixed8.class; | case UINT8: return RepeatedFixed8.class; | case UINT8: return 8; | case UINT8: return new Fixed8(field, allocator); | |
33 | 31 | PROTO2 | 2 + len | VarLen2 | protobuf encoded complex type. (up to 2^16 in length) | PROTO2 = 31; // protobuf encoded complex type. (up to 2^16 in length) | case PROTO2: return VarLen2.class; | case PROTO2: return NullableVarLen2.class; | case PROTO2: return RepeatedVarLen2.class; | case PROTO2: return 2 + len; | case PROTO2: return new VarLen2(field, allocator); | |
34 | 32 | PROTO4 | 4 + len | VarLen4 | protobuf encoded complex type. (up to 2^32 in length) | PROTO4 = 32; // protobuf encoded complex type. (up to 2^32 in length) | case PROTO4: return VarLen4.class; | case PROTO4: return NullableVarLen4.class; | case PROTO4: return RepeatedVarLen4.class; | case PROTO4: return 4 + len; | case PROTO4: return new VarLen4(field, allocator); | |
35 | 33 | MSGPACK2 | 2 + len | VarLen2 | msgpack encoded complex type. (up to 2^16 in length) | MSGPACK2 = 33; // msgpack encoded complex type. (up to 2^16 in length) | case MSGPACK2: return VarLen2.class; | case MSGPACK2: return NullableVarLen2.class; | case MSGPACK2: return RepeatedVarLen2.class; | case MSGPACK2: return 2 + len; | case MSGPACK2: return new VarLen2(field, allocator); | |
36 | 34 | MSGPACK4 | 4 + len | VarLen4 | msgpack encoded complex type. (up to 2^32 in length) | MSGPACK4 = 34; // msgpack encoded complex type. (up to 2^32 in length) | case MSGPACK4: return VarLen4.class; | case MSGPACK4: return NullableVarLen4.class; | case MSGPACK4: return RepeatedVarLen4.class; | case MSGPACK4: return 4 + len; | case MSGPACK4: return new VarLen4(field, allocator); |