@vlasky/zongji 0.7.1 → 0.8.0

package/lib/charset_map.js

@@ -0,0 +1,86 @@
+// Maps MySQL collation ids (as they appear in TABLE_MAP_EVENT optional
+// metadata) to their character set names, matching the
+// INFORMATION_SCHEMA.COLUMNS CHARACTER_SET_NAME values that the
+// metadata-fetch path produces, so both metadata sources look identical
+// to consumers.
+//
+// Generated from INFORMATION_SCHEMA.COLLATIONS and CHARACTER_SETS on
+// MySQL 8.0 and 8.4 (identical sets). Collation ids are append-only and
+// stable across MySQL versions. Regenerate with:
+//   docker exec <mysql-container> mysql -u root -p<pw> -N -e \
+//     'SELECT ID, CHARACTER_SET_NAME FROM information_schema.COLLATIONS ORDER BY ID'
+//   docker exec <mysql-container> mysql -u root -p<pw> -N -e \
+//     'SELECT CHARACTER_SET_NAME, MAXLEN FROM information_schema.CHARACTER_SETS'
+const collationCharsets = {
+  1: 'big5', 2: 'latin2', 3: 'dec8', 4: 'cp850', 5: 'latin1', 6: 'hp8',
+  7: 'koi8r', 8: 'latin1', 9: 'latin2', 10: 'swe7', 11: 'ascii', 12: 'ujis',
+  13: 'sjis', 14: 'cp1251', 15: 'latin1', 16: 'hebrew', 18: 'tis620', 19: 'euckr',
+  20: 'latin7', 21: 'latin2', 22: 'koi8u', 23: 'cp1251', 24: 'gb2312', 25: 'greek',
+  26: 'cp1250', 27: 'latin2', 28: 'gbk', 29: 'cp1257', 30: 'latin5', 31: 'latin1',
+  32: 'armscii8', 33: 'utf8mb3', 34: 'cp1250', 35: 'ucs2', 36: 'cp866', 37: 'keybcs2',
+  38: 'macce', 39: 'macroman', 40: 'cp852', 41: 'latin7', 42: 'latin7', 43: 'macce',
+  44: 'cp1250', 45: 'utf8mb4', 46: 'utf8mb4', 47: 'latin1', 48: 'latin1', 49: 'latin1',
+  50: 'cp1251', 51: 'cp1251', 52: 'cp1251', 53: 'macroman', 54: 'utf16', 55: 'utf16',
+  56: 'utf16le', 57: 'cp1256', 58: 'cp1257', 59: 'cp1257', 60: 'utf32', 61: 'utf32',
+  62: 'utf16le', 63: 'binary', 64: 'armscii8', 65: 'ascii', 66: 'cp1250', 67: 'cp1256',
+  68: 'cp866', 69: 'dec8', 70: 'greek', 71: 'hebrew', 72: 'hp8', 73: 'keybcs2',
+  74: 'koi8r', 75: 'koi8u', 76: 'utf8mb3', 77: 'latin2', 78: 'latin5', 79: 'latin7',
+  80: 'cp850', 81: 'cp852', 82: 'swe7', 83: 'utf8mb3', 84: 'big5', 85: 'euckr',
+  86: 'gb2312', 87: 'gbk', 88: 'sjis', 89: 'tis620', 90: 'ucs2', 91: 'ujis',
+  92: 'geostd8', 93: 'geostd8', 94: 'latin1', 95: 'cp932', 96: 'cp932', 97: 'eucjpms',
+  98: 'eucjpms', 99: 'cp1250', 101: 'utf16', 102: 'utf16', 103: 'utf16', 104: 'utf16',
+  105: 'utf16', 106: 'utf16', 107: 'utf16', 108: 'utf16', 109: 'utf16', 110: 'utf16',
+  111: 'utf16', 112: 'utf16', 113: 'utf16', 114: 'utf16', 115: 'utf16', 116: 'utf16',
+  117: 'utf16', 118: 'utf16', 119: 'utf16', 120: 'utf16', 121: 'utf16', 122: 'utf16',
+  123: 'utf16', 124: 'utf16', 128: 'ucs2', 129: 'ucs2', 130: 'ucs2', 131: 'ucs2',
+  132: 'ucs2', 133: 'ucs2', 134: 'ucs2', 135: 'ucs2', 136: 'ucs2', 137: 'ucs2',
+  138: 'ucs2', 139: 'ucs2', 140: 'ucs2', 141: 'ucs2', 142: 'ucs2', 143: 'ucs2',
+  144: 'ucs2', 145: 'ucs2', 146: 'ucs2', 147: 'ucs2', 148: 'ucs2', 149: 'ucs2',
+  150: 'ucs2', 151: 'ucs2', 159: 'ucs2', 160: 'utf32', 161: 'utf32', 162: 'utf32',
+  163: 'utf32', 164: 'utf32', 165: 'utf32', 166: 'utf32', 167: 'utf32', 168: 'utf32',
+  169: 'utf32', 170: 'utf32', 171: 'utf32', 172: 'utf32', 173: 'utf32', 174: 'utf32',
+  175: 'utf32', 176: 'utf32', 177: 'utf32', 178: 'utf32', 179: 'utf32', 180: 'utf32',
+  181: 'utf32', 182: 'utf32', 183: 'utf32', 192: 'utf8mb3', 193: 'utf8mb3', 194: 'utf8mb3',
+  195: 'utf8mb3', 196: 'utf8mb3', 197: 'utf8mb3', 198: 'utf8mb3', 199: 'utf8mb3', 200: 'utf8mb3',
+  201: 'utf8mb3', 202: 'utf8mb3', 203: 'utf8mb3', 204: 'utf8mb3', 205: 'utf8mb3', 206: 'utf8mb3',
+  207: 'utf8mb3', 208: 'utf8mb3', 209: 'utf8mb3', 210: 'utf8mb3', 211: 'utf8mb3', 212: 'utf8mb3',
+  213: 'utf8mb3', 214: 'utf8mb3', 215: 'utf8mb3', 223: 'utf8mb3', 224: 'utf8mb4', 225: 'utf8mb4',
+  226: 'utf8mb4', 227: 'utf8mb4', 228: 'utf8mb4', 229: 'utf8mb4', 230: 'utf8mb4', 231: 'utf8mb4',
+  232: 'utf8mb4', 233: 'utf8mb4', 234: 'utf8mb4', 235: 'utf8mb4', 236: 'utf8mb4', 237: 'utf8mb4',
+  238: 'utf8mb4', 239: 'utf8mb4', 240: 'utf8mb4', 241: 'utf8mb4', 242: 'utf8mb4', 243: 'utf8mb4',
+  244: 'utf8mb4', 245: 'utf8mb4', 246: 'utf8mb4', 247: 'utf8mb4', 248: 'gb18030', 249: 'gb18030',
+  250: 'gb18030', 255: 'utf8mb4', 256: 'utf8mb4', 257: 'utf8mb4', 258: 'utf8mb4', 259: 'utf8mb4',
+  260: 'utf8mb4', 261: 'utf8mb4', 262: 'utf8mb4', 263: 'utf8mb4', 264: 'utf8mb4', 265: 'utf8mb4',
+  266: 'utf8mb4', 267: 'utf8mb4', 268: 'utf8mb4', 269: 'utf8mb4', 270: 'utf8mb4', 271: 'utf8mb4',
+  273: 'utf8mb4', 274: 'utf8mb4', 275: 'utf8mb4', 277: 'utf8mb4', 278: 'utf8mb4', 279: 'utf8mb4',
+  280: 'utf8mb4', 281: 'utf8mb4', 282: 'utf8mb4', 283: 'utf8mb4', 284: 'utf8mb4', 285: 'utf8mb4',
+  286: 'utf8mb4', 287: 'utf8mb4', 288: 'utf8mb4', 289: 'utf8mb4', 290: 'utf8mb4', 291: 'utf8mb4',
+  292: 'utf8mb4', 293: 'utf8mb4', 294: 'utf8mb4', 296: 'utf8mb4', 297: 'utf8mb4', 298: 'utf8mb4',
+  300: 'utf8mb4', 303: 'utf8mb4', 304: 'utf8mb4', 305: 'utf8mb4', 306: 'utf8mb4', 307: 'utf8mb4',
+  308: 'utf8mb4', 309: 'utf8mb4', 310: 'utf8mb4', 311: 'utf8mb4', 312: 'utf8mb4', 313: 'utf8mb4',
+  314: 'utf8mb4', 315: 'utf8mb4', 316: 'utf8mb4', 317: 'utf8mb4', 318: 'utf8mb4', 319: 'utf8mb4',
+  320: 'utf8mb4', 321: 'utf8mb4', 322: 'utf8mb4', 323: 'utf8mb4',
+};
+
+// Maximum bytes per character, used to recover character display widths
+// from the byte widths stored in binlog column metadata
+const charsetMaxBytesPerChar = {
+  armscii8: 1, ascii: 1, big5: 2, binary: 1, cp1250: 1, cp1251: 1,
+  cp1256: 1, cp1257: 1, cp850: 1, cp852: 1, cp866: 1, cp932: 2,
+  dec8: 1, eucjpms: 3, euckr: 2, gb18030: 4, gb2312: 2, gbk: 2,
+  geostd8: 1, greek: 1, hebrew: 1, hp8: 1, keybcs2: 1, koi8r: 1,
+  koi8u: 1, latin1: 1, latin2: 1, latin5: 1, latin7: 1, macce: 1,
+  macroman: 1, sjis: 2, swe7: 1, tis620: 1, ucs2: 2, ujis: 3,
+  utf16: 4, utf16le: 4, utf32: 4, utf8mb3: 3, utf8mb4: 4,
+};
+
+// All collations added since MySQL 8.4 are utf8mb4 (the 0900 and uca1400
+// series), so that is the safest guess for ids this table has not caught
+// up with yet.
+export function collationToCharset(id) {
+  return collationCharsets[id] || 'utf8mb4';
+}
+
+export function charsetMaxLength(charsetName) {
+  return charsetMaxBytesPerChar[charsetName] || 4;
+}

package/lib/code_map.js

@@ -43,9 +43,27 @@ const CodeEvent = [
   'XA_PREPARE_LOG_EVENT',
   'PARTIAL_UPDATE_ROWS_EVENT',
   'TRANSACTION_PAYLOAD_EVENT',
-  'HEARTBEAT_LOG_EVENT_V2'
+  'HEARTBEAT_LOG_EVENT_V2',
+  'GTID_TAGGED_LOG_EVENT'
 ];
 
+// MariaDB-specific event codes (sql/log_event.h enum Log_event_type).
+// The GTID names are prefixed to avoid clashing with MySQL's
+// GTID_LOG_EVENT (33): MariaDB's own enum calls 162/163 GTID_EVENT and
+// GTID_LIST_EVENT.
+CodeEvent[160] = 'ANNOTATE_ROWS_EVENT';
+CodeEvent[161] = 'BINLOG_CHECKPOINT_EVENT';
+CodeEvent[162] = 'MARIADB_GTID_EVENT';
+CodeEvent[163] = 'MARIADB_GTID_LIST_EVENT';
+CodeEvent[164] = 'START_ENCRYPTION_EVENT';
+CodeEvent[165] = 'QUERY_COMPRESSED_EVENT';
+CodeEvent[166] = 'WRITE_ROWS_COMPRESSED_EVENT_V1';
+CodeEvent[167] = 'UPDATE_ROWS_COMPRESSED_EVENT_V1';
+CodeEvent[168] = 'DELETE_ROWS_COMPRESSED_EVENT_V1';
+CodeEvent[169] = 'WRITE_ROWS_COMPRESSED_EVENT';
+CodeEvent[170] = 'UPDATE_ROWS_COMPRESSED_EVENT';
+CodeEvent[171] = 'DELETE_ROWS_COMPRESSED_EVENT';
+
 const EventClass = {
   UNKNOWN_EVENT: events.Unknown,
   QUERY_EVENT: events.Query,
@@ -53,7 +71,12 @@ const EventClass = {
   ROTATE_EVENT: events.Rotate,
   FORMAT_DESCRIPTION_EVENT: events.Format,
   XID_EVENT: events.Xid,
+  HEARTBEAT_LOG_EVENT: events.Heartbeat,
   GTID_LOG_EVENT: events.Gtid,
+  // Tagged GTIDs (MySQL 8.3+) decode inside the plain Gtid class (keyed
+  // on options.eventType), so consumers see and filter ordinary 'gtid'
+  // events; event.gtid is 'uuid:tag:gno' and event.tag is set
+  GTID_TAGGED_LOG_EVENT: events.Gtid,
   ANONYMOUS_GTID_LOG_EVENT: events.AnonymousGtid,
   PREVIOUS_GTIDS_LOG_EVENT: events.PreviousGtids,
   TRANSACTION_PAYLOAD_EVENT: events.TransactionPayload,
@@ -66,6 +89,26 @@ const EventClass = {
   WRITE_ROWS_EVENT_V2: rowsEvents.WriteRows,
   UPDATE_ROWS_EVENT_V2: rowsEvents.UpdateRows,
   DELETE_ROWS_EVENT_V2: rowsEvents.DeleteRows,
+
+  XA_PREPARE_LOG_EVENT: events.XaPrepare,
+  ROWS_QUERY_LOG_EVENT: events.RowsQuery,
+
+  // MariaDB
+  ANNOTATE_ROWS_EVENT: events.AnnotateRows,
+  BINLOG_CHECKPOINT_EVENT: events.BinlogCheckpoint,
+  MARIADB_GTID_EVENT: events.MariadbGtid,
+  MARIADB_GTID_LIST_EVENT: events.MariadbGtidList,
+  START_ENCRYPTION_EVENT: events.StartEncryption,
+  // log_bin_compress=ON variants decompress transparently inside the
+  // plain event classes (keyed on options.eventType), so consumers see
+  // and filter ordinary query/writerows/updaterows/deleterows events
+  QUERY_COMPRESSED_EVENT: events.Query,
+  WRITE_ROWS_COMPRESSED_EVENT_V1: rowsEvents.WriteRows,
+  UPDATE_ROWS_COMPRESSED_EVENT_V1: rowsEvents.UpdateRows,
+  DELETE_ROWS_COMPRESSED_EVENT_V1: rowsEvents.DeleteRows,
+  WRITE_ROWS_COMPRESSED_EVENT: rowsEvents.WriteRows,
+  UPDATE_ROWS_COMPRESSED_EVENT: rowsEvents.UpdateRows,
+  DELETE_ROWS_COMPRESSED_EVENT: rowsEvents.DeleteRows,
 };
 
 export function getEventClass(code) {

package/lib/common.js

@@ -1,3 +1,5 @@
+import zlib from 'zlib';
+
 import iconv from 'iconv-lite';
 import decodeJson, { convertBigInts, jsonToText } from './json_decode.js';
 import * as dtDecode from './datetime_decode.js';
@@ -24,6 +26,11 @@ export const MysqlTypes = {
   TIMESTAMP2: 17,
   DATETIME2: 18,
   TIME2: 19,
+  // MariaDB-only wire types for VARCHAR/VARBINARY/TEXT/BLOB columns
+  // declared with the COMPRESSED attribute ("only used internally for
+  // RBR", i.e. they appear in TABLE_MAP column-type arrays)
+  BLOB_COMPRESSED: 140,
+  VARCHAR_COMPRESSED: 141,
   // JSON data type added in MySQL 5.7.7
   JSON: 245,
   NEWDECIMAL: 246,
@@ -158,7 +165,12 @@ const parseAnyInt = function(parser, column, columnSchema) {
       result = parseUInt64(parser);
       break;
   }
-  if (columnSchema.COLUMN_TYPE.indexOf('unsigned') === -1) {
+  // Binlog optional metadata provides signedness directly (UNSIGNED);
+  // otherwise infer it from the INFORMATION_SCHEMA column definition
+  const unsigned = columnSchema.UNSIGNED !== undefined ?
+    columnSchema.UNSIGNED :
+    columnSchema.COLUMN_TYPE.indexOf('unsigned') !== -1;
+  if (!unsigned) {
     const length = size * 8;
     const int64 = (length == 64);
     // Flip bits on negative signed integer
@@ -353,6 +365,238 @@ const readTemporalFraction = function(parser, fractionPrecision) {
   };
 };
 
+export function formatUuid(buffer) {
+  const hex = buffer.toString('hex');
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20)
+  ].join('-');
+}
+
+// Undoes MariaDB's per-value column compression (VARCHAR/BLOB COMPRESSED,
+// sql/field_comp.cc). Header byte: bits 4-7 = method (0 = stored
+// uncompressed, 8 = zlib), and for zlib bits 0-2 = size of the big-endian
+// original-length field that follows, bit 3 = deflate stream has no zlib
+// wrapper (raw deflate). An empty value is stored with no header at all.
+// Variable-length integer of MySQL's mysql::serialization framework
+// (libs/mysql/serialization/variable_length_integers.h, used by the
+// tagged GTID event of MySQL 8.3+). NOT protobuf varint and NOT the
+// classic length-encoded integer: the total byte count is the number of
+// trailing one-bits of the first byte plus one (1-9); the value is the
+// first byte shifted right by that count, joined with the remaining
+// bytes little-endian shifted left by (8 - count). A 9-byte encoding
+// (first byte 0xFF) carries a full little-endian u64 unshifted.
+// Returns a BigInt; `end` bounds the read (event end minus checksum).
+export function parseSerializationVarint(parser, end, what) {
+  if (parser._offset + 1 > end) {
+    throw new Error(`Truncated ${what}: varint head past event end`);
+  }
+  const first = parser.parseUnsignedNumber(1);
+  let extra = 0;
+  while (extra < 8 && (first >> extra) & 1) {
+    extra++;
+  }
+  if (parser._offset + extra > end) {
+    throw new Error(`Truncated ${what}: ${extra + 1}-byte varint ` +
+      'past event end');
+  }
+  if (extra === 8) {
+    let value = 0n;
+    for (let i = 0; i < 8; i++) {
+      value |= BigInt(parser.parseUnsignedNumber(1)) << BigInt(8 * i);
+    }
+    return value;
+  }
+  let rest = 0n;
+  for (let i = 0; i < extra; i++) {
+    rest |= BigInt(parser.parseUnsignedNumber(1)) << BigInt(8 * i);
+  }
+  return (BigInt(first) >> BigInt(extra + 1)) |
+    (rest << BigInt(8 - (extra + 1)));
+}
+
+// Signed variant: value x >= 0 encodes as x << 1, x < 0 as
+// ((-(x + 1)) << 1) | 1 (a zigzag-like mapping)
+export function parseSerializationVarintSigned(parser, end, what) {
+  const u = parseSerializationVarint(parser, end, what);
+  return (u & 1n) ? -(u >> 1n) - 1n : u >> 1n;
+}
+
+// MySQL charset names mostly match iconv-lite encoding names, with four
+// classes of exception: the utf8 aliases; MySQL's "latin1", which is
+// really cp1252 (its 0x80-0x9F range holds printable characters that
+// ISO-8859-1 reserves for controls, and the server converts them as such
+// for query results); the Unicode charsets whose stored byte order is
+// big-endian while the iconv-lite encodings of the same spelling default
+// to little-endian; and names iconv-lite spells differently or lacks
+// (ujis is EUC-JP, eucjpms is its MS-extended variant for which plain
+// EUC-JP is the closest decoder available, macce is Mac Central
+// European). dec8, geostd8, hp8, keybcs2 and swe7 have no iconv-lite
+// decoder at all; those columns come through as raw Buffers.
+const ICONV_CHARSET_OVERRIDES = {
+  utf8mb3: 'utf8',
+  utf8mb4: 'utf8',
+  latin1: 'cp1252',
+  ucs2: 'utf16-be',
+  utf16: 'utf16-be',
+  utf16le: 'utf16-le',
+  utf32: 'utf32-be',
+  ujis: 'eucjp',
+  eucjpms: 'eucjp',
+  macce: 'maccenteuro',
+};
+
+// Decodes a text column's raw bytes using the column's own character set
+// (INFORMATION_SCHEMA CHARACTER_SET_NAME, or the charset carried by FULL
+// binlog metadata). Returns the buffer unchanged when the charset is
+// unknown to iconv.
+export function decodeTextColumn(buffer, charset) {
+  const charsetName = ICONV_CHARSET_OVERRIDES[charset] || charset || 'utf8';
+  if (charsetName === 'utf8') {
+    return buffer.toString('utf8');
+  }
+  try {
+    // A leading U+FEFF is column data, not a byte-order mark: the
+    // charset's byte order is fixed, and the server preserves the
+    // character when converting for query results
+    return iconv.decode(buffer, charsetName, { stripBOM: false });
+  } catch (err) {
+    console.warn(err);
+    return buffer;
+  }
+}
+
+const uncompressColumnValue = function(buffer) {
+  if (buffer.length === 0) {
+    return buffer;
+  }
+  const header = buffer[0];
+  const method = header >> 4;
+  if (method === 0) {
+    return buffer.subarray(1);
+  }
+  if (method === 8) {
+    const lengthBytes = header & 0x07;
+    const compressed = buffer.subarray(1 + lengthBytes);
+    return (header & 0x08)
+      ? zlib.inflateRawSync(compressed)
+      : zlib.inflateSync(compressed);
+  }
+  throw new Error(
+    `Unknown MariaDB column compression method ${method}`);
+};
+
+// Undoes the payload envelope of MariaDB's compressed binlog EVENTS
+// (log_bin_compress=ON, event codes 165-171; sql/log_event.cc
+// binlog_get_uncompress_len / binlog_buf_uncompress). Distinct from the
+// per-column COMPRESSED envelope above: header byte has bit 7 always set,
+// bits 4-6 = algorithm (only 0 = zlib is defined), bits 0-2 = size of the
+// big-endian original-length field that follows; then a zlib-wrapped
+// deflate stream.
+export function uncompressBinlogEventPayload(buffer) {
+  if (buffer.length < 1) {
+    throw new Error('Empty compressed binlog event payload');
+  }
+  const header = buffer[0];
+  const algorithm = (header & 0x70) >> 4;
+  if ((header & 0x80) === 0 || algorithm !== 0) {
+    throw new Error(
+      `Unknown binlog event compression header 0x${header.toString(16)}`);
+  }
+  const lengthBytes = header & 0x07;
+  if (lengthBytes < 1 || lengthBytes > 4 ||
+      buffer.length < 1 + lengthBytes) {
+    throw new Error(
+      `Corrupt binlog event compression header 0x${header.toString(16)}`);
+  }
+  const originalLength = buffer.readUIntBE(1, lengthBytes);
+  const inflated = zlib.inflateSync(buffer.subarray(1 + lengthBytes));
+  if (inflated.length !== originalLength) {
+    throw new Error(
+      `Compressed binlog event inflated to ${inflated.length} bytes, ` +
+      `expected ${originalLength}`);
+  }
+  return inflated;
+}
+
+// Dotted-quad text form of a MariaDB INET4 value (4 bytes, network order)
+export function formatInet4(buffer) {
+  return `${buffer[0]}.${buffer[1]}.${buffer[2]}.${buffer[3]}`;
+}
+
+// Canonical text form of a MariaDB INET6 value (16 bytes, network order),
+// matching the server's own formatting: RFC 5952 (lowercase hex groups,
+// the longest run of two or more zero groups compressed to '::', the
+// leftmost on a tie) with IPv4-mapped (::ffff:a.b.c.d) and IPv4-compatible
+// (::a.b.c.d, except :: and ::1) addresses in dotted form
+export function formatInet6(buffer) {
+  const leadingZero = buffer.subarray(0, 10).every(byte => byte === 0);
+  if (leadingZero) {
+    const v4 = formatInet4(buffer.subarray(12));
+    if (buffer[10] === 0xff && buffer[11] === 0xff) {
+      return `::ffff:${v4}`;
+    }
+    if (buffer[10] === 0 && buffer[11] === 0 &&
+        buffer.readUInt32BE(12) > 1) {
+      return `::${v4}`;
+    }
+  }
+
+  const groups = [];
+  for (let i = 0; i < 16; i += 2) {
+    groups.push(buffer.readUInt16BE(i));
+  }
+  // Longest run of >=2 zero groups; leftmost wins a tie
+  let bestStart = -1, bestLength = 1;
+  for (let i = 0; i < 8;) {
+    if (groups[i] !== 0) { i++; continue; }
+    let j = i;
+    while (j < 8 && groups[j] === 0) j++;
+    if (j - i > bestLength) {
+      bestStart = i;
+      bestLength = j - i;
+    }
+    i = j;
+  }
+  const hex = (value) => value.toString(16);
+  if (bestStart === -1) {
+    return groups.map(hex).join(':');
+  }
+  const head = groups.slice(0, bestStart).map(hex).join(':');
+  const tail = groups.slice(bestStart + bestLength).map(hex).join(':');
+  return `${head}::${tail}`;
+}
+
+// MariaDB 5.3-era "hires" temporals (written under mysql56_temporal_format
+// =OFF, or by tables never rebuilt since 10.0): fractional TIME/DATETIME/
+// TIMESTAMP binlogged under the classic type codes 11/12/7 with no
+// metadata, so the precision is only knowable from the column definition
+// (COLUMN_TYPE reads e.g. 'datetime(3) /* mariadb-5.3 */'). MySQL never
+// produces these codes with a precision: fractional temporals always use
+// TIME2/DATETIME2/TIMESTAMP2.
+const hiresPrecision = function(columnSchema) {
+  const match = /^(?:time|datetime|timestamp)\((\d)\)/
+    .exec(columnSchema.COLUMN_TYPE);
+  return match ? parseInt(match[1], 10) : 0;
+};
+
+// Same shape as readTemporalFraction, from a fraction that was stored
+// with exactly `precision` decimal digits
+const hiresFractionObject = function(value, precision) {
+  let milliseconds;
+  if (precision > 3) {
+    milliseconds = Math.floor(value / Math.pow(10, precision - 3));
+  } else if (precision < 3) {
+    milliseconds = value * Math.pow(10, 3 - precision);
+  } else {
+    milliseconds = value;
+  }
+  return { value, precision, milliseconds };
+};
+
 // This function is used to read and interpret non-null values from parser.
 // The parser object contains the raw value, and functions useful for value
 // interpretation, but not the underlying column type or how the value ought to
@@ -406,8 +650,11 @@ export function readMysqlValue(
         low = parser.parseUnsignedNumber(column.metadata.size);
       }
 
+      // Binlog optional metadata provides the value list directly;
+      // otherwise parse it out of the column definition.
       // Second argument: prefixLen = 4 'set('
-      choices = parseSetEnumTypeDef(columnSchema.COLUMN_TYPE, 4);
+      choices = columnSchema.SET_VALUES ||
+        parseSetEnumTypeDef(columnSchema.COLUMN_TYPE, 4);
       result = '';
       for (let i = 0; low >= Math.pow(2, i); i++) {
         if (low & Math.pow(2, i)) result += choices[i] + ',';
@@ -422,27 +669,59 @@ export function readMysqlValue(
     case MysqlTypes.ENUM:
       raw = parser.parseUnsignedNumber(column.metadata.size);
       // Second argument: prefixLen = 5 'enum('
-      choices = parseSetEnumTypeDef(columnSchema.COLUMN_TYPE, 5);
+      choices = columnSchema.ENUM_VALUES ||
+        parseSetEnumTypeDef(columnSchema.COLUMN_TYPE, 5);
       result = choices[raw - 1];
       break;
     case MysqlTypes.VAR_STRING:
       // Never used?
       result = parser.parseLengthCodedString();
       break;
+    case MysqlTypes.VARCHAR_COMPRESSED: {
+      // MariaDB VARCHAR/VARBINARY ... COMPRESSED: length-prefixed like
+      // VARCHAR, with a per-value compression envelope around the payload
+      const prefixSize = column.metadata['max_length'] > 255 ? 2 : 1;
+      size = parser.parseUnsignedNumber(prefixSize);
+      buffer = uncompressColumnValue(parser.parseBuffer(size));
+      result = columnSchema.COLUMN_TYPE.substr(0, 6) === 'varbin' ?
+        buffer : decodeTextColumn(buffer, column.charset);
+      break;
+    }
     case MysqlTypes.VARCHAR:
     case MysqlTypes.STRING: {
       const prefixSize = column.metadata['max_length'] > 255 ? 2 : 1;
       size = parser.parseUnsignedNumber(prefixSize);
       const def = columnSchema.COLUMN_TYPE;
       const defPrefix = def.substr(0, 6);
-      if (defPrefix === 'binary') {
+      // MariaDB logical types ride on STRING/VARCHAR with a binary
+      // charset; only COLUMN_TYPE distinguishes them from BINARY(n) or
+      // VARBINARY(n). Text forms match the server's own (and therefore
+      // what a mysql2 query returns); VECTOR stays a raw Buffer of
+      // little-endian float32s, as in query results. As with BINARY(n),
+      // the row image strips trailing zero bytes, so the value is
+      // re-padded to the type's fixed width before formatting.
+      const readFixedWidth = (width) => {
+        const padded = Buffer.alloc(width, 0);
+        parser.parseBuffer(size).copy(padded);
+        return padded;
+      };
+      if (def === 'uuid') {
+        result = formatUuid(readFixedWidth(16));
+      } else if (def === 'inet4') {
+        result = formatInet4(readFixedWidth(4));
+      } else if (def === 'inet6') {
+        result = formatInet6(readFixedWidth(16));
+      } else if (defPrefix === 'vector') {
+        result = parser.parseBuffer(size);
+      } else if (defPrefix === 'binary') {
         const bufsize = parseInt(def.substr(7, def.length - 2), 10);
         result = Buffer.alloc(bufsize, 0);
         parser.parseBuffer(size).copy(result);
       } else if (defPrefix === 'varbin') {
         result = parser.parseBuffer(size);
       } else {
-        result = parser.parseString(size);
+        // Text CHAR/VARCHAR: decode in the column's own charset
+        result = decodeTextColumn(parser.parseBuffer(size), column.charset);
       }
       break;
     }
@@ -450,24 +729,20 @@ export function readMysqlValue(
     case MysqlTypes.MEDIUM_BLOB:
     case MysqlTypes.LONG_BLOB:
     case MysqlTypes.BLOB:
+    case MysqlTypes.BLOB_COMPRESSED:
       lengthSize = column.metadata['length_size'];
       result = parser.parseBuffer(parser.parseUnsignedNumber(lengthSize));
+      if (column.type === MysqlTypes.BLOB_COMPRESSED) {
+        // MariaDB TEXT/BLOB ... COMPRESSED: the payload wears a per-value
+        // compression envelope; the charset handling below then applies
+        // to the inflated bytes as for a plain TEXT/BLOB
+        result = uncompressColumnValue(result);
+      }
 
       // Blobs can be sometimes return as String instead of Buffer
       // e.g. TINYTEXT, MEDIUMTEXT, LONGTEXT, TEXT data types
       if (column.charset !== null) {
-        // Javascript UTF8 always allows up to 4 bytes per character
-        switch (column.charset) {
-          case 'utf8mb3':
-          case 'utf8mb4':
-            column.charset = 'utf8';
-            break;
-        }
-        try {
-          result = iconv.decode(result, column.charset);
-        } catch (err) {
-          console.warn(err);
-        }
+        result = decodeTextColumn(result, column.charset);
       }
       break;
     case MysqlTypes.JSON: {
@@ -504,7 +779,32 @@ export function readMysqlValue(
         zongji.connection.config.timezone
       );
       break;
-    case MysqlTypes.TIME:
+    case MysqlTypes.TIME: {
+      const hiresDec = hiresPrecision(columnSchema);
+      if (hiresDec > 0) {
+        // MariaDB hires TIME: one big-endian unsigned integer of signed
+        // total time units offset by zero_point = 3020400 * 10^dec
+        // (TIME_MAX_VALUE_SECONDS + 1, scaled), so '00:00:00' stores
+        // exactly zero_point and the encoding sorts as unsigned
+        const bytes = [3, 4, 4, 5, 5, 5, 6][hiresDec];
+        const scale = Math.pow(10, hiresDec);
+        let stored = parser._buffer.readUIntBE(parser._offset, bytes);
+        parser._offset += bytes;
+        stored -= 3020400 * scale;
+        isNegative = stored < 0;
+        if (isNegative) stored = -stored;
+        fraction = hiresFractionObject(stored % scale, hiresDec);
+        const totalSeconds = Math.floor(stored / scale);
+        hour = Math.floor(totalSeconds / 3600);
+        minute = Math.floor((totalSeconds % 3600) / 60);
+        second = totalSeconds % 60;
+        result = (isNegative ? '-' : '') +
+                 zeroPad(hour, hour > 99 ? 3 : 2) + ':' +
+                 zeroPad(minute, 2) + ':' +
+                 zeroPad(second, 2) +
+                 dtDecode.getFractionString(fraction);
+        break;
+      }
       raw = parseUInt24(parser);
 
       isNegative = (raw & (1 << 23)) !== 0;
@@ -520,6 +820,7 @@ export function readMysqlValue(
                zeroPad(minute, 2) + ':' +
                zeroPad(second, 2);
       break;
+    }
     case MysqlTypes.TIME2:
       raw = readIntBE(parser._buffer, parser._offset, 3);
       parser._offset += 3;
@@ -545,7 +846,41 @@ export function readMysqlValue(
         result += dtDecode.getFractionString(fraction);
       }
       break;
-    case MysqlTypes.DATETIME:
+    case MysqlTypes.DATETIME: {
+      const hiresDec = hiresPrecision(columnSchema);
+      if (hiresDec > 0) {
+        // MariaDB hires DATETIME: one big-endian unsigned integer of
+        // pack_time() scaled to dec fractional digits; mixed radix, not
+        // the YYYYMMDDHHMMSS decimal of the classic format and not the
+        // DATETIME2 bit layout. Up to 8 bytes (beyond 2^53), so split in
+        // BigInt.
+        const bytes = [5, 6, 6, 7, 7, 7, 8][hiresDec];
+        let packed = 0n;
+        for (let i = 0; i < bytes; i++) {
+          packed = (packed << 8n) | BigInt(parser._buffer[parser._offset + i]);
+        }
+        parser._offset += bytes;
+        const scale = 10n ** BigInt(hiresDec);
+        fraction = hiresFractionObject(Number(packed % scale), hiresDec);
+        let units = packed / scale;
+        const secondPart = Number(units % 60n); units /= 60n;
+        const minutePart = Number(units % 60n); units /= 60n;
+        const hourPart = Number(units % 24n); units /= 24n;
+        const dayPart = Number(units % 32n); units /= 32n;
+        const monthPart = Number(units % 13n); units /= 13n;
+        result = dtDecode.getDateTime(
+          zongji.connection.config.dateStrings,
+          Number(units),  // year
+          monthPart,
+          dayPart,
+          hourPart,
+          minutePart,
+          secondPart,
+          fraction,
+          zongji.connection.config.timezone
+        );
+        break;
+      }
       raw = parseUInt64(parser);
       date = Math.floor(raw / 1000000);
       time = raw % 1000000;
@@ -561,6 +896,7 @@ export function readMysqlValue(
         zongji.connection.config.timezone
       );
       break;
+    }
     case MysqlTypes.DATETIME2: {
       // Overlapping high-low to get all data in 32-bit numbers
       const rawHigh = readIntBE(parser._buffer, parser._offset, 4);
@@ -582,7 +918,26 @@ export function readMysqlValue(
       );
       break;
     }
-    case MysqlTypes.TIMESTAMP:
+    case MysqlTypes.TIMESTAMP: {
+      const hiresDec = hiresPrecision(columnSchema);
+      if (hiresDec > 0) {
+        // MariaDB hires TIMESTAMP: big-endian epoch seconds (the classic
+        // format is little-endian) followed by a big-endian fraction of
+        // exactly dec digits
+        raw = parser._buffer.readUInt32BE(parser._offset);
+        parser._offset += 4;
+        const fracBytes = [0, 1, 1, 2, 2, 3, 3][hiresDec];
+        fraction = hiresFractionObject(
+          parser._buffer.readUIntBE(parser._offset, fracBytes), hiresDec);
+        parser._offset += fracBytes;
+        result = dtDecode.getTimeStamp(
+          zongji.connection.config.dateStrings,
+          raw,
+          fraction,
+          zongji.connection.config.timezone
+        );
+        break;
+      }
       raw = parser.parseUnsignedNumber(4);
       result = dtDecode.getTimeStamp(
         zongji.connection.config.dateStrings,
@@ -591,6 +946,7 @@ export function readMysqlValue(
         zongji.connection.config.timezone
       );
       break;
+    }
     case MysqlTypes.TIMESTAMP2:
       raw = readIntBE(parser._buffer, parser._offset, 4);
       parser._offset += 4;