parseBinaryColumnData function

(dynamic, int) parseBinaryColumnData(
  1. int columnType,
  2. ByteData data,
  3. Uint8List buffer,
  4. int startOffset, {
  5. bool unsigned = false,
})

Função auxiliar para analisar dados de coluna em formato binário.

columnType: O tipo da coluna (valor inteiro representando o tipo MySQL). data: Um ByteData que fornece acesso aos bytes do buffer. buffer: O Uint8List original contendo os dados. startOffset: A posição inicial no buffer para leitura.

Retorna um record (dynamic, int) contendo:

  • $1: O valor lido da coluna (geralmente convertido para string ou, em casos binários, um Uint8List).
  • $2: O número de bytes consumidos durante a leitura.

Caso o tipo da coluna não seja implementado, lança MySQLProtocolException.

Implementation

(dynamic, int) parseBinaryColumnData(
  int columnType,
  ByteData data,
  Uint8List buffer,
  int startOffset, {
  bool unsigned = false,
}) {
  // [unsigned] comes from the column's UNSIGNED flag: without it a
  // TINYINT UNSIGNED 200 was read as -56 (and so on for every width).
  switch (columnType) {
    case mysqlColumnTypeTiny:
      {
        final value =
            unsigned ? data.getUint8(startOffset) : data.getInt8(startOffset);
        return (value.toString(), 1);
      }

    case mysqlColumnTypeShort:
      {
        final value = unsigned
            ? data.getUint16(startOffset, Endian.little)
            : data.getInt16(startOffset, Endian.little);
        return (value.toString(), 2);
      }

    case mysqlColumnTypeLong:
    case mysqlColumnTypeInt24:
      {
        final value = unsigned
            ? data.getUint32(startOffset, Endian.little)
            : data.getInt32(startOffset, Endian.little);
        return (value.toString(), 4);
      }

    case mysqlColumnTypeLongLong:
      {
        final value = data.getInt64(startOffset, Endian.little);
        if (unsigned && value < 0) {
          // Above 2^63 - 1: the two's-complement int64 plus 2^64.
          return ((BigInt.from(value) + (BigInt.one << 64)).toString(), 8);
        }
        return (value.toString(), 8);
      }

    case mysqlColumnTypeFloat:
      {
        final value = data.getFloat32(startOffset, Endian.little);
        return (value.toString(), 4);
      }

    case mysqlColumnTypeDouble:
      {
        final value = data.getFloat64(startOffset, Endian.little);
        return (value.toString(), 8);
      }

    case mysqlColumnTypeDate:
    case mysqlColumnTypeDateTime:
    case mysqlColumnTypeTimestamp:
      {
        final initialOffset = startOffset;
        // Lê o número de bytes (pode ser 0, 4, 7 ou 11)
        final numOfBytes = data.getUint8(startOffset);
        startOffset += 1;

        // Quando numOfBytes == 0, MySQL envia datas/timestamps '0000-00-00 00:00:00'
        if (numOfBytes == 0) {
          return ("0000-00-00 00:00:00", 1);
        }

        var year = 0, month = 0, day = 0;
        var hour = 0, minute = 0, second = 0, microSecond = 0;

        if (numOfBytes >= 4) {
          year = data.getUint16(startOffset, Endian.little);
          startOffset += 2;
          month = data.getUint8(startOffset);
          startOffset += 1;
          day = data.getUint8(startOffset);
          startOffset += 1;
        }
        if (numOfBytes >= 7) {
          hour = data.getUint8(startOffset);
          startOffset += 1;
          minute = data.getUint8(startOffset);
          startOffset += 1;
          second = data.getUint8(startOffset);
          startOffset += 1;
        }
        if (numOfBytes >= 11) {
          microSecond = data.getUint32(startOffset, Endian.little);
          startOffset += 4;
        }

        // Zero-padded like the text protocol: an unpadded year (999) failed
        // DateTime.parse, and unpadded microseconds (5000 -> ".5000") read
        // as half a second.
        final result = StringBuffer()
          ..write('${year.toString().padLeft(4, '0')}-')
          ..write('${month.toString().padLeft(2, '0')}-')
          ..write('${day.toString().padLeft(2, '0')} ')
          ..write('${hour.toString().padLeft(2, '0')}:')
          ..write('${minute.toString().padLeft(2, '0')}:')
          ..write(second.toString().padLeft(2, '0'));

        if (numOfBytes >= 11) {
          result.write('.${microSecond.toString().padLeft(6, '0')}');
        }

        final consumed = startOffset - initialOffset;
        return (result.toString(), consumed);
      }

    case mysqlColumnTypeTime:
    case mysqlColumnTypeTime2:
      {
        final initialOffset = startOffset;
        // Lê o número de bytes (pode ser 0, 8 ou 12)
        final numOfBytes = data.getUint8(startOffset);
        startOffset += 1;

        if (numOfBytes == 0) {
          return ("00:00:00", 1);
        }

        var isNegative = false;
        var days = 0, hours = 0, minutes = 0, seconds = 0, microSecond = 0;

        if (numOfBytes >= 8) {
          isNegative = data.getUint8(startOffset) > 0;
          startOffset += 1;
          days = data.getUint32(startOffset, Endian.little);
          startOffset += 4;
          hours = data.getUint8(startOffset);
          startOffset += 1;
          minutes = data.getUint8(startOffset);
          startOffset += 1;
          seconds = data.getUint8(startOffset);
          startOffset += 1;
        }

        if (numOfBytes >= 12) {
          microSecond = data.getUint32(startOffset, Endian.little);
          startOffset += 4;
        }

        hours += days * 24;
        final timeResult = StringBuffer();
        if (isNegative) {
          timeResult.write("-");
        }
        timeResult.write('${hours.toString().padLeft(2, '0')}:');
        timeResult.write('${minutes.toString().padLeft(2, '0')}:');
        timeResult.write(seconds.toString().padLeft(2, '0'));

        if (numOfBytes >= 12) {
          timeResult.write('.${microSecond.toString().padLeft(6, '0')}');
        }

        final consumed = startOffset - initialOffset;
        return (timeResult.toString(), consumed);
      }

    case mysqlColumnTypeString:
    case mysqlColumnTypeVarString:
    case mysqlColumnTypeVarChar:
    case mysqlColumnTypeEnum:
    case mysqlColumnTypeSet:
    case mysqlColumnTypeJson:
      {
        // Dados textuais length-encoded
        final result = buffer.getUtf8LengthEncodedString(startOffset);
        return (result.$1, result.$2);
      }

    case mysqlColumnTypeDecimal:
    case mysqlColumnTypeNewDecimal:
      {
        final lengthEncoded = buffer.getLengthEncodedBytes(startOffset);
        // Valores numéricos vêm como texto no protocolo textual; decodifique em UTF-8.
        final strValue = utf8.decode(lengthEncoded.$1, allowMalformed: true);
        return (strValue, lengthEncoded.$2);
      }

    case mysqlColumnTypeLongBlob:
    case mysqlColumnTypeMediumBlob:
    case mysqlColumnTypeBlob:
    case mysqlColumnTypeTinyBlob:
    case mysqlColumnTypeGeometry:
    case mysqlColumnTypeBit:
      {
        // Para dados binários, retorna os bytes crus
        final lengthEncoded = buffer.getLengthEncodedBytes(startOffset);
        return (lengthEncoded.$1, lengthEncoded.$2);
      }

    case mysqlColumnTypeYear:
      {
        // Lê 2 bytes para YEAR
        final yearValue = data.getUint16(startOffset, Endian.little);
        return (yearValue.toString(), 2);
      }
  }

  throw MySQLProtocolException(
    "Can not parse binary column data: column type $columnType is not implemented",
  );
}