public byte[] getCombinedStartKey() { if ((partitionKey == null) || (partitionKey.length == 0)) { return startKey; } return (startKey == null) ? null : ByteArrayUtils.combineArrays(partitionKey, startKey); }
public byte[] getCombinedEndKey() { if ((partitionKey == null) || (partitionKey.length == 0)) { return endKey; } return (endKey == null) ? ByteArrayUtils.combineArrays(ByteArrayUtils.getNextPrefix(partitionKey), endKey) : ByteArrayUtils.combineArrays(partitionKey, endKey); }
protected static byte[] fitExpectedByteCount(final int expectedByteCount, final byte[] bytes) { final int leftPadding = expectedByteCount - bytes.length; if (leftPadding > 0) { final byte[] zeroes = new byte[leftPadding]; Arrays.fill(zeroes, (byte) 0); return ByteArrayUtils.combineArrays(zeroes, bytes); } else if (leftPadding < 0) { final byte[] truncatedBytes = new byte[expectedByteCount]; if (bytes[0] != 0) { Arrays.fill(truncatedBytes, (byte) 255); } else { System.arraycopy(bytes, -leftPadding, truncatedBytes, 0, expectedByteCount); } return truncatedBytes; } return bytes; }
public static byte[] getNextPrefix(final byte[] rowKeyPrefix) { int offset = rowKeyPrefix.length; while (offset > 0) { if (rowKeyPrefix[offset - 1] != (byte) 0xFF) { break; } offset--; } if (offset == 0) { // TODO: is this correct? an empty byte array sorts before a single // byte {0xFF} // return new byte[0]; // it doesn't seem right, so instead, let's append several 0xFF // bytes return ByteArrayUtils.combineArrays( rowKeyPrefix, new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF}); } final byte[] newStopRow = Arrays.copyOfRange(rowKeyPrefix, 0, offset); // And increment the last one newStopRow[newStopRow.length - 1]++; return newStopRow; }
public SinglePartitionInsertionIds( final SinglePartitionInsertionIds insertionId1, final SinglePartitionInsertionIds insertionId2) { partitionKey = ByteArrayUtils.combineArrays(insertionId1.partitionKey, insertionId2.partitionKey); if ((insertionId1.sortKeys == null) || insertionId1.sortKeys.isEmpty()) { sortKeys = insertionId2.sortKeys; } else if ((insertionId2.sortKeys == null) || insertionId2.sortKeys.isEmpty()) { sortKeys = insertionId1.sortKeys; } else { // use all permutations of range keys sortKeys = new ArrayList<>(insertionId1.sortKeys.size() * insertionId2.sortKeys.size()); for (final byte[] sortKey1 : insertionId1.sortKeys) { for (final byte[] sortKey2 : insertionId2.sortKeys) { sortKeys.add(ByteArrayUtils.combineArrays(sortKey1, sortKey2)); } } } }
public List<byte[]> getCompositeInsertionIds() { if (compositeInsertionIds != null) { return compositeInsertionIds; } if ((sortKeys == null) || sortKeys.isEmpty()) { compositeInsertionIds = Arrays.asList(partitionKey); return compositeInsertionIds; } if (partitionKey == null) { compositeInsertionIds = sortKeys; return compositeInsertionIds; } final List<byte[]> internalInsertionIds = new ArrayList<>(sortKeys.size()); for (final byte[] sortKey : sortKeys) { internalInsertionIds.add(ByteArrayUtils.combineArrays(partitionKey, sortKey)); } compositeInsertionIds = internalInsertionIds; return compositeInsertionIds; }
@Override public MultiDimensionalCoordinates getCoordinatesPerDimension( final byte[] partitionKey, final byte[] sortKey) { final byte[] rowId = ByteArrayUtils.combineArrays( partitionKey == null ? null : partitionKey, sortKey == null ? null : sortKey); return new MultiDimensionalCoordinates( new byte[] {tier}, BinnedSFCUtils.getCoordinatesForId(rowId, baseDefinitions, sfc)); }
public static List<SinglePartitionQueryRanges> getQueryRanges( final List<BinnedNumericDataset> binnedQueries, final SpaceFillingCurve sfc, final int maxRanges, final byte tier) { final List<SinglePartitionQueryRanges> queryRanges = new ArrayList<>(); int maxRangeDecompositionPerBin = maxRanges; if ((maxRanges > 1) && (binnedQueries.size() > 1)) { maxRangeDecompositionPerBin = (int) Math.ceil((double) maxRanges / (double) binnedQueries.size()); } for (final BinnedNumericDataset binnedQuery : binnedQueries) { final RangeDecomposition rangeDecomp = sfc.decomposeRange(binnedQuery, true, maxRangeDecompositionPerBin); final byte[] tierAndBinId = ByteArrayUtils.combineArrays(new byte[] {tier // we're assuming tiers only go to 127 (the max byte // value) }, binnedQuery.getBinId()); queryRanges.add( new SinglePartitionQueryRanges(tierAndBinId, Arrays.asList(rangeDecomp.getRanges()))); } return queryRanges; }
@Override public byte[][] getInsertionPartitionKeys(final MultiDimensionalNumericData insertionData) { final byte[][] partitionKeys1 = subStrategy1.getInsertionPartitionKeys(insertionData); final byte[][] partitionKeys2 = subStrategy2.getInsertionPartitionKeys(insertionData); if ((partitionKeys1 == null) || (partitionKeys1.length == 0)) { return partitionKeys2; } if ((partitionKeys2 == null) || (partitionKeys2.length == 0)) { return partitionKeys1; } // return permutations final byte[][] partitionKeys = new byte[partitionKeys1.length * partitionKeys2.length][]; int i = 0; for (final byte[] partitionKey1 : partitionKeys1) { for (final byte[] partitionKey2 : partitionKeys2) { partitionKeys[i++] = ByteArrayUtils.combineArrays(partitionKey1, partitionKey2); } } return partitionKeys; }
@Override public byte[][] getQueryPartitionKeys( final MultiDimensionalNumericData queryData, final IndexMetaData... hints) { final byte[][] partitionKeys1 = subStrategy1.getQueryPartitionKeys(queryData, hints); final byte[][] partitionKeys2 = subStrategy2.getQueryPartitionKeys(queryData, hints); if ((partitionKeys1 == null) || (partitionKeys1.length == 0)) { return partitionKeys2; } if ((partitionKeys2 == null) || (partitionKeys2.length == 0)) { return partitionKeys1; } // return all permutations of partitionKeys final byte[][] partitionKeys = new byte[partitionKeys1.length * partitionKeys2.length][]; int i = 0; for (final byte[] partitionKey1 : partitionKeys1) { for (final byte[] partitionKey2 : partitionKeys2) { partitionKeys[i++] = ByteArrayUtils.combineArrays(partitionKey1, partitionKey2); } } return partitionKeys; }
@Override public MultiDimensionalCoordinates getCoordinatesPerDimension( final byte[] partitionKey, final byte[] sortKey) { // select curve based on first byte final byte first = partitionKey[0]; Coordinate[] coordinates = null; if (first == pointCurveMultiDimensionalId) { coordinates = BinnedSFCUtils.getCoordinatesForId( ByteArrayUtils.combineArrays(partitionKey, sortKey == null ? null : sortKey), baseDefinitions, pointCurve); } else if (first == xzCurveMultiDimensionalId) { coordinates = BinnedSFCUtils.getCoordinatesForId( ByteArrayUtils.combineArrays(partitionKey, sortKey == null ? null : sortKey), baseDefinitions, xzCurve); } else { return rasterStrategy.getCoordinatesPerDimension(partitionKey, sortKey); } if (coordinates == null) { return null; } return new MultiDimensionalCoordinates(new byte[] {first}, coordinates); }
@Override public MultiDimensionalCoordinates getCoordinatesPerDimension( final byte[] partitionKey, final byte[] sortKey) { if ((partitionKey != null) && (partitionKey.length > 0)) { final byte[] rowId = ByteArrayUtils.combineArrays(partitionKey, sortKey == null ? null : sortKey); final Integer orderedSfcIndex = orderedSfcIndexToTierId.inverse().get(rowId[0]); return new MultiDimensionalCoordinates( new byte[] {rowId[0]}, BinnedSFCUtils.getCoordinatesForId(rowId, baseDefinitions, orderedSfcs[orderedSfcIndex])); } else { LOGGER.warn("Row's partition key must at least contain a byte for the tier"); } return null; }
public QueryRanges(final byte[][] partitionKeys, final QueryRanges queryRanges) { if ((queryRanges == null) || (queryRanges.partitionRanges == null) || queryRanges.partitionRanges.isEmpty()) { partitionRanges = fromPartitionKeys(partitionKeys); } else if ((partitionKeys == null) || (partitionKeys.length == 0)) { partitionRanges = queryRanges.partitionRanges; } else { partitionRanges = new ArrayList<>(partitionKeys.length * queryRanges.partitionRanges.size()); for (final byte[] partitionKey : partitionKeys) { for (final SinglePartitionQueryRanges sortKeyRange : queryRanges.partitionRanges) { byte[] newPartitionKey; if (partitionKey == null) { newPartitionKey = sortKeyRange.getPartitionKey(); } else if (sortKeyRange.getPartitionKey() == null) { newPartitionKey = partitionKey; } else { newPartitionKey = ByteArrayUtils.combineArrays(partitionKey, sortKeyRange.getPartitionKey()); } partitionRanges.add( new SinglePartitionQueryRanges(newPartitionKey, sortKeyRange.getSortKeyRanges())); } } } }
final SpaceFillingCurve sfc) { final List<byte[]> retVal = new ArrayList<>(); final byte[] tierAndBinId = ByteArrayUtils.combineArrays(new byte[] {tierId}, index.getBinId()); final RangeDecomposition rangeDecomp = sfc.decomposeRange(index, false, DEFAULT_MAX_RANGES);
internalQueryRanges.add( new ByteArrayRange( ByteArrayUtils.combineArrays( partition.getPartitionKey(), sortKeyRange.getStart()), ByteArrayUtils.combineArrays(partition.getPartitionKey(), sortKeyRange.getEnd()), sortKeyRange.singleValue));
public static SinglePartitionInsertionIds getSingleBinnedInsertionId( final BigInteger rowCount, final byte multiDimensionalId, final BinnedNumericDataset index, final SpaceFillingCurve sfc) { if (rowCount.equals(BigInteger.ONE)) { final byte[] tierAndBinId = ByteArrayUtils.combineArrays(new byte[] {multiDimensionalId}, index.getBinId()); final double[] minValues = index.getMinValuesPerDimension(); final double[] maxValues = index.getMaxValuesPerDimension(); byte[] singleId = null; if (Arrays.equals(maxValues, minValues)) { singleId = sfc.getId(minValues); } else { final byte[] minId = sfc.getId(minValues); final byte[] maxId = sfc.getId(maxValues); if (Arrays.equals(minId, maxId)) { singleId = minId; } } if (singleId != null) { return new SinglePartitionInsertionIds(tierAndBinId, singleId); } } return null; }
@Override public SinglePartitionInsertionIds apply( final SinglePartitionInsertionIds input) { if (input.getPartitionKey() != null) { return new SinglePartitionInsertionIds( ByteArrayUtils.combineArrays(partitionKey, input.getPartitionKey()), input.getSortKeys()); } else { return new SinglePartitionInsertionIds(partitionKey, input.getSortKeys()); } } }));
ByteArrayUtils.combineArrays( new byte[] {xzCurveMultiDimensionalId}, range.getBinId()),
visibility = ByteArrayUtils.combineArrays(startVisibility, endVisibility);
public GeoWaveValueImpl(final GeoWaveValue[] values) { if ((values == null) || (values.length == 0)) { fieldMask = new byte[] {}; visibility = new byte[] {}; value = new byte[] {}; } else if (values.length == 1) { fieldMask = values[0].getFieldMask(); visibility = values[0].getVisibility(); value = values[0].getValue(); } else { byte[] intermediateFieldMask = values[0].getFieldMask(); byte[] intermediateVisibility = values[0].getVisibility(); byte[] intermediateValue = values[0].getValue(); for (int i = 1; i < values.length; i++) { intermediateFieldMask = BitmaskUtils.generateANDBitmask(intermediateFieldMask, values[i].getFieldMask()); intermediateVisibility = DataStoreUtils.mergeVisibilities(intermediateVisibility, values[i].getVisibility()); intermediateValue = ByteArrayUtils.combineArrays(intermediateValue, values[i].getValue()); } fieldMask = intermediateFieldMask; visibility = intermediateVisibility; value = intermediateValue; } }