Examples with ImmutableBytesWritable org.apache.hadoop.hbase.io.ImmutableBytesWritable used on opensource projects

Example 46 with ImmutableBytesWritable

use of org.apache.hadoop.hbase.io.ImmutableBytesWritable in project phoenix by apache.

the class ExpressionCompiler method visitLeave.

@Override
public Expression visitLeave(StringConcatParseNode node, List<Expression> children) throws SQLException {
    final StringConcatExpression expression = new StringConcatExpression(children);
    for (int i = 0; i < children.size(); i++) {
        ParseNode childNode = node.getChildren().get(i);
        if (childNode instanceof BindParseNode) {
            context.getBindManager().addParamMetaData((BindParseNode) childNode, expression);
        }
        PDataType type = children.get(i).getDataType();
        if (type == PVarbinary.INSTANCE) {
            throw new SQLExceptionInfo.Builder(SQLExceptionCode.TYPE_NOT_SUPPORTED_FOR_OPERATOR).setMessage("Concatenation does not support " + type + " in expression" + node).build().buildException();
        }
    }
    ImmutableBytesWritable ptr = context.getTempPtr();
    if (ExpressionUtil.isConstant(expression)) {
        return ExpressionUtil.getConstantExpression(expression, ptr);
    }
    return wrapGroupByExpression(expression);
}

Example 47 with ImmutableBytesWritable

use of org.apache.hadoop.hbase.io.ImmutableBytesWritable in project phoenix by apache.

the class GlobalCache method clearTenantCache.

public long clearTenantCache() {
    long unfreedBytes = getMemoryManager().getMaxMemory() - getMemoryManager().getAvailableMemory();
    if (unfreedBytes != 0 && logger.isDebugEnabled()) {
        logger.debug("Found " + (getMemoryManager().getMaxMemory() - getMemoryManager().getAvailableMemory()) + " bytes not freed from global cache");
    }
    removeAllServerCache();
    for (Map.Entry<ImmutableBytesWritable, TenantCache> entry : perTenantCacheMap.entrySet()) {
        TenantCache cache = entry.getValue();
        long unfreedTenantBytes = cache.getMemoryManager().getMaxMemory() - cache.getMemoryManager().getAvailableMemory();
        if (unfreedTenantBytes != 0 && logger.isDebugEnabled()) {
            ImmutableBytesWritable cacheId = entry.getKey();
            logger.debug("Found " + unfreedTenantBytes + " bytes not freed for tenant " + Bytes.toStringBinary(cacheId.get(), cacheId.getOffset(), cacheId.getLength()));
        }
        unfreedBytes += unfreedTenantBytes;
        cache.removeAllServerCache();
    }
    perTenantCacheMap.clear();
    return unfreedBytes;
}

Example 48 with ImmutableBytesWritable

use of org.apache.hadoop.hbase.io.ImmutableBytesWritable in project phoenix by apache.

the class ExpressionCompiler method visitLeave.

private Expression visitLeave(ArithmeticParseNode node, List<Expression> children, ArithmeticExpressionBinder binder, ArithmeticExpressionFactory factory) throws SQLException {
    boolean isNull = false;
    for (Expression child : children) {
        boolean isChildLiteral = (child instanceof LiteralExpression);
        isNull |= isChildLiteral && ((LiteralExpression) child).getValue() == null;
    }
    Expression expression = factory.create(node, children);
    for (int i = 0; i < node.getChildren().size(); i++) {
        ParseNode childNode = node.getChildren().get(i);
        if (childNode instanceof BindParseNode) {
            context.getBindManager().addParamMetaData((BindParseNode) childNode, binder == null ? expression : binder.getBindMetaData(i, children, expression));
        }
    }
    ImmutableBytesWritable ptr = context.getTempPtr();
    // If all children are literals, just evaluate now
    if (ExpressionUtil.isConstant(expression)) {
        return ExpressionUtil.getConstantExpression(expression, ptr);
    } else if (isNull) {
        return LiteralExpression.newConstant(null, expression.getDataType(), expression.getDeterminism());
    }
    // Otherwise create and return the expression
    return wrapGroupByExpression(expression);
}

Example 49 with ImmutableBytesWritable

use of org.apache.hadoop.hbase.io.ImmutableBytesWritable in project phoenix by apache.

the class ExpressionCompiler method visitLeave.

@Override
public Expression visitLeave(ArrayConstructorNode node, List<Expression> children) throws SQLException {
    boolean isChildTypeUnknown = false;
    Expression arrayElemChild = null;
    PDataType arrayElemDataType = children.get(0).getDataType();
    for (int i = 0; i < children.size(); i++) {
        Expression child = children.get(i);
        PDataType childType = child.getDataType();
        if (childType == null) {
            isChildTypeUnknown = true;
        } else if (arrayElemDataType == null) {
            arrayElemDataType = childType;
            isChildTypeUnknown = true;
            arrayElemChild = child;
        } else if (arrayElemDataType == childType || childType.isCoercibleTo(arrayElemDataType)) {
            continue;
        } else if (arrayElemDataType.isCoercibleTo(childType)) {
            arrayElemChild = child;
            arrayElemDataType = childType;
        } else {
            throw new SQLExceptionInfo.Builder(SQLExceptionCode.TYPE_MISMATCH).setMessage("Case expressions must have common type: " + arrayElemDataType + " cannot be coerced to " + childType).build().buildException();
        }
    }
    // make the return type be the most general number type of DECIMAL.
    if (isChildTypeUnknown && arrayElemDataType != null && arrayElemDataType.isCoercibleTo(PDecimal.INSTANCE)) {
        arrayElemDataType = PDecimal.INSTANCE;
    }
    final PDataType theArrayElemDataType = arrayElemDataType;
    for (int i = 0; i < node.getChildren().size(); i++) {
        ParseNode childNode = node.getChildren().get(i);
        if (childNode instanceof BindParseNode) {
            context.getBindManager().addParamMetaData((BindParseNode) childNode, arrayElemDataType == arrayElemChild.getDataType() ? arrayElemChild : new DelegateDatum(arrayElemChild) {

                @Override
                public PDataType getDataType() {
                    return theArrayElemDataType;
                }
            });
        }
    }
    ImmutableBytesWritable ptr = context.getTempPtr();
    // the value object array type should match the java known type
    Object[] elements = (Object[]) java.lang.reflect.Array.newInstance(theArrayElemDataType.getJavaClass(), children.size());
    boolean rowKeyOrderOptimizable = context.getCurrentTable().getTable().rowKeyOrderOptimizable();
    ArrayConstructorExpression arrayExpression = new ArrayConstructorExpression(children, arrayElemDataType, rowKeyOrderOptimizable);
    if (ExpressionUtil.isConstant(arrayExpression)) {
        for (int i = 0; i < children.size(); i++) {
            Expression child = children.get(i);
            child.evaluate(null, ptr);
            Object value = null;
            if (child.getDataType() == null) {
                value = arrayElemDataType.toObject(ptr, theArrayElemDataType, child.getSortOrder());
            } else {
                value = arrayElemDataType.toObject(ptr, child.getDataType(), child.getSortOrder());
            }
            elements[i] = LiteralExpression.newConstant(value, theArrayElemDataType, child.getDeterminism()).getValue();
        }
        Object value = PArrayDataType.instantiatePhoenixArray(arrayElemDataType, elements);
        return LiteralExpression.newConstant(value, PDataType.fromTypeId(arrayElemDataType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, arrayExpression.getSortOrder(), Determinism.ALWAYS, rowKeyOrderOptimizable);
    }
    return wrapGroupByExpression(arrayExpression);
}

Example 50 with ImmutableBytesWritable

use of org.apache.hadoop.hbase.io.ImmutableBytesWritable in project phoenix by apache.

the class SpillableGroupByCache method getScanner.

@Override
public RegionScanner getScanner(final RegionScanner s) {
    final Iterator<Entry<ImmutableBytesWritable, Aggregator[]>> cacheIter = new EntryIterator();
    // scanner using the spillable implementation
    return new BaseRegionScanner(s) {

        @Override
        public void close() throws IOException {
            try {
                s.close();
            } finally {
                // Always close gbCache and swallow possible Exceptions
                Closeables.closeQuietly(SpillableGroupByCache.this);
            }
        }

        @Override
        public boolean next(List<Cell> results) throws IOException {
            if (!cacheIter.hasNext()) {
                return false;
            }
            Map.Entry<ImmutableBytesWritable, Aggregator[]> ce = cacheIter.next();
            ImmutableBytesWritable key = ce.getKey();
            Aggregator[] aggs = ce.getValue();
            byte[] value = aggregators.toBytes(aggs);
            if (logger.isDebugEnabled()) {
                logger.debug("Adding new distinct group: " + Bytes.toStringBinary(key.get(), key.getOffset(), key.getLength()) + " with aggregators " + aggs.toString() + " value = " + Bytes.toStringBinary(value));
            }
            results.add(KeyValueUtil.newKeyValue(key.get(), key.getOffset(), key.getLength(), SINGLE_COLUMN_FAMILY, SINGLE_COLUMN, AGG_TIMESTAMP, value, 0, value.length));
            return cacheIter.hasNext();
        }
    };
}