Package org.apache.phoenix.query

Examples of org.apache.phoenix.query.KeyRange


     * @return regions that intersect with the key range given by the startKey and stopKey
     */
    // exposed for tests
    public static List<HRegionLocation> filterRegions(List<HRegionLocation> allTableRegions, byte[] startKey, byte[] stopKey) {
        Iterable<HRegionLocation> regions;
        final KeyRange keyRange = KeyRange.getKeyRange(startKey, true, stopKey, false);
        if (keyRange == KeyRange.EVERYTHING_RANGE) {
            return allTableRegions;
        }
       
        regions = Iterables.filter(allTableRegions, new Predicate<HRegionLocation>() {
            @Override
            public boolean apply(HRegionLocation location) {
                KeyRange regionKeyRange = KeyRange.getKeyRange(location.getRegionInfo().getStartKey(), location.getRegionInfo().getEndKey());
                return keyRange.intersect(regionKeyRange) != KeyRange.EMPTY_RANGE;
            }
        });
        return Lists.newArrayList(regions);
    }
View Full Code Here


        } else {
            regions = Iterables.filter(allTableRegions,
                    new Predicate<HRegionLocation>() {
                    @Override
                    public boolean apply(HRegionLocation region) {
                        KeyRange minMaxRange = context.getMinMaxRange();
                        if (minMaxRange != null) {
                            KeyRange range = KeyRange.getKeyRange(region.getRegionInfo().getStartKey(), region.getRegionInfo().getEndKey());
                            if (tableRef.getTable().getBucketNum() != null) {
                                // Add salt byte, as minMaxRange won't have it
                                minMaxRange = SaltingUtil.addSaltByte(region.getRegionInfo().getStartKey(), minMaxRange);
                            }
                            range = range.intersect(minMaxRange);
                            return ranges.intersect(range.getLowerRange(), range.getUpperRange());
                        }
                        return ranges.intersect(region.getRegionInfo().getStartKey(), region.getRegionInfo().getEndKey());
                    }
            });
        }
View Full Code Here

    }

    @Override
    public void initialize(InputSplit split, TaskAttemptContext context) throws IOException, InterruptedException {
        final PhoenixInputSplit pSplit = (PhoenixInputSplit)split;
        final KeyRange keyRange = pSplit.getKeyRange();
        final Scan splitScan = queryPlan.getContext().getScan();
        final Scan scan = new Scan(splitScan);
        scan.setStartRow(keyRange.getLowerRange());
        scan.setStopRow(keyRange.getUpperRange());
         try {
            //this.resultIterator = queryPlan.iterator();
             TableResultIterator tableResultIterator = new TableResultIterator(queryPlan.getContext(), queryPlan.getTableRef(),scan);
            if(queryPlan.getContext().getSequenceManager().getSequenceCount() > 0) {
                    this.resultIterator = new SequenceResultIterator(tableResultIterator, queryPlan.getContext().getSequenceManager());
View Full Code Here

        this.keyRange = keyRange;
    }
   
    @Override
    public void readFields(DataInput input) throws IOException {
        this.keyRange = new KeyRange ();
        this.keyRange.readFields(input);
    }
View Full Code Here

        final StatementContext context = qplan.getContext();
        final TableRef tableRef = qplan.getTableRef();
        for (KeyRange split : splits) {
            final Scan splitScan = new Scan(context.getScan());
            if (tableRef.getTable().getBucketNum() != null) {
                KeyRange minMaxRange = context.getMinMaxRange();
                if (minMaxRange != null) {
                    minMaxRange = SaltingUtil.addSaltByte(split.getLowerRange(), minMaxRange);
                    split = split.intersect(minMaxRange);
                }
            }
View Full Code Here

            saltByte = SaltingUtil.getSaltingByte(key, 1, length, bucketNum);
            key[0] = saltByte;
            byte[] saltedStartKey = Arrays.copyOf(key, length + 1);
            length = ScanUtil.setKey(schema, ranges, position, Bound.UPPER, key, NUM_SALTING_BYTES, 1, ranges.size(), 1);
            byte[] saltedEndKey = Arrays.copyOf(key, length + 1);
            KeyRange range = PDataType.VARBINARY.getKeyRange(saltedStartKey, true, saltedEndKey, false);
            expandedRanges[idx++] = range;
        } while (incrementKey(ranges, position));
        // The comparator is imperfect, but sufficient for all single keys.
        Arrays.sort(expandedRanges, KeyRange.COMPARATOR);
        List<KeyRange> expandedRangesList = Arrays.asList(expandedRanges);
View Full Code Here

    public KeyPart newKeyPart(final KeyPart childPart) {
        return new KeyPart() {

            @Override
            public KeyRange getKeyRange(CompareOp op, Expression rhs) {
                KeyRange range = childPart.getKeyRange(op, rhs);
                return range.invert();
            }

            @Override
            public List<Expression> getExtractNodes() {
                return childPart.getExtractNodes();
View Full Code Here

            public KeyRange getKeyRange(CompareOp op, Expression rhs) {
                ImmutableBytesWritable ptr = new ImmutableBytesWritable();
                rhs.evaluate(null, ptr);
                byte[] key = ByteUtil.copyKeyBytesIfNecessary(ptr);
                PDataType type = getColumn().getDataType();
                KeyRange range;
                switch (op) {
                case EQUAL:
                    range = type.getKeyRange(key, true, ByteUtil.nextKey(ByteUtil.concat(key, new byte[] {StringUtil.SPACE_UTF8})), false);
                    break;
                case LESS_OR_EQUAL:
                    range = type.getKeyRange(KeyRange.UNBOUND, false, ByteUtil.nextKey(ByteUtil.concat(key, new byte[] {StringUtil.SPACE_UTF8})), false);
                    break;
                default:
                    range = childPart.getKeyRange(op, rhs);
                    break;
                }
                Integer length = getColumn().getByteSize();
                return length == null ? range : range.fill(length);
            }

            @Override
            public List<Expression> getExtractNodes() {
                return Collections.<Expression>emptyList();
View Full Code Here

            if (keyRange == null) {
                return DEGENERATE_KEY_PARTS;
            }
           
            List<KeyRange> keyRanges = slot.getPKSpan() == 1 ? Collections.<KeyRange>singletonList(keyRange) : EVERYTHING_RANGES;
            KeyRange minMaxRange = slot.getPKSpan() == 1 ? null : keyRange;
            return newKeyParts(slot, extractNode, keyRanges, minMaxRange);
        }
View Full Code Here

            final ImmutableBytesWritable ptr = context.getTempPtr();
            return new SingleKeySlot(new KeyPart() {

                @Override
                public KeyRange getKeyRange(CompareOp op, Expression rhs) {
                    KeyRange range = childPart.getKeyRange(op, rhs);
                    byte[] lower = range.getLowerRange();
                    if (!range.lowerUnbound()) {
                        ptr.set(lower);
                        // Do the reverse translation so we can optimize out the coerce expression
                        // For the actual type of the coerceBytes call, we use the node type instead of the rhs type, because
                        // for IN, the rhs type will be VARBINARY and no coerce will be done in that case (and we need it to
                        // be done).
                        node.getChild().getDataType().coerceBytes(ptr, node.getDataType(), rhs.getColumnModifier(), node.getChild().getColumnModifier());
                        lower = ByteUtil.copyKeyBytesIfNecessary(ptr);
                    }
                    byte[] upper = range.getUpperRange();
                    if (!range.upperUnbound()) {
                        ptr.set(upper);
                        // Do the reverse translation so we can optimize out the coerce expression
                        node.getChild().getDataType().coerceBytes(ptr, node.getDataType(), rhs.getColumnModifier(), node.getChild().getColumnModifier());
                        upper = ByteUtil.copyKeyBytesIfNecessary(ptr);
                    }
                    return KeyRange.getKeyRange(lower, range.isLowerInclusive(), upper, range.isUpperInclusive());
                }

                @Override
                public List<Expression> getExtractNodes() {
                    return childPart.getExtractNodes();
View Full Code Here

TOP

Related Classes of org.apache.phoenix.query.KeyRange

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.