text:
package org.apache.phoenix.compile;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.collect.Lists.newArrayListWithCapacity;

import java.sql.ParameterMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.phoenix.cache.ServerCacheClient.ServerCache;
import org.apache.phoenix.compile.GroupByCompiler.GroupBy;
import org.apache.phoenix.compile.OrderByCompiler.OrderBy;
import org.apache.phoenix.coprocessor.BaseScannerRegionObserver;
import org.apache.phoenix.coprocessor.UngroupedAggregateRegionObserver;
import org.apache.phoenix.exception.SQLExceptionCode;
import org.apache.phoenix.exception.SQLExceptionInfo;
import org.apache.phoenix.execute.AggregatePlan;
import org.apache.phoenix.execute.MutationState;
import org.apache.phoenix.execute.MutationState.RowMutationState;
import org.apache.phoenix.execute.MutationState.RowTimestampColInfo;
import org.apache.phoenix.expression.Determinism;
import org.apache.phoenix.expression.Expression;
import org.apache.phoenix.expression.LiteralExpression;
import org.apache.phoenix.hbase.index.util.ImmutableBytesPtr;
import org.apache.phoenix.index.IndexMetaDataCacheClient;
import org.apache.phoenix.index.PhoenixIndexCodec;
import org.apache.phoenix.iterate.ResultIterator;
import org.apache.phoenix.jdbc.PhoenixConnection;
import org.apache.phoenix.jdbc.PhoenixResultSet;
import org.apache.phoenix.jdbc.PhoenixStatement;
import org.apache.phoenix.jdbc.PhoenixStatement.Operation;
import org.apache.phoenix.optimize.QueryOptimizer;
import org.apache.phoenix.parse.AliasedNode;
import org.apache.phoenix.parse.BindParseNode;
import org.apache.phoenix.parse.ColumnName;
import org.apache.phoenix.parse.HintNode;
import org.apache.phoenix.parse.HintNode.Hint;
import org.apache.phoenix.parse.LiteralParseNode;
import org.apache.phoenix.parse.NamedTableNode;
import org.apache.phoenix.parse.ParseNode;
import org.apache.phoenix.parse.SelectStatement;
import org.apache.phoenix.parse.SequenceValueParseNode;
import org.apache.phoenix.parse.UpsertStatement;
import org.apache.phoenix.query.ConnectionQueryServices;
import org.apache.phoenix.query.QueryServices;
import org.apache.phoenix.query.QueryServicesOptions;
import org.apache.phoenix.schema.ColumnRef;
import org.apache.phoenix.schema.ConstraintViolationException;
import org.apache.phoenix.schema.IllegalDataException;
import org.apache.phoenix.schema.MetaDataClient;
import org.apache.phoenix.schema.MetaDataEntityNotFoundException;
import org.apache.phoenix.schema.PColumn;
import org.apache.phoenix.schema.PColumnImpl;
import org.apache.phoenix.schema.PName;
import org.apache.phoenix.schema.PTable;
import org.apache.phoenix.schema.PTable.ViewType;
import org.apache.phoenix.schema.PTableImpl;
import org.apache.phoenix.schema.PTableType;
import org.apache.phoenix.schema.ReadOnlyTableException;
import org.apache.phoenix.schema.SortOrder;
import org.apache.phoenix.schema.TableRef;
import org.apache.phoenix.schema.TypeMismatchException;
import org.apache.phoenix.schema.tuple.Tuple;
import org.apache.phoenix.schema.types.PDataType;
import org.apache.phoenix.schema.types.PLong;
import org.apache.phoenix.schema.types.PTimestamp;
import org.apache.phoenix.schema.types.PUnsignedLong;
import org.apache.phoenix.util.ByteUtil;
import org.apache.phoenix.util.IndexUtil;
import org.apache.phoenix.util.MetaDataUtil;
import org.apache.phoenix.util.ScanUtil;
import org.apache.phoenix.util.SchemaUtil;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;

public class UpsertCompiler {
    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));
    }

    private static MutationState upsertSelect(StatementContext childContext, TableRef tableRef, RowProjector projector,
            ResultIterator iterator, int[] columnIndexes, int[] pkSlotIndexes, boolean useServerTimestamp) throws SQLException {
        PhoenixStatement statement = childContext.getStatement();
        PhoenixConnection connection = statement.getConnection();
        ConnectionQueryServices services = connection.getQueryServices();
        int maxSize = services.getProps().getInt(QueryServices.MAX_MUTATION_SIZE_ATTRIB,
                QueryServicesOptions.DEFAULT_MAX_MUTATION_SIZE);
        int batchSize = Math.min(connection.getMutateBatchSize(), maxSize);
        boolean isAutoCommit = connection.getAutoCommit();
        byte[][] values = new byte[columnIndexes.length][];
        int rowCount = 0;
        Map<ImmutableBytesPtr, RowMutationState> mutation = Maps.newHashMapWithExpectedSize(batchSize);
        PTable table = tableRef.getTable();
        try (ResultSet rs = new PhoenixResultSet(iterator, projector, childContext)) {
            ImmutableBytesWritable ptr = new ImmutableBytesWritable();
            while (rs.next()) {
                for (int i = 0; i < values.length; i++) {
                    PColumn column = table.getColumns().get(columnIndexes[i]);
                    byte[] bytes = rs.getBytes(i + 1);
                    ptr.set(bytes == null ? ByteUtil.EMPTY_BYTE_ARRAY : bytes);
                    Object value = rs.getObject(i + 1);
                    int rsPrecision = rs.getMetaData().getPrecision(i + 1);
                    Integer precision = rsPrecision == 0 ? null : rsPrecision;
                    int rsScale = rs.getMetaData().getScale(i + 1);
                    Integer scale = rsScale == 0 ? null : rsScale;
                    // We are guaranteed that the two column will have compatible types,
                    // as we checked that before.
                    if (!column.getDataType().isSizeCompatible(ptr, value, column.getDataType(), precision, scale,
                            column.getMaxLength(), column.getScale())) { throw new SQLExceptionInfo.Builder(
                            SQLExceptionCode.DATA_EXCEEDS_MAX_CAPACITY).setColumnName(column.getName().getString())
                            .setMessage("value=" + column.getDataType().toStringLiteral(ptr, null)).build()
                            .buildException(); }
                    column.getDataType().coerceBytes(ptr, value, column.getDataType(),
                            precision, scale, SortOrder.getDefault(),
                            column.getMaxLength(), column.getScale(), column.getSortOrder(),
                            table.rowKeyOrderOptimizable());
                    values[i] = ByteUtil.copyKeyBytesIfNecessary(ptr);
                }
                setValues(values, pkSlotIndexes, columnIndexes, table, mutation, statement, useServerTimestamp);
                rowCount++;
                // Commit a batch if auto commit is true and we're at our batch size
                if (isAutoCommit && rowCount % batchSize == 0) {
                    MutationState state = new MutationState(tableRef, mutation, 0, maxSize, connection);
                    connection.getMutationState().join(state);
                    connection.getMutationState().send();
                    mutation.clear();
                }
            }
            // If auto commit is true, this last batch will be committed upon return
            return new MutationState(tableRef, mutation, rowCount / batchSize * batchSize, maxSize, connection);
        }
    }

    private static class UpsertingParallelIteratorFactory extends MutatingParallelIteratorFactory {
        private RowProjector projector;
        private int[] columnIndexes;
        private int[] pkSlotIndexes;
        private final TableRef tableRef;
        private final boolean useSeverTimestamp;

        private UpsertingParallelIteratorFactory (PhoenixConnection connection, TableRef tableRef, boolean useServerTimestamp) {
            super(connection);
            this.tableRef = tableRef;
            this.useSeverTimestamp = useServerTimestamp;
        }

        @Override
        protected MutationState mutate(StatementContext parentContext, ResultIterator iterator, PhoenixConnection connection) throws SQLException {
            if (parentContext.getSequenceManager().getSequenceCount() > 0) {
                throw new IllegalStateException("Cannot pipeline upsert when sequence is referenced");
            }
            PhoenixStatement statement = new PhoenixStatement(connection);
            /*
             * We don't want to collect any read metrics within the child context. This is because any read metrics that
             * need to be captured are already getting collected in the parent statement context enclosed in the result
             * iterator being used for reading rows out.
             */
            StatementContext childContext = new StatementContext(statement, false);
            // Clone the row projector as it's not thread safe and would be used simultaneously by
            // multiple threads otherwise.
            MutationState state = upsertSelect(childContext, tableRef, projector.cloneIfNecessary(), iterator, columnIndexes, pkSlotIndexes, useSeverTimestamp);
            return state;
        }

        public void setRowProjector(RowProjector projector) {
            this.projector = projector;
        }
        public void setColumnIndexes(int[] columnIndexes) {
            this.columnIndexes = columnIndexes;
        }
        public void setPkSlotIndexes(int[] pkSlotIndexes) {
            this.pkSlotIndexes = pkSlotIndexes;
        }
    }

    private final PhoenixStatement statement;
    private final Operation operation;

    public UpsertCompiler(PhoenixStatement statement, Operation operation) {
        this.statement = statement;
        this.operation = operation;
    }

    private static LiteralParseNode getNodeForRowTimestampColumn(PColumn col) {
        PDataType type = col.getDataType();
        long dummyValue = 0L;
        if (type.isCoercibleTo(PTimestamp.INSTANCE)) {
            return new LiteralParseNode(new Timestamp(dummyValue), PTimestamp.INSTANCE);
        } else if (type == PLong.INSTANCE || type == PUnsignedLong.INSTANCE) {
            return new LiteralParseNode(dummyValue, PLong.INSTANCE);
        }
        throw new IllegalArgumentException();
    }

    public MutationPlan compile(UpsertStatement upsert) throws SQLException {
        final PhoenixConnection connection = statement.getConnection();
        ConnectionQueryServices services = connection.getQueryServices();
        final int maxSize = services.getProps().getInt(QueryServices.MAX_MUTATION_SIZE_ATTRIB,QueryServicesOptions.DEFAULT_MAX_MUTATION_SIZE);
        List<ColumnName> columnNodes = upsert.getColumns();
        TableRef tableRefToBe = null;
        PTable table = null;
        Set<PColumn> addViewColumnsToBe = Collections.emptySet();
        Set<PColumn> overlapViewColumnsToBe = Collections.emptySet();
        List<PColumn> allColumnsToBe = Collections.emptyList();
        boolean isTenantSpecific = false;
        boolean isSharedViewIndex = false;
        String tenantIdStr = null;
        ColumnResolver resolver = null;
        int[] columnIndexesToBe;
        int nColumnsToSet = 0;
        int[] pkSlotIndexesToBe;
        List<ParseNode> valueNodes = upsert.getValues();
        List<PColumn> targetColumns;
        NamedTableNode tableNode = upsert.getTable();
        String tableName = tableNode.getName().getTableName();
        String schemaName = tableNode.getName().getSchemaName();
        QueryPlan queryPlanToBe = null;
        int nValuesToSet;
        boolean sameTable = false;
        boolean runOnServer = false;
        UpsertingParallelIteratorFactory parallelIteratorFactoryToBe = null;
        // Retry once if auto commit is off, as the meta data may
        // be out of date. We do not retry if auto commit is on, as we
        // update the cache up front when we create the resolver in that case.
        boolean retryOnce = !connection.getAutoCommit();
        boolean useServerTimestampToBe = false;
        while (true) {
            try {
                resolver = FromCompiler.getResolverForMutation(upsert, connection);
                tableRefToBe = resolver.getTables().get(0);
                table = tableRefToBe.getTable();
                // Cannot update:
                // - read-only VIEW
                // - transactional table with a connection having an SCN
                if (table.getType() == PTableType.VIEW && table.getViewType().isReadOnly()) {
                    throw new ReadOnlyTableException(schemaName,tableName);
                }
                else if (table.isTransactional() && connection.getSCN() != null) {
                    throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_SPECIFY_SCN_FOR_TXN_TABLE).setSchemaName(schemaName)
                    .setTableName(tableName).build().buildException();
                }
                boolean isSalted = table.getBucketNum() != null;
                isTenantSpecific = table.isMultiTenant() && connection.getTenantId() != null;
                isSharedViewIndex = table.getViewIndexId() != null;
                tenantIdStr = isTenantSpecific ? connection.getTenantId().getString() : null;
                int posOffset = isSalted ? 1 : 0;
                // Setup array of column indexes parallel to values that are going to be set
                allColumnsToBe = table.getColumns();

                nColumnsToSet = 0;
                if (table.getViewType() == ViewType.UPDATABLE) {
                    addViewColumnsToBe = Sets.newLinkedHashSetWithExpectedSize(allColumnsToBe.size());
                    for (PColumn column : allColumnsToBe) {
                        if (column.getViewConstant() != null) {
                            addViewColumnsToBe.add(column);
                        }
                    }
                }
                ImmutableBytesWritable ptr = new ImmutableBytesWritable();
                // Allow full row upsert if no columns or only dynamic ones are specified and values count match
                if (columnNodes.isEmpty() || columnNodes.size() == upsert.getTable().getDynamicColumns().size()) {
                    nColumnsToSet = allColumnsToBe.size() - posOffset;
                    columnIndexesToBe = new int[nColumnsToSet];
                    pkSlotIndexesToBe = new int[columnIndexesToBe.length];
                    targetColumns = Lists.newArrayListWithExpectedSize(columnIndexesToBe.length);
                    targetColumns.addAll(Collections.<PColumn>nCopies(columnIndexesToBe.length, null));
                    int minPKPos = 0;
                    if (isTenantSpecific) {
                        PColumn tenantColumn = table.getPKColumns().get(minPKPos);
                        columnIndexesToBe[minPKPos] = tenantColumn.getPosition();
                        targetColumns.set(minPKPos, tenantColumn);
                        minPKPos++;
                    }
                    if (isSharedViewIndex) {
                        PColumn indexIdColumn = table.getPKColumns().get(minPKPos);
                        columnIndexesToBe[minPKPos] = indexIdColumn.getPosition();
                        targetColumns.set(minPKPos, indexIdColumn);
                        minPKPos++;
                    }
                    for (int i = posOffset, j = 0; i < allColumnsToBe.size(); i++) {
                        PColumn column = allColumnsToBe.get(i);
                        if (SchemaUtil.isPKColumn(column)) {
                            pkSlotIndexesToBe[i-posOffset] = j + posOffset;
                            if (j++ < minPKPos) { // Skip, as it's already been set above
                                continue;
                            }
                            minPKPos = 0;
                        }
                        columnIndexesToBe[i-posOffset+minPKPos] = i;
                        targetColumns.set(i-posOffset+minPKPos, column);
                    }
                    if (!addViewColumnsToBe.isEmpty()) {
                        // All view columns overlap in this case
                        overlapViewColumnsToBe = addViewColumnsToBe;
                        addViewColumnsToBe = Collections.emptySet();
                    }
                } else {
                    // Size for worse case
                    int numColsInUpsert = columnNodes.size();
                    nColumnsToSet = numColsInUpsert + addViewColumnsToBe.size() + (isTenantSpecific ? 1 : 0) +  + (isSharedViewIndex ? 1 : 0);
                    columnIndexesToBe = new int[nColumnsToSet];
                    pkSlotIndexesToBe = new int[columnIndexesToBe.length];
                    targetColumns = Lists.newArrayListWithExpectedSize(columnIndexesToBe.length);
                    targetColumns.addAll(Collections.<PColumn>nCopies(columnIndexesToBe.length, null));
                    Arrays.fill(columnIndexesToBe, -1); // TODO: necessary? So we'll get an AIOB exception if it's not replaced
                    Arrays.fill(pkSlotIndexesToBe, -1); // TODO: necessary? So we'll get an AIOB exception if it's not replaced
                    BitSet pkColumnsSet = new BitSet(table.getPKColumns().size());
                    int i = 0;
                    // Add tenant column directly, as we don't want to resolve it as this will fail
                    if (isTenantSpecific) {
                        PColumn tenantColumn = table.getPKColumns().get(i + posOffset);
                        columnIndexesToBe[i] = tenantColumn.getPosition();
                        pkColumnsSet.set(pkSlotIndexesToBe[i] = i + posOffset);
                        targetColumns.set(i, tenantColumn);
                        i++;
                    }
                    if (isSharedViewIndex) {
                        PColumn indexIdColumn = table.getPKColumns().get(i + posOffset);
                        columnIndexesToBe[i] = indexIdColumn.getPosition();
                        pkColumnsSet.set(pkSlotIndexesToBe[i] = i + posOffset);
                        targetColumns.set(i, indexIdColumn);
                        i++;
                    }
                    for (ColumnName colName : columnNodes) {
                        ColumnRef ref = resolver.resolveColumn(null, colName.getFamilyName(), colName.getColumnName());
                        PColumn column = ref.getColumn();
                        if (IndexUtil.getViewConstantValue(column, ptr)) {
                            if (overlapViewColumnsToBe.isEmpty()) {
                                overlapViewColumnsToBe = Sets.newHashSetWithExpectedSize(addViewColumnsToBe.size());
                            }
                            nColumnsToSet--;
                            overlapViewColumnsToBe.add(column);
                            addViewColumnsToBe.remove(column);
                        }
                        columnIndexesToBe[i] = ref.getColumnPosition();
                        targetColumns.set(i, column);
                        if (SchemaUtil.isPKColumn(column)) {
                            pkColumnsSet.set(pkSlotIndexesToBe[i] = ref.getPKSlotPosition());
                        }
                        i++;
                    }
                    for (PColumn column : addViewColumnsToBe) {
                        columnIndexesToBe[i] = column.getPosition();
                        targetColumns.set(i, column);
                        if (SchemaUtil.isPKColumn(column)) {
                            pkColumnsSet.set(pkSlotIndexesToBe[i] = SchemaUtil.getPKPosition(table, column));
                        }
                        i++;
                    }
                    // If a table has rowtimestamp col, then we always set it.
                    useServerTimestampToBe = table.getRowTimestampColPos() != -1 && !isRowTimestampSet(pkSlotIndexesToBe, table);
                    if (useServerTimestampToBe) {
                        PColumn rowTimestampCol = table.getPKColumns().get(table.getRowTimestampColPos());
                        // Need to resize columnIndexesToBe and pkSlotIndexesToBe to include this extra column.
                        columnIndexesToBe = Arrays.copyOf(columnIndexesToBe, columnIndexesToBe.length + 1);
                        pkSlotIndexesToBe = Arrays.copyOf(pkSlotIndexesToBe, pkSlotIndexesToBe.length + 1);
                        columnIndexesToBe[i] = rowTimestampCol.getPosition();
                        pkColumnsSet.set(pkSlotIndexesToBe[i] = table.getRowTimestampColPos());
                        targetColumns.add(rowTimestampCol);
                        if (valueNodes != null && !valueNodes.isEmpty()) {
                            valueNodes.add(getNodeForRowTimestampColumn(rowTimestampCol));
                        }
                        nColumnsToSet++;
                    }
                    for (i = posOffset; i < table.getPKColumns().size(); i++) {
                        PColumn pkCol = table.getPKColumns().get(i);
                        if (!pkColumnsSet.get(i)) {
                            if (!pkCol.isNullable()) {
                                throw new ConstraintViolationException(table.getName().getString() + "." + pkCol.getName().getString() + " may not be null");
                            }
                        }
                    }
                }
                boolean isAutoCommit = connection.getAutoCommit();
                if (valueNodes == null) {
                    SelectStatement select = upsert.getSelect();
                    assert(select != null);
                    select = SubselectRewriter.flatten(select, connection);
                    ColumnResolver selectResolver = FromCompiler.getResolverForQuery(select, connection);
                    select = StatementNormalizer.normalize(select, selectResolver);
                    select = prependTenantAndViewConstants(table, select, tenantIdStr, addViewColumnsToBe, useServerTimestampToBe);
                    SelectStatement transformedSelect = SubqueryRewriter.transform(select, selectResolver, connection);
                    if (transformedSelect != select) {
                        selectResolver = FromCompiler.getResolverForQuery(transformedSelect, connection);
                        select = StatementNormalizer.normalize(transformedSelect, selectResolver);
                    }
                    sameTable = !select.isJoin()
                        && tableRefToBe.equals(selectResolver.getTables().get(0));
                    tableRefToBe = adjustTimestampToMinOfSameTable(tableRefToBe, selectResolver.getTables());
                    /* We can run the upsert in a coprocessor if:
                     * 1) from has only 1 table and the into table matches from table
                     * 2) the select query isn't doing aggregation (which requires a client-side final merge)
                     * 3) autoCommit is on
                     * 4) the table is not immutable with indexes, as the client is the one that figures out the additional
                     *    puts for index tables.
                     * 5) no limit clause, as the limit clause requires client-side post processing
                     * 6) no sequences, as sequences imply that the order of upsert must match the order of
                     *    selection. TODO: change this and only force client side if there's a ORDER BY on the sequence value
                     * Otherwise, run the query to pull the data from the server
                     * and populate the MutationState (upto a limit).
                    */
                    if (! (select.isAggregate() || select.isDistinct() || select.getLimit() != null || select.hasSequence()) ) {
                        // We can pipeline the upsert select instead of spooling everything to disk first,
                        // if we don't have any post processing that's required.
                        parallelIteratorFactoryToBe = new UpsertingParallelIteratorFactory(connection, tableRefToBe, useServerTimestampToBe);
                        // If we're in the else, then it's not an aggregate, distinct, limited, or sequence using query,
                        // so we might be able to run it entirely on the server side.
                        // For a table with row timestamp column, we can't guarantee that the row key will reside in the
                        // region space managed by region servers. So we bail out on executing on server side.
                        runOnServer = sameTable && isAutoCommit && !table.isTransactional() && !(table.isImmutableRows() && !table.getIndexes().isEmpty()) && table.getRowTimestampColPos() == -1;
                    }
                    // If we may be able to run on the server, add a hint that favors using the data table
                    // if all else is equal.
                    // TODO: it'd be nice if we could figure out in advance if the PK is potentially changing,
                    // as this would disallow running on the server. We currently use the row projector we
                    // get back to figure this out.
                    HintNode hint = upsert.getHint();
                    if (!upsert.getHint().hasHint(Hint.USE_INDEX_OVER_DATA_TABLE)) {
                        hint = HintNode.create(hint, Hint.USE_DATA_OVER_INDEX_TABLE);
                    }
                    select = SelectStatement.create(select, hint);
                    // Pass scan through if same table in upsert and select so that projection is computed correctly
                    // Use optimizer to choose the best plan
                    try {
                        QueryCompiler compiler = new QueryCompiler(statement, select, selectResolver, targetColumns, parallelIteratorFactoryToBe, new SequenceManager(statement), false);
                        queryPlanToBe = compiler.compile();
                        // This is post-fix: if the tableRef is a projected table, this means there are post-processing
                        // steps and parallelIteratorFactory did not take effect.
                        if (queryPlanToBe.getTableRef().getTable().getType() == PTableType.PROJECTED || queryPlanToBe.getTableRef().getTable().getType() == PTableType.SUBQUERY) {
                            parallelIteratorFactoryToBe = null;
                        }
                    } catch (MetaDataEntityNotFoundException e) {
                        retryOnce = false; // don't retry if select clause has meta data entities that aren't found, as we already updated the cache
                        throw e;
                    }
                    nValuesToSet = queryPlanToBe.getProjector().getColumnCount();
                    // Cannot auto commit if doing aggregation or topN or salted
                    // Salted causes problems because the row may end up living on a different region
                } else {
                    nValuesToSet = valueNodes.size() + addViewColumnsToBe.size() + (isTenantSpecific ? 1 : 0) + (isSharedViewIndex ? 1 : 0);
                }
                // Resize down to allow a subset of columns to be specifiable
                if (columnNodes.isEmpty() && columnIndexesToBe.length >= nValuesToSet) {
                    nColumnsToSet = nValuesToSet;
                    columnIndexesToBe = Arrays.copyOf(columnIndexesToBe, nValuesToSet);
                    pkSlotIndexesToBe = Arrays.copyOf(pkSlotIndexesToBe, nValuesToSet);
                }

                if (nValuesToSet != nColumnsToSet) {
                    // We might have added columns, so refresh cache and try again if stale.
                    // Note that this check is not really sufficient, as a column could have
                    // been removed and the added back and we wouldn't detect that here.
                    if (retryOnce) {
                        retryOnce = false;
                        if (new MetaDataClient(connection).updateCache(schemaName, tableName).wasUpdated()) {
                            continue;
                        }
                    }
                    throw new SQLExceptionInfo.Builder(SQLExceptionCode.UPSERT_COLUMN_NUMBERS_MISMATCH)
                        .setMessage("Numbers of columns: " + nColumnsToSet + ". Number of values: " + nValuesToSet)
                        .build().buildException();
                }
            } catch (MetaDataEntityNotFoundException e) {
                // Catch column/column family not found exception, as our meta data may
                // be out of sync. Update the cache once and retry if we were out of sync.
                // Otherwise throw, as we'll just get the same error next time.
                if (retryOnce) {
                    retryOnce = false;
                    if (new MetaDataClient(connection).updateCache(schemaName, tableName).wasUpdated()) {
                        continue;
                    }
                }
                throw e;
            }
            break;
        }

        final QueryPlan originalQueryPlan = queryPlanToBe;
        RowProjector projectorToBe = null;
        // Optimize only after all checks have been performed
        if (valueNodes == null) {
            queryPlanToBe = new QueryOptimizer(services).optimize(queryPlanToBe, statement, targetColumns, parallelIteratorFactoryToBe);
            projectorToBe = queryPlanToBe.getProjector();
            runOnServer &= queryPlanToBe.getTableRef().equals(tableRefToBe);
        }
        final List<PColumn> allColumns = allColumnsToBe;
        final RowProjector projector = projectorToBe;
        final QueryPlan queryPlan = queryPlanToBe;
        final TableRef tableRef = tableRefToBe;
        final Set<PColumn> addViewColumns = addViewColumnsToBe;
        final Set<PColumn> overlapViewColumns = overlapViewColumnsToBe;
        final UpsertingParallelIteratorFactory parallelIteratorFactory = parallelIteratorFactoryToBe;
        final int[] columnIndexes = columnIndexesToBe;
        final int[] pkSlotIndexes = pkSlotIndexesToBe;
        final boolean useServerTimestamp = useServerTimestampToBe;
        if (table.getRowTimestampColPos() == -1 && useServerTimestamp) {
            throw new IllegalStateException("For a table without row timestamp column, useServerTimestamp cannot be true");
        }
        // TODO: break this up into multiple functions
        ////////////////////////////////////////////////////////////////////
        // UPSERT SELECT
        /////////////////////////////////////////////////////////////////////
        if (valueNodes == null) {
            // Before we re-order, check that for updatable view columns
            // the projected expression either matches the column name or
            // is a constant with the same required value.
            throwIfNotUpdatable(tableRef, overlapViewColumnsToBe, targetColumns, projector, sameTable);

            ////////////////////////////////////////////////////////////////////
            // UPSERT SELECT run server-side (maybe)
            /////////////////////////////////////////////////////////////////////
            if (runOnServer) {
                // At most this array will grow bigger by the number of PK columns
                int[] allColumnsIndexes = Arrays.copyOf(columnIndexes, columnIndexes.length + nValuesToSet);
                int[] reverseColumnIndexes = new int[table.getColumns().size()];
                List<Expression> projectedExpressions = Lists.newArrayListWithExpectedSize(reverseColumnIndexes.length);
                Arrays.fill(reverseColumnIndexes, -1);
                for (int i =0; i < nValuesToSet; i++) {
                    projectedExpressions.add(projector.getColumnProjector(i).getExpression());
                    reverseColumnIndexes[columnIndexes[i]] = i;
                }
                /*
                 * Order projected columns and projected expressions with PK columns
                 * leading order by slot position
                 */
                int offset = table.getBucketNum() == null ? 0 : 1;
                for (int i = 0; i < table.getPKColumns().size() - offset; i++) {
                    PColumn column = table.getPKColumns().get(i + offset);
                    int pos = reverseColumnIndexes[column.getPosition()];
                    if (pos == -1) {
                        // Last PK column may be fixed width and nullable
                        // We don't want to insert a null expression b/c
                        // it's not valid to set a fixed width type to null.
                        if (column.getDataType().isFixedWidth()) {
                            continue;
                        }
                        // Add literal null for missing PK columns
                        pos = projectedExpressions.size();
                        Expression literalNull = LiteralExpression.newConstant(null, column.getDataType(), Determinism.ALWAYS);
                        projectedExpressions.add(literalNull);
                        allColumnsIndexes[pos] = column.getPosition();
                    }
                    // Swap select expression at pos with i
                    Collections.swap(projectedExpressions, i, pos);
                    // Swap column indexes and reverse column indexes too
                    int tempPos = allColumnsIndexes[i];
                    allColumnsIndexes[i] = allColumnsIndexes[pos];
                    allColumnsIndexes[pos] = tempPos;
                    reverseColumnIndexes[tempPos] = reverseColumnIndexes[i];
                    reverseColumnIndexes[i] = i;
                }
                // If any pk slots are changing, be conservative and don't run this server side.
                // If the row ends up living in a different region, we'll get an error otherwise.
                for (int i = 0; i < table.getPKColumns().size(); i++) {
                    PColumn column = table.getPKColumns().get(i);
                    Expression source = projectedExpressions.get(i);
                    if (source == null || !source.equals(new ColumnRef(tableRef, column.getPosition()).newColumnExpression())) {
                        // TODO: we could check the region boundaries to see if the pk will still be in it.
                        runOnServer = false; // bail on running server side, since PK may be changing
                        break;
                    }
                }

                ////////////////////////////////////////////////////////////////////
                // UPSERT SELECT run server-side
                /////////////////////////////////////////////////////////////////////
                if (runOnServer) {
                    // Iterate through columns being projected
                    List<PColumn> projectedColumns = Lists.newArrayListWithExpectedSize(projectedExpressions.size());
                    for (int i = 0; i < projectedExpressions.size(); i++) {
                        // Must make new column if position has changed
                        PColumn column = allColumns.get(allColumnsIndexes[i]);
                        projectedColumns.add(column.getPosition() == i ? column : new PColumnImpl(column, i));
                    }
                    // Build table from projectedColumns
                    PTable projectedTable = PTableImpl.makePTable(table, projectedColumns);

                    SelectStatement select = SelectStatement.create(SelectStatement.COUNT_ONE, upsert.getHint());
                    StatementContext statementContext = queryPlan.getContext();
                    RowProjector aggProjectorToBe = ProjectionCompiler.compile(statementContext, select, GroupBy
                            .EMPTY_GROUP_BY);
                    statementContext.getAggregationManager().compile(queryPlan.getContext()
                            ,GroupBy.EMPTY_GROUP_BY);
                    if (queryPlan.getProjector().projectEveryRow()) {
                        aggProjectorToBe = new RowProjector(aggProjectorToBe,true);
                    }
                    final RowProjector aggProjector = aggProjectorToBe;

                    /*
                     * Transfer over PTable representing subset of columns selected, but all PK columns.
                     * Move columns setting PK first in pkSlot order, adding LiteralExpression of null for any missing ones.
                     * Transfer over List<Expression> for projection.
                     * In region scan, evaluate expressions in order, collecting first n columns for PK and collection non PK in mutation Map
                     * Create the PRow and get the mutations, adding them to the batch
                     */
                    final StatementContext context = queryPlan.getContext();
                    final Scan scan = context.getScan();
                    scan.setAttribute(BaseScannerRegionObserver.UPSERT_SELECT_TABLE, UngroupedAggregateRegionObserver.serialize(projectedTable));
                    scan.setAttribute(BaseScannerRegionObserver.UPSERT_SELECT_EXPRS, UngroupedAggregateRegionObserver.serialize(projectedExpressions));

                    // Ignore order by - it has no impact
                    final QueryPlan aggPlan = new AggregatePlan(context, select, tableRef, aggProjector, null,null, OrderBy.EMPTY_ORDER_BY, null, GroupBy.EMPTY_GROUP_BY, null);
                    return new MutationPlan() {
                        @Override
                        public ParameterMetaData getParameterMetaData() {
                            return queryPlan.getContext().getBindManager().getParameterMetaData();
                        }

                        @Override
                        public StatementContext getContext() {
                            return queryPlan.getContext();
                        }

                        @Override
                        public TableRef getTargetRef() {
                            return tableRef;
                        }

                        @Override
                        public Set<TableRef> getSourceRefs() {
                            return originalQueryPlan.getSourceRefs();
                        }

                		@Override
                		public Operation getOperation() {
                			return operation;
                		}

                        @Override
                        public MutationState execute() throws SQLException {
                            ImmutableBytesWritable ptr = context.getTempPtr();
                            PTable table = tableRef.getTable();
                            table.getIndexMaintainers(ptr, context.getConnection());
                            byte[] txState = table.isTransactional() ? connection.getMutationState().encodeTransaction() : ByteUtil.EMPTY_BYTE_ARRAY;

                            ServerCache cache = null;
                            try {
                                if (ptr.getLength() > 0) {
                                    IndexMetaDataCacheClient client = new IndexMetaDataCacheClient(connection, tableRef);
                                    cache = client.addIndexMetadataCache(context.getScanRanges(), ptr, txState);
                                    byte[] uuidValue = cache.getId();
                                    scan.setAttribute(PhoenixIndexCodec.INDEX_UUID, uuidValue);
                                }
                                ResultIterator iterator = aggPlan.iterator();
                                try {
                                    Tuple row = iterator.next();
                                    final long mutationCount = (Long)aggProjector.getColumnProjector(0).getValue(row, PLong.INSTANCE, ptr);
                                    return new MutationState(maxSize, connection) {
                                        @Override
                                        public long getUpdateCount() {
                                            return mutationCount;
                                        }
                                    };
                                } finally {
                                    iterator.close();
                                }
                            } finally {
                                if (cache != null) {
                                    cache.close();
                                }
                            }
                        }

                        @Override
                        public ExplainPlan getExplainPlan() throws SQLException {
                            List<String> queryPlanSteps =  aggPlan.getExplainPlan().getPlanSteps();
                            List<String> planSteps = Lists.newArrayListWithExpectedSize(queryPlanSteps.size()+1);
                            planSteps.add("UPSERT ROWS");
                            planSteps.addAll(queryPlanSteps);
                            return new ExplainPlan(planSteps);
                        }
                    };
                }
            }
            ////////////////////////////////////////////////////////////////////
            // UPSERT SELECT run client-side
            /////////////////////////////////////////////////////////////////////
            return new MutationPlan() {
                @Override
                public ParameterMetaData getParameterMetaData() {
                    return queryPlan.getContext().getBindManager().getParameterMetaData();
                }

                @Override
                public StatementContext getContext() {
                    return queryPlan.getContext();
                }

                @Override
                public TableRef getTargetRef() {
                    return tableRef;
                }

                @Override
                public Set<TableRef> getSourceRefs() {
                    return originalQueryPlan.getSourceRefs();
                }

        		@Override
        		public Operation getOperation() {
        			return operation;
        		}

                @Override
                public MutationState execute() throws SQLException {
                    ResultIterator iterator = queryPlan.iterator();
                    if (parallelIteratorFactory == null) {
                        return upsertSelect(new StatementContext(statement), tableRef, projector, iterator, columnIndexes, pkSlotIndexes, useServerTimestamp);
                    }
                    try {
                        parallelIteratorFactory.setRowProjector(projector);
                        parallelIteratorFactory.setColumnIndexes(columnIndexes);
                        parallelIteratorFactory.setPkSlotIndexes(pkSlotIndexes);
                        Tuple tuple;
                        long totalRowCount = 0;
                        StatementContext context = queryPlan.getContext();
                        while ((tuple=iterator.next()) != null) {// Runs query
                            Cell kv = tuple.getValue(0);
                            totalRowCount += PLong.INSTANCE.getCodec().decodeLong(kv.getValueArray(), kv.getValueOffset(), SortOrder.getDefault());
                        }
                        // Return total number of rows that have been updated. In the case of auto commit being off
                        // the mutations will all be in the mutation state of the current connection.
                        MutationState mutationState = new MutationState(maxSize, statement.getConnection(), totalRowCount);
                        /*
                         *  All the metrics collected for measuring the reads done by the parallel mutating iterators
                         *  is included in the ReadMetricHolder of the statement context. Include these metrics in the
                         *  returned mutation state so they can be published on commit.
                         */
                        mutationState.setReadMetricQueue(context.getReadMetricsQueue());
                        return mutationState;
                    } finally {
                        iterator.close();
                    }
                }

                @Override
                public ExplainPlan getExplainPlan() throws SQLException {
                    List<String> queryPlanSteps =  queryPlan.getExplainPlan().getPlanSteps();
                    List<String> planSteps = Lists.newArrayListWithExpectedSize(queryPlanSteps.size()+1);
                    planSteps.add("UPSERT SELECT");
                    planSteps.addAll(queryPlanSteps);
                    return new ExplainPlan(planSteps);
                }

            };
        }

        ////////////////////////////////////////////////////////////////////
        // UPSERT VALUES
        /////////////////////////////////////////////////////////////////////
        final byte[][] values = new byte[nValuesToSet][];
        int nodeIndex = 0;
        if (isTenantSpecific) {
            PName tenantId = connection.getTenantId();
            values[nodeIndex++] = ScanUtil.getTenantIdBytes(table.getRowKeySchema(), table.getBucketNum() != null, tenantId);
        }
        if (isSharedViewIndex) {
            values[nodeIndex++] = MetaDataUtil.getViewIndexIdDataType().toBytes(table.getViewIndexId());
        }

        final int nodeIndexOffset = nodeIndex;
        // Allocate array based on size of all columns in table,
        // since some values may not be set (if they're nullable).
        final StatementContext context = new StatementContext(statement, resolver, new Scan(), new SequenceManager(statement));
        UpsertValuesCompiler expressionBuilder = new UpsertValuesCompiler(context);
        final List<Expression> constantExpressions = Lists.newArrayListWithExpectedSize(valueNodes.size());
        // First build all the expressions, as with sequences we want to collect them all first
        // and initialize them in one batch
        for (ParseNode valueNode : valueNodes) {
            if (!valueNode.isStateless()) {
                throw new SQLExceptionInfo.Builder(SQLExceptionCode.VALUE_IN_UPSERT_NOT_CONSTANT).build().buildException();
            }
            PColumn column = allColumns.get(columnIndexes[nodeIndex]);
            expressionBuilder.setColumn(column);
            Expression expression = valueNode.accept(expressionBuilder);
            if (expression.getDataType() != null && !expression.getDataType().isCastableTo(column.getDataType())) {
                throw TypeMismatchException.newException(
                        expression.getDataType(), column.getDataType(), "expression: "
                                + expression.toString() + " in column " + column);
            }
            constantExpressions.add(expression);
            nodeIndex++;
        }
        return new MutationPlan() {
            @Override
            public ParameterMetaData getParameterMetaData() {
                return context.getBindManager().getParameterMetaData();
            }

            @Override
            public StatementContext getContext() {
                return context;
            }

            @Override
            public TableRef getTargetRef() {
                return tableRef;
            }

            @Override
            public Set<TableRef> getSourceRefs() {
                return Collections.emptySet();
            }

    		@Override
    		public Operation getOperation() {
    			return operation;
    		}

            @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);
            }

            @Override
            public ExplainPlan getExplainPlan() throws SQLException {
                List<String> planSteps = Lists.newArrayListWithExpectedSize(2);
                if (context.getSequenceManager().getSequenceCount() > 0) {
                    planSteps.add("CLIENT RESERVE " + context.getSequenceManager().getSequenceCount() + " SEQUENCES");
                }
                planSteps.add("PUT SINGLE ROW");
                return new ExplainPlan(planSteps);
            }

        };
    }

    private static boolean isRowTimestampSet(int[] pkSlotIndexes, PTable table) {
        checkArgument(table.getRowTimestampColPos() != -1, "Call this method only for tables with row timestamp column");
        int rowTimestampColPKSlot = table.getRowTimestampColPos();
        for (int pkSlot : pkSlotIndexes) {
            if (pkSlot == rowTimestampColPKSlot) {
                return true;
            }
        }
        return false;
    }

    private TableRef adjustTimestampToMinOfSameTable(TableRef upsertRef, List<TableRef> selectRefs) {
        long minTimestamp = Long.MAX_VALUE;
        for (TableRef selectRef : selectRefs) {
            if (selectRef.equals(upsertRef)) {
                minTimestamp = Math.min(minTimestamp, selectRef.getTimeStamp());
            }
        }
        if (minTimestamp != Long.MAX_VALUE) {
            // If we found the same table is selected from that is being upserted to,
            // reset the timestamp of the upsert (which controls the Put timestamp)
            // to the lowest timestamp we found to ensure that the data being selected
            // will not see the data being upserted. This prevents infinite loops
            // like the one in PHOENIX-1257.
            return new TableRef(upsertRef, minTimestamp);
        }
        return upsertRef;
    }

    private static final class UpsertValuesCompiler extends ExpressionCompiler {
        private PColumn column;

        private UpsertValuesCompiler(StatementContext context) {
            super(context);
        }

        public void setColumn(PColumn column) {
            this.column = column;
        }

        @Override
        public Expression visit(BindParseNode node) throws SQLException {
            if (isTopLevel()) {
                context.getBindManager().addParamMetaData(node, column);
                Object value = context.getBindManager().getBindValue(node);
                return LiteralExpression.newConstant(value, column.getDataType(), column.getSortOrder(), Determinism.ALWAYS);
            }
            return super.visit(node);
        }

        @Override
        public Expression visit(LiteralParseNode node) throws SQLException {
            if (isTopLevel()) {
                return LiteralExpression.newConstant(node.getValue(), column.getDataType(), column.getSortOrder(), Determinism.ALWAYS);
            }
            return super.visit(node);
        }

        @Override
        public Expression visit(SequenceValueParseNode node) throws SQLException {
            return context.getSequenceManager().newSequenceReference(node);
        }
    }

    private static SelectStatement prependTenantAndViewConstants(PTable table, SelectStatement select, String tenantId, Set<PColumn> addViewColumns, boolean useServerTimestamp) {
        if ((!table.isMultiTenant() || tenantId == null) && table.getViewIndexId() == null && addViewColumns.isEmpty() && !useServerTimestamp) {
            return select;
        }
        List<AliasedNode> selectNodes = newArrayListWithCapacity(select.getSelect().size() + 1 + addViewColumns.size());
        if (table.isMultiTenant() && tenantId != null) {
            selectNodes.add(new AliasedNode(null, new LiteralParseNode(tenantId)));
        }
        if (table.getViewIndexId() != null) {
            selectNodes.add(new AliasedNode(null, new LiteralParseNode(table.getViewIndexId())));
        }
        selectNodes.addAll(select.getSelect());
        for (PColumn column : addViewColumns) {
            byte[] byteValue = column.getViewConstant();
            Object value = column.getDataType().toObject(byteValue, 0, byteValue.length-1);
            selectNodes.add(new AliasedNode(null, new LiteralParseNode(value)));
        }
        if (useServerTimestamp) {
            PColumn rowTimestampCol = table.getPKColumns().get(table.getRowTimestampColPos());
            selectNodes.add(new AliasedNode(null, getNodeForRowTimestampColumn(rowTimestampCol)));
        }
        return SelectStatement.create(select, selectNodes);
    }

    /**
     * Check that none of no columns in our updatable VIEW are changing values.
     * @param tableRef
     * @param overlapViewColumns
     * @param targetColumns
     * @param projector
     * @throws SQLException
     */
    private static void throwIfNotUpdatable(TableRef tableRef, Set<PColumn> overlapViewColumns,
            List<PColumn> targetColumns, RowProjector projector, boolean sameTable) throws SQLException {
        PTable table = tableRef.getTable();
        if (table.getViewType() == ViewType.UPDATABLE && !overlapViewColumns.isEmpty()) {
            ImmutableBytesWritable ptr = new ImmutableBytesWritable();
            for (int i = 0; i < targetColumns.size(); i++) {
                PColumn targetColumn = targetColumns.get(i);
                if (overlapViewColumns.contains(targetColumn)) {
                    Expression source = projector.getColumnProjector(i).getExpression();
                    if (source.isStateless()) {
                        source.evaluate(null, ptr);
                        if (Bytes.compareTo(ptr.get(), ptr.getOffset(), ptr.getLength(), targetColumn.getViewConstant(), 0, targetColumn.getViewConstant().length-1) == 0) {
                            continue;
                        }
                    }
                    throw new SQLExceptionInfo.Builder(
                            SQLExceptionCode.CANNOT_UPDATE_VIEW_COLUMN)
                            .setColumnName(targetColumn.getName().getString())
                            .build().buildException();
                }
            }
        }
    }
}


text:
[Node.js code sample] (sample_node.js_mac.js) that runs on Mac OS X. The sample connects to Azure SQL Database by using the Tedious driver.

## Required software items

Install **node**, unless it is already installed on your machine.

To install node.js on OSX 10.10 Yosemite  you can download a pre-compiled binary package which makes a nice and easy installation. [Head over to nodejs.org](http://nodejs.org/) and click the install button to download the latest package.

Install the package from the .dmg by following along the install wizard which will install both **node** and **npm**, npm is Node Package Manager which facilitates installs of additional packages for node.js.

After your machine is configured with **node** and **npm**, navigate to a directory where you plan to create your Node.js project, and enter the following commands.

npm install

### Create an AdventureWorks database

The code sample in this topic expects an **AdventureWorks** test database. If you do not already have one, see [Get started with SQL Database](http://azure.microsoft.com/documentation/articles/sql-database-get-started/). It is important that you follow the guide to create an **AdventureWorks database template**. The examples shown below work only with the **AdventureWorks schema**.

redpajama_set_name: RedPajamaGithub


text:
package es.logongas.ix3.web.security.jwt.impl;

import es.logongas.ix3.web.security.jwt.Jws;
import java.math.BigInteger;
import java.security.Key;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Random;
import org.jose4j.jws.AlgorithmIdentifiers;
import org.jose4j.jws.JsonWebSignature;
import org.jose4j.keys.AesKey;
import org.jose4j.lang.JoseException;

/**
 * Clase de utilidad para gestionar los tokens Jws firmados
 *
 * @author logongas
 */
public class JwsImplJose4j implements Jws {

    private static final String PAYLOAD_PARTS_SEPARATOR=";";
    private static final String CREATE_DATE_FORMAT="yyyy-MM-dd'T'HH:mm:ss";

    @Override
    public String getJwsCompactSerialization(String payload, byte[] secretKey) {
        try {
            Key key = new AesKey(secretKey);
            String structuredPayload=getStructuredPayLoadFromPayload(payload);

            JsonWebSignature jws = new JsonWebSignature();
            jws.setPayload(structuredPayload);
            jws.setAlgorithmHeaderValue(AlgorithmIdentifiers.HMAC_SHA256);
            jws.setKey(key);
            String jwsCompactSerialization = jws.getCompactSerialization();

            return jwsCompactSerialization;
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    @Override
    public boolean verifyJwsCompactSerialization(String jwsCompactSerialization, byte[] secretKey,int maxMinutesValid) {
        try {
            Key key = new AesKey(secretKey);
            JsonWebSignature jws = new JsonWebSignature();
            jws.setCompactSerialization(jwsCompactSerialization);
            jws.setKey(key);

            boolean signatureVerified = jws.verifySignature();

            if (signatureVerified==false) {
                return false;
            }

            Date creationDate=getDateFromStructuredPayload(jws.getUnverifiedPayload());
            Date maxDate=dateAddMinutes(creationDate,maxMinutesValid);
            Date now=new Date();

            if (now.after(maxDate)) {
                //Ha caducado el Token
                return false;
            }

            return true;

        } catch (JoseException ex) {
            throw new RuntimeException(ex);
        }
    }

    @Override
    public String getUnverifiedPayloadFromJwsCompactSerialization(String jwsCompactSerialization) {
        try {
            JsonWebSignature jws = new JsonWebSignature();
            jws.setCompactSerialization(jwsCompactSerialization);

            String structuredPayload = jws.getUnverifiedPayload();

            return getPayloadFromStructuredPayload(structuredPayload);

        } catch (JoseException ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * Le añade al payload la fecha de creación y un número aleatorio
     * @param payload
     * @return
     */
    String getStructuredPayLoadFromPayload(String payload) {
        if ((payload==null) || (payload.isEmpty())) {
            throw new RuntimeException("El payload no puede estar vacio");
        }

        if (payload.contains(PAYLOAD_PARTS_SEPARATOR)) {
            throw new RuntimeException("El payload no puede contener el caracter '" + PAYLOAD_PARTS_SEPARATOR + "'");
        }

        Date date=new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(CREATE_DATE_FORMAT);

        String structuredPayLoad=payload + PAYLOAD_PARTS_SEPARATOR + simpleDateFormat.format(date) + PAYLOAD_PARTS_SEPARATOR + getLongRandomNumber(5);

        return structuredPayLoad;

    }

    private String getPayloadFromStructuredPayload(String structuredPayload) {
        String payload;

        if ((structuredPayload==null) || (structuredPayload.isEmpty())) {
            throw new RuntimeException("El structuredPayload no puede estar vacio");
        }

        if (structuredPayload.contains(PAYLOAD_PARTS_SEPARATOR)==true) {
            payload=structuredPayload.split(PAYLOAD_PARTS_SEPARATOR)[0];
        } else {
            //Es un viejo payload que no tenía la fecha de creación, asi que "todo" es el payload
            payload=structuredPayload;
        }

        return payload;
    }
    private Date getDateFromStructuredPayload(String structuredPayload) {
        try {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(CREATE_DATE_FORMAT);
            Date date;

            if ((structuredPayload==null) || (structuredPayload.isEmpty())) {
                throw new RuntimeException("El payload no puede estar vacio");
            }

            if (structuredPayload.contains(PAYLOAD_PARTS_SEPARATOR)==true) {
                date=simpleDateFormat.parse(structuredPayload.split(PAYLOAD_PARTS_SEPARATOR)[1]);
            } else {
                //Es un viejo payload que no tenía la fecha de creación
                //Así que ponermos una fecha muy vieja para que seguro que esté caducado
                GregorianCalendar gregorianCalendar=new GregorianCalendar(1793, 1, 1, 1, 1, 1);
                date=gregorianCalendar.getTime();
            }

            return date;
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    private String getLongRandomNumber(int size) {
        Random random = new Random();
        byte[] b = new byte[size];
        random.nextBytes(b);
        BigInteger bigInteger = (new BigInteger(b)).abs();

        return bigInteger.toString();
    }

    private Date dateAddMinutes(Date date ,int minutes) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MINUTE, minutes);
        Date result = calendar.getTime();

        return result;
    }

}


text:
<?php
session_start();

include('db.php');
if($_POST['id'])
{
$id=$_POST['id'];
$user = $_SESSION['user'];

$res = mysqli_query($conn, "INSERT INTO `likes`(`username`, `RID`) VALUES ('" . $user ."', '" . $id . "')");
if($res){
	echo "You've like it.  Total likes: ";
	$total = mysqli_query($conn, "SELECT COUNT(*) FROM likes l WHERE l.rid = '" . $id . "'") or die (mysqli_error($conn));
	$totalsrow = mysqli_fetch_array($total);
	echo $totalsrow[0];
} else{
	echo "Error: You've already liked this item";
}

}
?>


text:
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Windows;
using System.Windows.Markup;
using System.Globalization;
using Microsoft.Shell;
using Loksim3D.WetterEdit.Settings;
using System.IO;
using System.Diagnostics;
using System.Runtime.InteropServices;
using Microsoft.WindowsAPICodePack.Dialogs;
using Loksim3D.WetterEdit.Win32Wrapper;
using Loksim3D.WetterEdit.Resources;
using System.Windows.Shell;
using System.Reflection;

[assembly: CLSCompliant(true)]
namespace Loksim3D.WetterEdit
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application, ISingleInstanceApp
    {
        private const string Unique = "LoksimWetterEditor-7F9571D8-3151-4801-AAFF-40EEAD0EDA95";

        private MainWindow mainWnd;

        private static string EscapeCommandLineArguments(string[] args)
        {
            string arguments = "";
            foreach (string arg in args)
            {
                arguments += " \"" +
                    arg.Replace("\\", "\\\\").Replace("\"", "\\\"") +
                    "\"";
            }
            return arguments;
        }

        [STAThread]
        public static void Main()
        {
            try
            {
                CultureInfo cInf = new CultureInfo(RegistrySettings.Default.UiCulture);
                Loksim3D.WetterEdit.Resources.Strings.Culture = cInf;
            }
            catch (ArgumentException ex)
            {
                MessageBox.Show("Invalid Language Settings " + RegistrySettings.Default.UiCulture + "\n" + ex.Message);
            }

            if (Environment.OSVersion.Version.Major >= 6 && RegistrySettings.Default.DefaultAdminStartMode != RegistrySettings.AdminStartMode.DoNotStartAsAdmin)
            {
                // Unter Vista oder höher prüfen ob wir in das Datenverzeichnis lt. paths.ini schreiben dürfen
                // Wenn nicht schauen wir ob wir als Admin ausgeführt werden
                // Wenn nicht als Admin ausgeführt => User fragen ob als Admin ausführen bzw in Optionen nachschauen was user möchte

                string datadir = L3dFilePath.LoksimDirectory.AbsolutePath;

                try
                {
                    string file = TempFileUtility.GetTempFileName("l3d", 0, datadir/*Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location)*/);
                    File.Delete(file);
                }
                catch (Win32Exception ex)
                {
                    if (ex.ErrorCode == TempFileUtility.ERROR_ACCESS_DENIED)
                    {
                        IntPtr tkHandle;
                        IntPtr procHandle = Process.GetCurrentProcess().Handle;
                        Win32Utility.OpenProcessToken(procHandle,
                            (uint)System.Security.Principal.TokenAccessLevels.Read, out tkHandle);

                        uint TokenInfLength = 0;
                        bool Result;

                        // first call gets lenght of TokenInformation
                        Result = Win32Utility.GetTokenInformation(tkHandle, Win32Utility.TOKEN_INFORMATION_CLASS.TokenElevation, IntPtr.Zero, TokenInfLength, out TokenInfLength);
                        IntPtr TokenInformation = Marshal.AllocHGlobal((int)TokenInfLength);

                        Result = Win32Utility.GetTokenInformation(tkHandle, Win32Utility.TOKEN_INFORMATION_CLASS.TokenElevation, TokenInformation, TokenInfLength, out TokenInfLength);
                        if (Result)
                        {
                            Win32Utility.TOKEN_ELEVATION TokenElevation = (Win32Utility.TOKEN_ELEVATION)Marshal.PtrToStructure(TokenInformation, typeof(Win32Utility.TOKEN_ELEVATION));
                            TaskDialog dlg = new TaskDialog
                            {
                                Caption = Strings.UacDlgCaption,
                                InstructionText = Strings.UacDlgInstructionText,
                                Text = Strings.UacDlgText,
                                FooterCheckBoxChecked = false,
                                FooterCheckBoxText = Strings.UacDlgCheckBoxText,
                                Cancelable = false,
                            };
                            TaskDialogButton btn = new TaskDialogButton { Text = Strings.UacDlgBtnAdmin, UseElevationIcon = true, Default = true };
                            btn.Click += (sender, e) => dlg.Close(TaskDialogResult.Yes);
                            dlg.Controls.Add(btn);
                            btn = new TaskDialogButton { Text = Strings.UacDlgBtnNoAdmin };
                            btn.Click += (sender, e) => dlg.Close(TaskDialogResult.No);
                            dlg.Controls.Add(btn);
                            if (RegistrySettings.Default.DefaultAdminStartMode == RegistrySettings.AdminStartMode.StartAsAdmin || dlg.Show() == TaskDialogResult.Yes)
                            {
                                if (dlg.FooterCheckBoxChecked.GetValueOrDefault(false))
                                {
                                    RegistrySettings.Default.DefaultAdminStartMode = RegistrySettings.AdminStartMode.StartAsAdmin;
                                }

                                ProcessStartInfo info = new ProcessStartInfo();
                                info.FileName = System.Reflection.Assembly.GetCallingAssembly().Location;
                                info.UseShellExecute = true;
                                info.Verb = "runas"; // Provides Run as Administrator
                                info.Arguments = EscapeCommandLineArguments(Environment.GetCommandLineArgs());
                                Process.Start(info);
                                Marshal.FreeHGlobal(TokenInformation);
                                return;
                            }
                            else if (RegistrySettings.Default.DefaultAdminStartMode == RegistrySettings.AdminStartMode.Ask && dlg.FooterCheckBoxChecked.GetValueOrDefault(false))
                            {
                                RegistrySettings.Default.DefaultAdminStartMode = RegistrySettings.AdminStartMode.DoNotStartAsAdmin;
                            }
                        }
                        Marshal.FreeHGlobal(TokenInformation);
                    }
                }
            }

            // Der Editor soll pro Installation nur 1x gestartet werden können.
            // Hat der User mehrere Editoren in unterschiedlichen Verzeichnissen oder mit unterschiedlichen Namen, kann er diese jeweils 1x starten
            // Deshalb ist in der Unique-ID auch noch die Assembly Location kodiert
            if (SingleInstance<App>.InitializeAsFirstInstance(Unique + "-" + System.Reflection.Assembly.GetCallingAssembly().Location.GetHashCode()))
            {
                var application = new App();

                application.InitializeComponent();
                application.Run();

                // Allow single instance code to perform cleanup operations
                SingleInstance<App>.Cleanup();
            }
        }

        static void Current_DispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
        {
            Application.Current.DispatcherUnhandledException -= Current_DispatcherUnhandledException;
            try
            {
                File.WriteAllText(Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "error_wetter_edit.txt"), e.Exception.ToString());
            }
            catch (Exception)
            {
            }
            //MessageBox.Show(e.Exception.Message + "\n" + e.Exception.StackTrace, "Unhandled Error", MessageBoxButton.OK, MessageBoxImage.Error);

        }

        #region ISingleInstanceApp Members

        public bool SignalExternalCommandLineArgs(IList<string> args)
        {
            OpenNewWindow(args.Skip(1));
            return true;
        }

        #endregion

        private void OpenNewWindow(IEnumerable<string> args)
        {
            MainWindow newWnd = null;
            string fileToOpen = null;
            if (args != null && args.Count() > 0 && !string.IsNullOrWhiteSpace(args.First()))
            {
                fileToOpen = args.First();
                if (File.Exists(fileToOpen))
                {
                    JumpList.AddToRecentCategory(fileToOpen);
                }
            }
            if (mainWnd == null && fileToOpen != null)
            {
                newWnd = new MainWindow(fileToOpen);
                newWnd.Show();
            }
            else if (mainWnd == null)
            {
                newWnd = new MainWindow();
                newWnd.Show();
            }
            else if (fileToOpen != null && fileToOpen.Trim().StartsWith("-"))
            {
                mainWnd.CreateNewFile(fileToOpen);
            }
            else if (fileToOpen != null)
            {
                mainWnd.OpenFile(new L3dFilePath(fileToOpen));
            }
            else
            {
                if (mainWnd.WindowState == System.Windows.WindowState.Minimized)
                {
                    mainWnd.WindowState = System.Windows.WindowState.Normal;
                }
                mainWnd.Activate();
                //mainWnd.BringIntoView();
            }
            if (mainWnd == null)
            {
                mainWnd = newWnd;
            }
        }

        private void Application_Startup(object sender, StartupEventArgs e)
        {
            Application.Current.DispatcherUnhandledException += new System.Windows.Threading.DispatcherUnhandledExceptionEventHandler(Current_DispatcherUnhandledException);

            // Ensure the current culture passed into bindings
            // is the OS culture. By default, WPF uses en-US
            // as the culture, regardless of the system settings.
            FrameworkElement.LanguageProperty.OverrideMetadata(
                typeof(FrameworkElement),
                new FrameworkPropertyMetadata(
                    XmlLanguage.GetLanguage(CultureInfo.CurrentCulture.IetfLanguageTag)));

#if DEBUG
            //L3dFilePath.LoksimDirectory = new L3dFilePath(@"D:\Loksim3D");
#endif
            //Args = e.Args;

            OpenNewWindow(e.Args);
        }
    }
}


text:
// Copyright (c) 2003-2014, Jodd Team (jodd.org). All Rights Reserved.

package jodd.mutable;

/**
 * A mutable boolean wrapper.
 */
public final class MutableBoolean implements Comparable<MutableBoolean>, Cloneable {

	public MutableBoolean() {
	}

	public MutableBoolean(boolean value) {
		this.value = value;
	}

	public MutableBoolean(String value) {
		this.value = Boolean.valueOf(value).booleanValue();
	}

	public MutableBoolean(Boolean value) {
		this.value = value.booleanValue();
	}

	public MutableBoolean(Number number) {
		this.value = number.intValue() != 0;
	}

	// ---------------------------------------------------------------- value

	/**
	 * The mutable value.
	 */
	public boolean value;

	/**
	 * Returns mutable value.
	 */
	public boolean getValue() {
		return value;
	}

	/**
	 * Sets mutable value.
	 */
	public void setValue(boolean value) {
		this.value = value;
	}

	public void setValue(Boolean value) {
		this.value = value.booleanValue();
	}

	// ---------------------------------------------------------------- object

	/**
	 * Stringify the value.
	 */
	@Override
	public String toString() {
		return Boolean.toString(value);
	}

	/**
	 * Returns a hashcode for this value.
	 */
	@Override
	public int hashCode() {
		return value ? 1231 : 1237;
	}

	/**
	 * Compares this object to the specified object.
	 *
	 * @param obj the object to compare with.
	 * @return true if the objects are the same;
	 *         false otherwise.
	 */
	@Override
	public boolean equals(Object obj) {
		if (obj != null) {
			if (obj instanceof Boolean) {
				return value == ((Boolean) obj).booleanValue();
			}
			if (obj instanceof MutableBoolean) {
				return value == ((MutableBoolean) obj).value;
			}
		}
		return false;
	}

	// ---------------------------------------------------------------- compare

	/**
	 * Compares value of two same instances.
	 */
	public int compareTo(MutableBoolean o) {
		return (value == o.value) ? 0 : (value == false ? -1 : 1);
	}

	// ---------------------------------------------------------------- clone

	/**
	 * Clones object.
	 */
	@Override
	public MutableBoolean clone() {
		return new MutableBoolean(value);
	}
}


text:
#ifndef GUI_INTERNAL__H
#define GUI_INTERNAL__H

#include <cubez/input.h>

void gui_initialize();
void gui_shutdown();

void gui_handle_input(qbInputEvent input);
qbRenderPass gui_create_renderpass(uint32_t width, uint32_t height);
void gui_window_updateuniforms();

#endif  // GUI_INTERNAL__H


text:
package com.tle.common;

import com.google.common.collect.Maps;
import com.tle.beans.entity.BaseEntity;
import java.util.Map;

public class EntityPack<T extends BaseEntity> extends ImportExportPack<T> {
  private static final long serialVersionUID = 1L;

  private String stagingID;
  private final Map<String, Object> attributes = Maps.newHashMap();

  public EntityPack() {
    super();
  }

  public EntityPack(T entity, String stagingID) {
    setEntity(entity);
    this.stagingID = stagingID;
  }

  public String getStagingID() {
    return stagingID;
  }

  public void setStagingID(String stagingID) {
    this.stagingID = stagingID;
  }

  public void setAttribute(String name, Object value) {
    attributes.put(name, value);
  }

  @SuppressWarnings("unchecked")
  public <O> O getAttribute(String name) {
    return (O) attributes.get(name);
  }
}


text:
const common::logger& video::logger = common::logger::get (
    "shimmer::sdl2::video" );

video::video( class shim* shim )
    : _shim ( shim ),
      _source_surface ( nullptr ),
      _renderer ( nullptr )
{}

video::~video() {
    if ( _source_surface == nullptr ) sym::SDL_FreeSurface ( _source_surface );

    if ( _sdl_renderer ) sym::SDL_DestroyRenderer ( _sdl_renderer );

    if ( _sdl_render_target ) sym::SDL_DestroyTexture ( _sdl_render_target );
}

SDL_Surface* video::source_surface() {
    if ( _source_surface == nullptr ) {
        _source_surface = _software_surface ( _source_resolution );
    }

    return _source_surface;
}

void video::setup ( int    w,
                    int    h,
                    Uint32 flags ) {
    _source_resolution = { static_cast<unsigned int>( w ),
                           static_cast<unsigned int>( h ) };

    if ( _renderer == nullptr ) {
        _target_resolution = _source_resolution;
        _flags             = flags;

        if ( _flags & SDL_WINDOW_OPENGL ) {
            logger.info ( "Using OpenGL mode..." );
            _mode = mode::opengl;
        }
        else {
            logger.info ( "Using software mode..." );
            _mode = mode::software;
        }

        _shim->source_resolution ( _source_resolution );
        _shim->target_resolution ( _target_resolution );
    }
}

SDL_Renderer* video::renderer ( SDL_Window* window, int index, Uint32 flags )
{
    if ( _use_software_sdl_renderer ) {
        logger.info ( "Creating software SDL Renderer." );

        _sdl_renderer = sym::SDL_CreateSoftwareRenderer ( source_surface() );
        _mode         = video::mode::software;
    }
    else if ( !_sdl_renderer ) {
        logger.info ( "Creating OpenGL SDL Renderer." );

        _sdl_renderer = sym::SDL_CreateRenderer ( window, index, flags );

        _mode = video::mode::renderer;
        _setup_renderer();
        _setup_sdl_render_target();
    }

    return _sdl_renderer;
}

void video::update()
{
    if ( !_renderer ) {
        _setup_renderer();
    }

    if ( _renderer ) {
        if ( _mode == mode::software ) {
            _renderer->copy_source (
                static_cast<uint8_t*>( _source_surface->pixels ),
                _source_resolution,
                4 );
            _renderer->render();
        }
        else if ( _mode == mode::opengl ) {
            _renderer->reset_fbo();
            _renderer->render();
            _renderer->capture_fbo();
        }
        else {
            _renderer->render();
        }
    }
}

void video::update ( SDL_Renderer* renderer )
{
    if ( renderer == _sdl_renderer ) {
        update();
        shim.window.update();
    }
    else {
        sym::SDL_RenderPresent ( renderer );
    }
}

common::dims_2u video::source_resolution() {
    return _source_resolution;
}

void video::source_resolution ( const common::dims_2u& dims )
{
    if ( _source_resolution != dims ) {
        logger.debug ( "Setting source resolution: {}", dims.to_json() );
        _source_resolution = dims;
        _source_surface    = _software_surface ( _source_resolution );

        if ( _renderer ) {
            _renderer->source_resolution ( _source_resolution );
        }

        if ( _mode == mode::renderer ) {
            _setup_sdl_render_target();
        }
    }
}

void video::target_resolution ( const common::dims_2u& dims )
{
    if ( _target_resolution != dims ) {
        logger.debug ( "Setting target resolution: {}", dims.to_json() );

        _target_resolution = dims;

        if ( _renderer ) {
            _renderer->target_resolution ( _target_resolution );
        }
    }
}

void video::size ( SDL_Renderer* renderer, int* w, int* h )
{
    if ( renderer == _sdl_renderer ) {
        auto size = _source_resolution;
        *w = static_cast<int>( size.width );
        *h = static_cast<int>( size.height );
    }
    else {
        sym::SDL_RenderGetLogicalSize ( renderer, w, h );
    }
}

void video::destroy ( SDL_Renderer* renderer ) {
    if ( renderer != _sdl_renderer ) {
        sym::SDL_DestroyRenderer ( renderer );
    }
}

void video::_setup_opengl_context()
{
    _gl_context = sym::SDL_GL_GetCurrentContext();

    if ( _mode == mode::software ) {
        logger.info ( "Assuming application is using software mode." );

        _gl_context =
            sym::SDL_GL_CreateContext ( _shim->window.source_window() );

        if ( _gl_context == nullptr ) {
            logger.error ( "Unable to create OpenGL context: {}",
                           SDL_GetError() );
        }
    }
    else if ( ( ( _mode == mode::opengl ) || ( _mode == mode::renderer ) )
              && ( _gl_context == nullptr ) ) {
        logger.warn ( "Failed to get current OpenGL context: {}",
                      SDL_GetError() );
        logger.info ( "Assuming application is using software mode." );

        _gl_context = sym::SDL_GL_CreateContext (
            _shim->window.source_window() );

        if ( _gl_context == nullptr ) {
            logger.error ( "Unable to create OpenGL context: {}",
                           SDL_GetError() );
        }

        _mode = mode::software;
    }
    else {
        int major_version = 0;
        int minor_version = 0;

        sym::SDL_GL_GetAttribute ( SDL_GL_CONTEXT_MAJOR_VERSION,
                                   &major_version );
        sym::SDL_GL_GetAttribute ( SDL_GL_CONTEXT_MINOR_VERSION,
                                   &minor_version );

        logger.info ( "Application is using the following GL version: {}.{}",
                      major_version,
                      minor_version );
    }
}

void video::_setup_renderer()
{
    _setup_opengl_context();

    shimmer::renderer::init();
    _renderer = std::make_unique<shimmer::renderer>( &_shim->config );

    _renderer->source_resolution ( _source_resolution );
    _renderer->target_resolution ( _target_resolution );

    if ( _mode == mode::software ) {
        _renderer->flip_target ( true );
    }
    else if ( _mode == mode::renderer ) {
        _renderer->flip_target ( true );
    }
}

void video::_setup_sdl_render_target()
{
    if ( _sdl_render_target ) {
        sym::SDL_DestroyTexture ( _sdl_render_target );
    }

    _sdl_render_target = sym::SDL_CreateTexture ( _sdl_renderer,
                                                  SDL_PIXELFORMAT_RGB24,
                                                  SDL_TEXTUREACCESS_TARGET,
                                                  _source_resolution.width,
                                                  _source_resolution.height );

    sym::SDL_SetRenderTarget ( _sdl_renderer, _sdl_render_target );

    if ( _renderer ) {
        _renderer->activate_source_texture_unit();
        sym::SDL_GL_BindTexture ( _sdl_render_target, nullptr, nullptr );
    }
}

SDL_Surface* video::_software_surface ( const common::dims_2u& dims )
{
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    Uint32 rmask = 0xff000000;
    Uint32 gmask = 0x00ff0000;
    Uint32 bmask = 0x0000ff00;
    Uint32 amask = 0x000000ff;
#else // if SDL_BYTEORDER == SDL_BIG_ENDIAN
    Uint32 rmask = 0x000000ff;
    Uint32 gmask = 0x0000ff00;
    Uint32 bmask = 0x00ff0000;
    Uint32 amask = 0xff000000;
#endif // if SDL_BYTEORDER == SDL_BIG_ENDIAN

    return SDL_CreateRGBSurface ( _flags,
                                  static_cast<int>( dims.width ),
                                  static_cast<int>( dims.height ),
                                  32,
                                  rmask,
                                  gmask,
                                  bmask,
                                  amask );
}


text:
import ctypes

class DoubleBuffer:
    def __init__(self, size, swap_callback):
        self.read_buffer = None
        self.write_buffer = None
        self.size = 0
        self.swap_callback = swap_callback

        self.resize(size)

    def resize(self, size):
        self.read_buffer = (ctypes.c_ubyte * size)(0)
        self.write_buffer = (ctypes.c_ubyte * size)(0)
        self.size = size

    def swap(self):
        self.read_buffer, self.write_buffer = self.write_buffer, self.read_buffer
        if self.swap_callback:
            self.swap_callback()


text:
namespace libspgl1 {
namespace initialization {

	template<typename MatrixType, typename VectorType>
	VectorType compute_r(const MatrixType& A,
						 const VectorType& b,
						 const VectorType& x){

		return b - libspgl1::matrix::matvec(A, x);
	}

	template<typename MatrixType, typename VectorType>
	VectorType compute_g(const MatrixType& At,
						 const VectorType& r){
		return -libspgl1::matrix::matvec(At, r);
	}

	template<typename VectorType>
	double compute_f(const VectorType& r){
		return libspgl1::vector::dot<double>(r,r) / 2.0;
	}

	double compute_gstep(double dxNorm,
						 double stepmin,
						 double stepmax){
		double gStep=0.0;
		if (dxNorm < (1.0 / stepmax)){
		    gStep = stepmax;
		}
		else{
			gStep = std::min(stepmin, std::max(stepmin, 1.0/dxNorm));
		}
		return gStep;
	}

} // initialization
} // libspgl1


text:
import urllib, ast, json
def getLocation():
	url='http://freegeoip.net/json/'
	response=urllib.urlopen(url).read()
	response=ast.literal_eval(response)
	lon=response['longitude']
	lat=response['latitude']
	d={'lon':lon,'lat':lat}
	return d


text:
#include "newgamedialog.hpp"

#include <QDebug>

#include <interface/irival.hpp>
#include <interface/iplugin.hpp>
#include <interface/iconfigurationwidget.hpp>

#include "ui_newgamedialog.h"

#include "pluginmanagerwidget.hpp"
#include "newgamewidget.hpp"
#include "pluginloader.hpp"

namespace KDots
{
  NewGameDialog::NewGameDialog(QWidget *parent)
    : QDialog(parent)
    , m_ui(new Ui::NewGameDialog)
    , m_game(nullptr)
    , m_pluginManager(new PluginManagerWidget(this))
    , m_configWidget(nullptr)
    , m_needCreateBoard(false)
  {
    m_ui->setupUi(this);

    m_ui->Grid->addWidget(m_pluginManager, 0, 0);

    connect(m_ui->NextButton, SIGNAL(clicked(bool)), this, SLOT(pluginWidget()));
    m_ui->NextButton->setFocus();
  }

  NewGameDialog::~NewGameDialog()
  {
  }

  std::unique_ptr<IRival> NewGameDialog::rival()
  {
    return std::move(m_rival);
  }

  void NewGameDialog::accept()
  {
    if (m_game)
      m_config = m_game->getGameConfig();
    else if (m_needCreateBoard)
    {
      m_rival->requestGameConfig();
    }

    if (m_configWidget)
      m_configWidget->setParent(0);

    QDialog::accept();
  }

  const GameConfig& NewGameDialog::gameConfig() const
  {
    return m_config;
  }

  void NewGameDialog::onBoardConfigReceived(const GameConfig& config)
  {
    m_config = config;
  }

  void NewGameDialog::pluginWidget()
  {
    m_ui->NextButton->disconnect(this, SLOT(pluginWidget()));

    if (!m_pluginManager)
    {
      qWarning() << "Cannot cast to PluginManagerWidget";
      return;
    }

    const QString& pluginName = m_pluginManager->pluginName();

    IPlugin *pluginInstance = PluginLoader::instance().plugin(pluginName);
    if (!pluginInstance)
    {
      qDebug() << "Plugin instance doesn't exists";
      return;
    }

    m_rival = std::move(pluginInstance->createRival());

    connect(m_rival.get(),
            SIGNAL(needCreateBoard(const GameConfig&)),
            this,
            SLOT(onBoardConfigReceived(const GameConfig&)));

    m_pluginManager->hide();

    m_configWidget = m_rival->configureWidget();

    if (m_configWidget == nullptr)
    {
      gameWidget();
      return;
    }

    m_ui->Grid->addWidget(m_configWidget , 0, 0);

    connect(m_configWidget, SIGNAL(needCreateBoard(bool)), this, SLOT(onNeedCreateBoard(bool)));

    connect(m_ui->NextButton, SIGNAL(clicked(bool)), this, SLOT(gameWidget()));

    m_configWidget->requestState();
  }

  void NewGameDialog::onNeedCreateBoard(bool val)
  {
    m_needCreateBoard = !val;
    m_ui->NextButton->setEnabled(val);
    m_ui->OKButton->setEnabled(m_needCreateBoard);
    if (val)
      connect(m_ui->NextButton, SIGNAL(clicked(bool)), this, SLOT(gameWidget()));
    else
      m_ui->NextButton->disconnect(this, SLOT(gameWidget()));
  }

  void NewGameDialog::gameWidget()
  {
    if (m_configWidget)
      m_configWidget->hide();

    m_ui->NextButton->setEnabled(false);
    m_ui->OKButton->setEnabled(true);
    m_ui->OKButton->setFocus();
    m_game = new NewGameWidget(this);
    m_ui->Grid->addWidget(m_game, 0, 0);
  }
}

#include "moc_newgamedialog.cpp"


text: The Just Do It Tutorial for Sinatra


text:
package com.ztiany.test;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;

import com.ztiany.test.bean.BeanA;

import org.junit.Before;
import org.junit.Test;

import java.util.Arrays;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;

/**
 * Example local unit test, which will execute on the development machine (host).
 *
 * @see Testing documentation
 */
public class ExampleUnitTest {

    private BeanA mBeanA;
    private Activity mActivity;
    @Before
    public void init() {
        mBeanA = new BeanA();
        mBeanA.setName("Z");
        mBeanA.setPhone("110");

        mActivity = new Activity();
    }

    @Test
    public void test1() throws Exception {
        assertNotNull(mBeanA);
    }

    @Test
    public void test2() throws Exception {
        assertEquals("Z", mBeanA.getName());
    }

    @Test
    public void test3() throws Exception {
        System.out.println(Arrays.toString(mBeanA.getClass().getInterfaces()));
        System.out.println(BeanA.sClass);
        assertNotNull( BeanA.sClass);
    }

    @Test
    public void test4() throws Exception {
        assertNotEquals(BeanA.class, Context.class);
        mActivity.setIntent(new Intent());

    }
}