Java Code Examples for com.taobao.tddl.dbsync.binlog.LogBuffer#position()

/**
 * Creates a new <code>Rotate_log_event</code> object read normally from
 * log.
 * 
 * @throws MySQLExtractException
 */
public RotateLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent){
    super(header);

    final int headerSize = descriptionEvent.commonHeaderLen;
    final int postHeaderLen = descriptionEvent.postHeaderLen[ROTATE_EVENT - 1];

    buffer.position(headerSize + R_POS_OFFSET);
    position = (postHeaderLen != 0) ? buffer.getLong64() : 4; // !uint8korr(buf
                                                              // +
                                                              // R_POS_OFFSET)

    final int filenameOffset = headerSize + postHeaderLen;
    int filenameLen = buffer.limit() - filenameOffset;
    if (filenameLen > FN_REFLEN - 1) filenameLen = FN_REFLEN - 1;
    buffer.position(filenameOffset);

    filename = buffer.getFixString(filenameLen);
}
 

public IncidentLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent){
    super(header);

    final int commonHeaderLen = descriptionEvent.commonHeaderLen;
    final int postHeaderLen = descriptionEvent.postHeaderLen[header.type - 1];

    buffer.position(commonHeaderLen);
    final int incidentNumber = buffer.getUint16();
    if (incidentNumber >= INCIDENT_COUNT || incidentNumber <= INCIDENT_NONE) {
        // If the incident is not recognized, this binlog event is
        // invalid. If we set incident_number to INCIDENT_NONE, the
        // invalidity will be detected by is_valid().
        incident = INCIDENT_NONE;
        message = null;
        return;
    }
    incident = incidentNumber;

    buffer.position(commonHeaderLen + postHeaderLen);
    message = buffer.getString();
}
 

public ExecuteLoadQueryLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent)
                                                                                                               throws IOException{
    super(header, buffer, descriptionEvent);

    buffer.position(descriptionEvent.commonHeaderLen + ELQ_FILE_ID_OFFSET);

    fileId = buffer.getUint32(); // ELQ_FILE_ID_OFFSET
    fnPosStart = (int) buffer.getUint32(); // ELQ_FN_POS_START_OFFSET
    fnPosEnd = (int) buffer.getUint32(); // ELQ_FN_POS_END_OFFSET
    dupHandling = buffer.getInt8(); // ELQ_DUP_HANDLING_OFFSET

    final int len = query.length();
    if (fnPosStart > len || fnPosEnd > len || dupHandling > LOAD_DUP_REPLACE) {
        throw new IOException(String.format("Invalid ExecuteLoadQueryLogEvent: fn_pos_start=%d, "
                                            + "fn_pos_end=%d, dup_handling=%d", fnPosStart, fnPosEnd, dupHandling));
    }
}
 

public XaPrepareLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent){
    super(header);

    final int commonHeaderLen = descriptionEvent.getCommonHeaderLen();
    final int postHeaderLen = descriptionEvent.getPostHeaderLen()[header.getType() - 1];

    int offset = commonHeaderLen + postHeaderLen;
    buffer.position(offset);

    onePhase = (buffer.getInt8() == 0x00 ? false : true);

    formatId = buffer.getInt32();
    gtridLength = buffer.getInt32();
    bqualLength = buffer.getInt32();

    int MY_XIDDATASIZE = 128;
    if (MY_XIDDATASIZE >= gtridLength + bqualLength && gtridLength >= 0 && gtridLength <= 64 && bqualLength >= 0
        && bqualLength <= 64) {
        data = buffer.getData(gtridLength + bqualLength);
    } else {
        formatId = -1;
        gtridLength = 0;
        bqualLength = 0;
    }
}
 

private void parse_geometry_type(LogBuffer buffer, int length) {
    // stores geometry column's types extracted from field.
    int limit = buffer.position() + length;

    List<Integer> datas = new ArrayList<Integer>();
    while (buffer.hasRemaining() && buffer.position() < limit) {
        int col_type = (int) buffer.getPackedLong();
        datas.add(col_type);
    }

    int index = 0;
    for (int i = 0; i < columnCnt; i++) {
        if (columnInfo[i].type == LogEvent.MYSQL_TYPE_GEOMETRY) {
            columnInfo[i].geoType = datas.get(index);
            index++;
        }
    }
}
 

public CreateFileLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent){
    super(header, buffer, descriptionEvent);

    final int headerLen = descriptionEvent.commonHeaderLen;
    final int loadHeaderLen = descriptionEvent.postHeaderLen[LOAD_EVENT - 1];
    final int createFileHeaderLen = descriptionEvent.postHeaderLen[CREATE_FILE_EVENT - 1];

    copyLogEvent(buffer,
        ((header.type == LOAD_EVENT) ? (loadHeaderLen + headerLen) : (headerLen + loadHeaderLen + createFileHeaderLen)),
        descriptionEvent);

    if (descriptionEvent.binlogVersion != 1) {
        fileId = buffer.getUint32(headerLen + loadHeaderLen + CF_FILE_ID_OFFSET);
        /*
         * Note that it's ok to use get_data_size() below, because it is
         * computed with values we have already read from this event
         * (because we called copy_log_event()); we are not using slave's
         * format info to decode master's format, we are really using
         * master's format info. Anyway, both formats should be identical
         * (except the common_header_len) as these Load events are not
         * changed between 4.0 and 5.0 (as logging of LOAD DATA INFILE does
         * not use Load_log_event in 5.0).
         */
        blockLen = buffer.limit() - buffer.position();
        blockBuf = buffer.duplicate(blockLen);
    } else {
        initedFromOld = true;
    }
}
 

public DeleteFileLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent){
    super(header);

    final int commonHeaderLen = descriptionEvent.commonHeaderLen;
    buffer.position(commonHeaderLen + DF_FILE_ID_OFFSET);
    fileId = buffer.getUint32(); // DF_FILE_ID_OFFSET
}
 

public RandLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent){
    super(header);

    /* The Post-Header is empty. The Variable Data part begins immediately. */
    buffer.position(descriptionEvent.commonHeaderLen + descriptionEvent.postHeaderLen[RAND_EVENT - 1]
                    + RAND_SEED1_OFFSET);
    seed1 = buffer.getLong64(); // !uint8korr(buf+RAND_SEED1_OFFSET);
    seed2 = buffer.getLong64(); // !uint8korr(buf+RAND_SEED2_OFFSET);
}
 

public XidLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent){
    super(header);

    /* The Post-Header is empty. The Variable Data part begins immediately. */
    buffer.position(descriptionEvent.commonHeaderLen + descriptionEvent.postHeaderLen[XID_EVENT - 1]);
    xid = buffer.getLong64(); // !uint8korr
}
 

public IntvarLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent){
    super(header);

    /* The Post-Header is empty. The Varible Data part begins immediately. */
    buffer.position(descriptionEvent.commonHeaderLen + descriptionEvent.postHeaderLen[INTVAR_EVENT - 1]
                    + I_TYPE_OFFSET);
    type = buffer.getInt8(); // I_TYPE_OFFSET
    value = buffer.getLong64(); // !uint8korr(buf + I_VAL_OFFSET);
}
 

private void parse_simple_pk(LogBuffer buffer, int length) {
    // stores primary key's column information extracted from
    // field. Each column has an index and a prefix which are
    // stored as a unit_pair. prefix is always 0 for
    // SIMPLE_PRIMARY_KEY field.

    int limit = buffer.position() + length;
    while (buffer.hasRemaining() && buffer.position() < limit) {
        int col_index = (int) buffer.getPackedLong();
        columnInfo[col_index].pk = true;
    }
}
 

private void parse_set_str_value(LogBuffer buffer, int length, boolean set) {
    // stores SET/ENUM column's string values extracted from
    // field. Each SET/ENUM column's string values are stored
    // into a string separate vector. All of them are stored
    // in 'vec'.
    int limit = buffer.position() + length;
    List<List<String>> datas = new ArrayList<List<String>>();
    while (buffer.hasRemaining() && buffer.position() < limit) {
        int count = (int) buffer.getPackedLong();
        List<String> data = new ArrayList<String>(count);
        for (int i = 0; i < count; i++) {
            int len1 = (int) buffer.getPackedLong();
            data.add(buffer.getFixString(len1));
        }

        datas.add(data);
    }

    int index = 0;
    for (int i = 0; i < columnCnt; i++) {
        if (set && getRealType(columnInfo[i].type, columnInfo[i].meta) == LogEvent.MYSQL_TYPE_SET) {
            columnInfo[i].set_enum_values = datas.get(index);
            index++;
        }

        if (!set && getRealType(columnInfo[i].type, columnInfo[i].meta) == LogEvent.MYSQL_TYPE_ENUM) {
            columnInfo[i].set_enum_values = datas.get(index);
            index++;
        }
    }
}
 

public IntvarLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent){
    super(header);

    /* The Post-Header is empty. The Varible Data part begins immediately. */
    buffer.position(descriptionEvent.commonHeaderLen + descriptionEvent.postHeaderLen[INTVAR_EVENT - 1]
                    + I_TYPE_OFFSET);
    type = buffer.getInt8(); // I_TYPE_OFFSET
    value = buffer.getLong64(); // !uint8korr(buf + I_VAL_OFFSET);
}
 

private List<Integer> parse_column_charset(LogBuffer buffer, int length) {
    // stores collation numbers extracted from field.
    int limit = buffer.position() + length;
    List<Integer> datas = new ArrayList<Integer>();
    while (buffer.hasRemaining() && buffer.position() < limit) {
        int col_charset = (int) buffer.getPackedLong();
        datas.add(col_charset);
    }

    return datas;
}
 

public AppendBlockLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent){
    super(header);

    final int commonHeaderLen = descriptionEvent.commonHeaderLen;
    final int postHeaderLen = descriptionEvent.postHeaderLen[header.type - 1];
    final int totalHeaderLen = commonHeaderLen + postHeaderLen;

    buffer.position(commonHeaderLen + AB_FILE_ID_OFFSET);
    fileId = buffer.getUint32();

    buffer.position(postHeaderLen);
    blockLen = buffer.limit() - totalHeaderLen;
    blockBuf = buffer.duplicate(blockLen);
}
 

private void parse_column_name(LogBuffer buffer, int length) {
    // stores column names extracted from field
    int limit = buffer.position() + length;
    int index = 0;
    while (buffer.hasRemaining() && buffer.position() < limit) {
        int len = (int) buffer.getPackedLong();
        columnInfo[index++].name = buffer.getFixString(len);
    }
}
 

public GtidLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent){
    super(header);

    final int commonHeaderLen = descriptionEvent.commonHeaderLen;
    // final int postHeaderLen = descriptionEvent.postHeaderLen[header.type
    // - 1];

    buffer.position(commonHeaderLen);
    commitFlag = (buffer.getUint8() != 0); // ENCODED_FLAG_LENGTH

    byte[] bs = buffer.getData(ENCODED_SID_LENGTH);
    ByteBuffer bb = ByteBuffer.wrap(bs);
    long high = bb.getLong();
    long low = bb.getLong();
    sid = new UUID(high, low);

    gno = buffer.getLong64();

    // support gtid lastCommitted and sequenceNumber
    // fix bug #776
    if (buffer.hasRemaining() && buffer.remaining() > 16 && buffer.getUint8() == LOGICAL_TIMESTAMP_TYPE_CODE) {
        lastCommitted = buffer.getLong64();
        sequenceNumber = buffer.getLong64();
    }

    // ignore gtid info read
    // sid.copy_from((uchar *)ptr_buffer);
    // ptr_buffer+= ENCODED_SID_LENGTH;
    //
    // // SIDNO is only generated if needed, in get_sidno().
    // spec.gtid.sidno= -1;
    //
    // spec.gtid.gno= uint8korr(ptr_buffer);
    // ptr_buffer+= ENCODED_GNO_LENGTH;
}
 

public AppendBlockLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent){
    super(header);

    final int commonHeaderLen = descriptionEvent.commonHeaderLen;
    final int postHeaderLen = descriptionEvent.postHeaderLen[header.type - 1];
    final int totalHeaderLen = commonHeaderLen + postHeaderLen;

    buffer.position(commonHeaderLen + AB_FILE_ID_OFFSET);
    fileId = buffer.getUint32();

    buffer.position(postHeaderLen);
    blockLen = buffer.limit() - totalHeaderLen;
    blockBuf = buffer.duplicate(blockLen);
}
 

/**
 * @see mysql-5.1.60/sql/log_event.cc - Load_log_event::copy_log_event
 */
protected final void copyLogEvent(LogBuffer buffer, final int bodyOffset, FormatDescriptionLogEvent descriptionEvent) {
    /* this is the beginning of the post-header */
    buffer.position(descriptionEvent.commonHeaderLen + L_EXEC_TIME_OFFSET);

    execTime = buffer.getUint32(); // L_EXEC_TIME_OFFSET
    skipLines = (int) buffer.getUint32(); // L_SKIP_LINES_OFFSET
    final int tableNameLen = buffer.getUint8(); // L_TBL_LEN_OFFSET
    final int dbLen = buffer.getUint8(); // L_DB_LEN_OFFSET
    numFields = (int) buffer.getUint32(); // L_NUM_FIELDS_OFFSET

    buffer.position(bodyOffset);
    /*
     * Sql_ex.init() on success returns the pointer to the first byte after
     * the sql_ex structure, which is the start of field lengths array.
     */
    if (header.type != LOAD_EVENT /* use_new_format */) {
        /*
         * The code below assumes that buf will not disappear from under our
         * feet during the lifetime of the event. This assumption holds true
         * in the slave thread if the log is in new format, but is not the
         * case when we have old format because we will be reusing net
         * buffer to read the actual file before we write out the
         * Create_file event.
         */
        fieldTerm = buffer.getString();
        enclosed = buffer.getString();
        lineTerm = buffer.getString();
        lineStart = buffer.getString();
        escaped = buffer.getString();
        optFlags = buffer.getInt8();
        emptyFlags = 0;
    } else {
        fieldTerm = buffer.getFixString(1);
        enclosed = buffer.getFixString(1);
        lineTerm = buffer.getFixString(1);
        lineStart = buffer.getFixString(1);
        escaped = buffer.getFixString(1);
        optFlags = buffer.getUint8();
        emptyFlags = buffer.getUint8();

        if ((emptyFlags & FIELD_TERM_EMPTY) != 0) fieldTerm = null;
        if ((emptyFlags & ENCLOSED_EMPTY) != 0) enclosed = null;
        if ((emptyFlags & LINE_TERM_EMPTY) != 0) lineTerm = null;
        if ((emptyFlags & LINE_START_EMPTY) != 0) lineStart = null;
        if ((emptyFlags & ESCAPED_EMPTY) != 0) escaped = null;
    }

    final int fieldLenPos = buffer.position();
    buffer.forward(numFields);
    fields = new String[numFields];
    for (int i = 0; i < numFields; i++) {
        final int fieldLen = buffer.getUint8(fieldLenPos + i);
        fields[i] = buffer.getFixString(fieldLen + 1);
    }

    table = buffer.getFixString(tableNameLen + 1);
    db = buffer.getFixString(dbLen + 1);

    // null termination is accomplished by the caller
    final int from = buffer.position();
    final int end = from + buffer.limit();
    int found = from;
    for (; (found < end) && buffer.getInt8(found) != '\0'; found++)
        /* empty loop */;
    fname = buffer.getString(found);
    buffer.forward(1); // The + 1 is for \0 terminating fname
}
 

public UserVarLogEvent(LogHeader header, LogBuffer buffer, FormatDescriptionLogEvent descriptionEvent)
                                                                                                      throws IOException{
    super(header);

    /* The Post-Header is empty. The Variable Data part begins immediately. */
    buffer.position(descriptionEvent.commonHeaderLen + descriptionEvent.postHeaderLen[USER_VAR_EVENT - 1]);
    final int nameLen = (int) buffer.getUint32();
    name = buffer.getFixString(nameLen); // UV_NAME_LEN_SIZE
    isNull = (0 != buffer.getInt8());

    if (isNull) {
        type = STRING_RESULT;
        charsetNumber = 63; /* binary */
        value = null;
    } else {
        type = buffer.getInt8(); // UV_VAL_IS_NULL
        charsetNumber = (int) buffer.getUint32(); // buf + UV_VAL_TYPE_SIZE
        final int valueLen = (int) buffer.getUint32(); // buf +
                                                       // UV_CHARSET_NUMBER_SIZE
        final int limit = buffer.limit(); /* for restore */
        buffer.limit(buffer.position() + valueLen);

        /* @see User_var_log_event::print */
        switch (type) {
            case REAL_RESULT:
                value = Double.valueOf(buffer.getDouble64()); // float8get
                break;
            case INT_RESULT:
                if (valueLen == 8) value = Long.valueOf(buffer.getLong64()); // !uint8korr
                else if (valueLen == 4) value = Long.valueOf(buffer.getUint32());
                else throw new IOException("Error INT_RESULT length: " + valueLen);
                break;
            case DECIMAL_RESULT:
                final int precision = buffer.getInt8();
                final int scale = buffer.getInt8();
                value = buffer.getDecimal(precision, scale); // bin2decimal
                break;
            case STRING_RESULT:
                String charsetName = CharsetConversion.getJavaCharset(charsetNumber);
                value = buffer.getFixString(valueLen, charsetName);
                break;
            case ROW_RESULT:
                // this seems to be banned in MySQL altogether
                throw new IOException("ROW_RESULT is unsupported");
            default:
                value = null;
                break;
        }
        buffer.limit(limit);
    }
}