phoenix upsert 源码分析

phoenix查询源码分析。

在之前的driver源码分析的基础上，现在分析一下UPSERT的流程

SET_ASYNC_CREATED_DATE =
"UPSERT INTO " + SYSTEM_CATALOG_SCHEMA + ".\"" + SYSTEM_CATALOG_TABLE + "


  PreparedStatement setAsync = connection.prepareStatement(SET_ASYNC_CREATED_DATE);
setAsync.setString(1, tenantIdStr);
setAsync.setString(2, schemaName);
setAsync.setString(3, tableName);
setAsync.setDate(4, asyncCreatedDate);
setAsync.execute();

sql预编译生成

PhoenixPreparedStatement statement = new PhoenixPreparedStatement(this, sql);

执行 setAsync.execute()然后调用到 PhoenixStatement 类中的下面的方法

protected int executeMutation(final CompilableStatement stmt) throws SQLException {
 if (connection.isReadOnly()) {
        throw new SQLExceptionInfo.Builder(
            SQLExceptionCode.READ_ONLY_CONNECTION).
            build().buildException();
    }
    GLOBAL_MUTATION_SQL_COUNTER.increment();
    try {
        return CallRunner
                .run(
                    new CallRunner.CallableThrowable<Integer, SQLException>() {
                    @Override
                        public Integer call() throws SQLException {
                        try {
                            MutationState state = connection.getMutationState();
                            MutationPlan plan = stmt.compilePlan(PhoenixStatement.this, Sequence.ValueOp.VALIDATE_SEQUENCE);
                            if (plan.getTargetRef() != null && plan.getTargetRef().getTable() != null && plan.getTargetRef().getTable().isTransactional()) {
                                state.startTransaction();
                            }
                            Iterator<TableRef> tableRefs = plan.getSourceRefs().iterator();
                            state.sendUncommitted(tableRefs);
                            state.checkpointIfNeccessary(plan);
                            MutationState lastState = plan.execute();
                            state.join(lastState);
                            if (connection.getAutoCommit()) {
                                connection.commit();;
                            }
                            setLastResultSet(null);
                            setLastQueryPlan(null);
                            // Unfortunately, JDBC uses an int for update count, so we
                            // just max out at Integer.MAX_VALUE
                            int lastUpdateCount = (int) Math.min(Integer.MAX_VALUE, lastState.getUpdateCount());
                            setLastUpdateCount(lastUpdateCount);
                            setLastUpdateOperation(stmt.getOperation());
                            connection.incrementStatementExecutionCounter();
                            return lastUpdateCount;
                        } catch (RuntimeException e) {
                            // FIXME: Expression.evaluate does not throw SQLException
                            // so this will unwrap throws from that.
                            if (e.getCause() instanceof SQLException) {
                                throw (SQLException) e.getCause();
                            }
                            throw e;
                        }
                    }
                }, PhoenixContextExecutor.inContext(),
                    Tracing.withTracing(connection, this.toString()));
    } catch (Exception e) {
        Throwables.propagateIfInstanceOf(e, SQLException.class);
        throw Throwables.propagate(e);
    }
}

上面的stmt 就是 ExecutableUpsertStatement，执行了compilePlan

public MutationPlan compilePlan(PhoenixStatement stmt, Sequence.ValueOp seqAction) throws SQLException {
        if(!getUdfParseNodes().isEmpty()) {
            stmt.throwIfUnallowedUserDefinedFunctions(getUdfParseNodes());
        }
        UpsertCompiler compiler = new UpsertCompiler(stmt, this.getOperation());
        MutationPlan plan = compiler.compile(this);
        plan.getContext().getSequenceManager().validateSequences(seqAction);
        return plan;
    }

接着调用到 UpsertCompiler.compile ,返回一下 MutationPlan对象
然后执行 plan.execute();（在UpsertCompiler类当中） 就是调用下面的方法，返回一下 MutationState 对象

 @Override
        public MutationState execute() throws SQLException {
            ImmutableBytesWritable ptr = context.getTempPtr();
            final SequenceManager sequenceManager = context.getSequenceManager();
            // Next evaluate all the expressions
            int nodeIndex = nodeIndexOffset;
            PTable table = tableRef.getTable();
            Tuple tuple = sequenceManager.getSequenceCount() == 0 ? null :
                sequenceManager.newSequenceTuple(null);
            for (Expression constantExpression : constantExpressions) {
                PColumn column = allColumns.get(columnIndexes[nodeIndex]);
                constantExpression.evaluate(tuple, ptr);
                Object value = null;
                if (constantExpression.getDataType() != null) {
                    value = constantExpression.getDataType().toObject(ptr, constantExpression.getSortOrder(), constantExpression.getMaxLength(), constantExpression.getScale());
                    if (!constantExpression.getDataType().isCoercibleTo(column.getDataType(), value)) { 
                        throw TypeMismatchException.newException(
                            constantExpression.getDataType(), column.getDataType(), "expression: "
                                    + constantExpression.toString() + " in column " + column);
                    }
                    if (!column.getDataType().isSizeCompatible(ptr, value, constantExpression.getDataType(),
                            constantExpression.getMaxLength(), constantExpression.getScale(), 
                            column.getMaxLength(), column.getScale())) { 
                        throw new SQLExceptionInfo.Builder(
                            SQLExceptionCode.DATA_EXCEEDS_MAX_CAPACITY).setColumnName(column.getName().getString())
                            .setMessage("value=" + constantExpression.toString()).build().buildException();
                    }
                }
                column.getDataType().coerceBytes(ptr, value, constantExpression.getDataType(), 
                        constantExpression.getMaxLength(), constantExpression.getScale(), constantExpression.getSortOrder(),
                        column.getMaxLength(), column.getScale(),column.getSortOrder(),
                        table.rowKeyOrderOptimizable());
                if (overlapViewColumns.contains(column) && Bytes.compareTo(ptr.get(), ptr.getOffset(), ptr.getLength(), column.getViewConstant(), 0, column.getViewConstant().length-1) != 0) {
                    throw new SQLExceptionInfo.Builder(
                            SQLExceptionCode.CANNOT_UPDATE_VIEW_COLUMN)
                            .setColumnName(column.getName().getString())
                            .setMessage("value=" + constantExpression.toString()).build().buildException();
                }
                values[nodeIndex] = ByteUtil.copyKeyBytesIfNecessary(ptr);
                nodeIndex++;
            }
            // Add columns based on view
            for (PColumn column : addViewColumns) {
                if (IndexUtil.getViewConstantValue(column, ptr)) {
                    values[nodeIndex++] = ByteUtil.copyKeyBytesIfNecessary(ptr);
                } else {
                    throw new IllegalStateException();
                }
            }
            Map<ImmutableBytesPtr, RowMutationState> mutation = Maps.newHashMapWithExpectedSize(1);
            setValues(values, pkSlotIndexes, columnIndexes, table, mutation, statement, useServerTimestamp);
            return new MutationState(tableRef, mutation, 0, maxSize, connection);
        }

在上面的setValues 方法中，就是进行数据的组装

private static void setValues(byte[][] values, int[] pkSlotIndex, int[] columnIndexes, PTable table, Map<ImmutableBytesPtr,RowMutationState> mutation, PhoenixStatement statement, boolean useServerTimestamp) {
    Map<PColumn,byte[]> columnValues = Maps.newHashMapWithExpectedSize(columnIndexes.length);
    byte[][] pkValues = new byte[table.getPKColumns().size()][];
    // If the table uses salting, the first byte is the salting byte, set to an empty array
    // here and we will fill in the byte later in PRowImpl.
    if (table.getBucketNum() != null) {
        pkValues[0] = new byte[] {0};
    }
    Long rowTimestamp = null; // case when the table doesn't have a row timestamp column
    RowTimestampColInfo rowTsColInfo = new RowTimestampColInfo(useServerTimestamp, rowTimestamp);
    for (int i = 0; i < values.length; i++) {
        byte[] value = values[i];
        PColumn column = table.getColumns().get(columnIndexes[i]);
        if (SchemaUtil.isPKColumn(column)) {
            pkValues[pkSlotIndex[i]] = value;
            if (SchemaUtil.getPKPosition(table, column) == table.getRowTimestampColPos()) {
                if (!useServerTimestamp) {
                    PColumn rowTimestampCol = table.getPKColumns().get(table.getRowTimestampColPos());
                    rowTimestamp = PLong.INSTANCE.getCodec().decodeLong(value, 0, rowTimestampCol.getSortOrder());
                    if (rowTimestamp < 0) {
                        throw new IllegalDataException("Value of a column designated as ROW_TIMESTAMP cannot be less than zero");
                    }
                    rowTsColInfo = new RowTimestampColInfo(useServerTimestamp, rowTimestamp);
                } 
            }
        } else {
            columnValues.put(column, value);
        }
    }
    ImmutableBytesPtr ptr = new ImmutableBytesPtr();
    table.newKey(ptr, pkValues);
    mutation.put(ptr, new RowMutationState(columnValues, statement.getConnection().getStatementExecutionCounter(), rowTsColInfo));
}

大家可能要对MutationState要注意一下，这个对象挺重要的，直接调用hbase.put 原生api的是这个State对象
在MetaDataClient 中，下面的代码，调用方法进行数据的写入的包装和逻辑判断

  tableMetaData.addAll(connection.getMutationState().toMutations(timestamp).next().getSecond());

调用到MutationState 对象当中

  private Iterator<Pair<byte[],List<Mutation>>> addRowMutations(final TableRef tableRef, final Map<ImmutableBytesPtr, RowMutationState> values, final long timestamp, boolean includeMutableIndexes, final boolean sendAll) { 
    final PTable table = tableRef.getTable();
    final Iterator<PTable> indexes = // Only maintain tables with immutable rows through this client-side mechanism
            (table.isImmutableRows() || includeMutableIndexes) ? 
                    IndexMaintainer.nonDisabledIndexIterator(table.getIndexes().iterator()) : 
                    Iterators.<PTable>emptyIterator();
    final List<Mutation> mutationList = Lists.newArrayListWithExpectedSize(values.size());
    final List<Mutation> mutationsPertainingToIndex = indexes.hasNext() ? Lists.<Mutation>newArrayListWithExpectedSize(values.size()) : null;
    generateMutations(tableRef, timestamp, values, mutationList, mutationsPertainingToIndex);
    return new Iterator<Pair<byte[],List<Mutation>>>() {
        boolean isFirst = true;

        @Override
        public boolean hasNext() {
            return isFirst || indexes.hasNext();
        }

        @Override
        public Pair<byte[], List<Mutation>> next() {
            if (isFirst) {
                isFirst = false;
                return new Pair<byte[],List<Mutation>>(table.getPhysicalName().getBytes(), mutationList);
            }
            PTable index = indexes.next();
            List<Mutation> indexMutations;
            try {
                indexMutations =
                        IndexUtil.generateIndexData(table, index, mutationsPertainingToIndex,
                            connection.getKeyValueBuilder(), connection);
                // we may also have to include delete mutations for immutable tables if we are not processing all the tables in the mutations map
                if (!sendAll) {
                    TableRef key = new TableRef(index);
                    Map<ImmutableBytesPtr, RowMutationState> rowToColumnMap = mutations.remove(key);
                    if (rowToColumnMap!=null) {
                        final List<Mutation> deleteMutations = Lists.newArrayList();
                        generateMutations(tableRef, timestamp, rowToColumnMap, deleteMutations, null);
                        indexMutations.addAll(deleteMutations);
                    }
                }
            } catch (SQLException e) {
                throw new IllegalDataException(e);
            }
            return new Pair<byte[],List<Mutation>>(index.getPhysicalName().getBytes(),indexMutations);
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }

    };
}

上面的方法就是进行生成 Mutations对象，把数据准备往hbase里面插入

当PhoenixConnection.commit 方法jdbc提交查询时，就会调用到如下的方法，就会调用到 MutationState.commit
.当 MutationState 对象进行commit的时候，调用了如下的方法，发送到hbase当中

  private void send(Iterator<TableRef> tableRefIterator) throws SQLException {
    int i = 0;
    long[] serverTimeStamps = null;
    boolean sendAll = false;
    if (tableRefIterator == null) {
        serverTimeStamps = validateAll();
        tableRefIterator = mutations.keySet().iterator();
        sendAll = true;
    }

    Map<ImmutableBytesPtr, RowMutationState> valuesMap;
    List<TableRef> txTableRefs = Lists.newArrayListWithExpectedSize(mutations.size());
    // add tracing for this operation
    try (TraceScope trace = Tracing.startNewSpan(connection, "Committing mutations to tables")) {
        Span span = trace.getSpan();
        ImmutableBytesWritable indexMetaDataPtr = new ImmutableBytesWritable();
        boolean isTransactional;
        while (tableRefIterator.hasNext()) {
            // at this point we are going through mutations for each table
            final TableRef tableRef = tableRefIterator.next();
            valuesMap = mutations.get(tableRef);
            if (valuesMap == null || valuesMap.isEmpty()) {
                continue;
            }
            // Validate as we go if transactional since we can undo if a problem occurs (which is unlikely)
            long serverTimestamp = serverTimeStamps == null ? validate(tableRef, valuesMap) : serverTimeStamps[i++];
            final PTable table = tableRef.getTable();
            // Track tables to which we've sent uncommitted data
            if (isTransactional = table.isTransactional()) {
                txTableRefs.add(tableRef);
                addDMLFence(table);
                uncommittedPhysicalNames.add(table.getPhysicalName().getString());
            }
            boolean isDataTable = true;
            table.getIndexMaintainers(indexMetaDataPtr, connection);
            Iterator<Pair<byte[],List<Mutation>>> mutationsIterator = addRowMutations(tableRef, valuesMap, serverTimestamp, false, sendAll);
            while (mutationsIterator.hasNext()) {
                Pair<byte[],List<Mutation>> pair = mutationsIterator.next();
                byte[] htableName = pair.getFirst();
                List<Mutation> mutationList = pair.getSecond();

                //create a span per target table
                //TODO maybe we can be smarter about the table name to string here?
                Span child = Tracing.child(span,"Writing mutation batch for table: "+Bytes.toString(htableName));

                int retryCount = 0;
                boolean shouldRetry = false;
                do {
                    final ServerCache cache = isDataTable ? setMetaDataOnMutations(tableRef, mutationList, indexMetaDataPtr) : null;

                    // If we haven't retried yet, retry for this case only, as it's possible that
                    // a split will occur after we send the index metadata cache to all known
                    // region servers.
                    shouldRetry = cache != null;
                    SQLException sqlE = null;
                    HTableInterface hTable = connection.getQueryServices().getTable(htableName);
                    try {
                        if (isTransactional) {
                            // If we have indexes, wrap the HTable in a delegate HTable that
                            // will attach the necessary index meta data in the event of a
                            // rollback
                            if (!table.getIndexes().isEmpty()) {
                                hTable = new MetaDataAwareHTable(hTable, tableRef);
                            }
                            TransactionAwareHTable txnAware = TransactionUtil.getTransactionAwareHTable(hTable, table);
                            // Don't add immutable indexes (those are the only ones that would participate
                            // during a commit), as we don't need conflict detection for these.
                            if (isDataTable) {
                                // Even for immutable, we need to do this so that an abort has the state
                                // necessary to generate the rows to delete.
                                addTransactionParticipant(txnAware);
                            } else {
                                txnAware.startTx(getTransaction());
                            }
                            hTable = txnAware;
                        }
                        long numMutations = mutationList.size();
                        GLOBAL_MUTATION_BATCH_SIZE.update(numMutations);

                        long startTime = System.currentTimeMillis();
                        child.addTimelineAnnotation("Attempt " + retryCount);
                            //很核心的这里进行了批量入库数据了
                        hTable.batch(mutationList);
                        if (logger.isDebugEnabled()) logger.debug("Sent batch of " + numMutations + " for " + Bytes.toString(htableName));
                        child.stop();
                        child.stop();
                        shouldRetry = false;
                        long mutationCommitTime = System.currentTimeMillis() - startTime;
                        GLOBAL_MUTATION_COMMIT_TIME.update(mutationCommitTime);

                        long mutationSizeBytes = calculateMutationSize(mutationList);
                        MutationMetric mutationsMetric = new MutationMetric(numMutations, mutationSizeBytes, mutationCommitTime);
                        mutationMetricQueue.addMetricsForTable(Bytes.toString(htableName), mutationsMetric);

这里的upsert的核心就上面的 hTable.batch(mutationList); 方法，把数据直接写到hbase当中去了

这样整个phoenix的插入数据的sql解释流程就完成了