public Pair<byte[], byte[]> getFirstPartitionAndSortKeyPair() { if (partitionKeys == null) { return null; } for (final SinglePartitionInsertionIds p : partitionKeys) { if ((p.getSortKeys() != null) && !p.getSortKeys().isEmpty()) { return new ImmutablePair<>(p.getPartitionKey(), p.getSortKeys().get(0)); } else if ((p.getPartitionKey() != null)) { return new ImmutablePair<>(p.getPartitionKey(), null); } } 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()); } } }));
@Override public MultiDimensionalNumericData getRangeForId( final byte[] partitionKey, final byte[] sortKey) { final List<byte[]> insertionIds = new SinglePartitionInsertionIds(partitionKey, sortKey).getCompositeInsertionIds(); if (insertionIds.isEmpty()) { LOGGER.warn("Unexpected empty insertion ID in getRangeForId()"); return null; } final byte[] rowId = insertionIds.get(0); return BinnedSFCUtils.getRangeForId(rowId, baseDefinitions, sfc); }
public SinglePartitionInsertionIds( final byte[] partitionKey, final SinglePartitionInsertionIds insertionId2) { this(new SinglePartitionInsertionIds(partitionKey, (List<byte[]>) null), insertionId2); }
public boolean hasDuplicates() { if (compositeInsertionIds != null) { return compositeInsertionIds.size() >= 2; } if ((partitionKeys == null) || partitionKeys.isEmpty()) { return false; } if (partitionKeys.size() > 1) { return true; } final SinglePartitionInsertionIds partition = partitionKeys.iterator().next(); if ((partition.getSortKeys() == null) || (partition.getSortKeys().size() <= 1)) { return false; } return true; }
public static byte[][] getInsertionPartitionKeys( final NumericIndexStrategy strategy, final MultiDimensionalNumericData insertionData) { final InsertionIds insertionIds = strategy.getInsertionIds(insertionData); return insertionIds.getPartitionKeys().stream().map(input -> input.getPartitionKey()).toArray( i -> new byte[i][]); } }
@Override public void fromBinary(final byte[] bytes) { final ByteBuffer buf = ByteBuffer.wrap(bytes); final int size = VarintUtils.readUnsignedInt(buf); if (size > 0) { partitionKeys = new ArrayList<>(size); for (int i = 0; i < size; i++) { final int length = VarintUtils.readUnsignedInt(buf); final byte[] pBytes = new byte[length]; buf.get(pBytes); final SinglePartitionInsertionIds pId = new SinglePartitionInsertionIds(); pId.fromBinary(pBytes); partitionKeys.add(pId); } } else { partitionKeys = new ArrayList<>(); } } }
public List<byte[]> getCompositeInsertionIds() { if (compositeInsertionIds != null) { return compositeInsertionIds; } if ((partitionKeys == null) || partitionKeys.isEmpty()) { return Collections.EMPTY_LIST; } final List<byte[]> internalCompositeInsertionIds = new ArrayList<>(); for (final SinglePartitionInsertionIds k : partitionKeys) { final List<byte[]> i = k.getCompositeInsertionIds(); if ((i != null) && !i.isEmpty()) { internalCompositeInsertionIds.addAll(i); } } compositeInsertionIds = internalCompositeInsertionIds; return compositeInsertionIds; }
@Override public byte[] toBinary() { if ((partitionKeys != null) && !partitionKeys.isEmpty()) { final List<byte[]> partitionKeysBinary = new ArrayList<>(partitionKeys.size()); int totalSize = VarintUtils.unsignedIntByteLength(partitionKeys.size()); for (final SinglePartitionInsertionIds id : partitionKeys) { final byte[] binary = id.toBinary(); totalSize += (VarintUtils.unsignedIntByteLength(binary.length) + binary.length); partitionKeysBinary.add(binary); } final ByteBuffer buf = ByteBuffer.allocate(totalSize); VarintUtils.writeUnsignedInt(partitionKeys.size(), buf); for (final byte[] binary : partitionKeysBinary) { VarintUtils.writeUnsignedInt(binary.length, buf); buf.put(binary); } return buf.array(); } else { return ByteBuffer.allocate(4).putInt(0).array(); } }
public InsertionIds(final List<byte[]> sortKeys) { this(new SinglePartitionInsertionIds(null, sortKeys)); }
public int getSize() { if (size >= 0) { return size; } if (compositeInsertionIds != null) { size = compositeInsertionIds.size(); return size; } if ((partitionKeys == null) || partitionKeys.isEmpty()) { size = 0; return size; } int internalSize = 0; for (final SinglePartitionInsertionIds k : partitionKeys) { final List<byte[]> i = k.getCompositeInsertionIds(); if ((i != null) && !i.isEmpty()) { internalSize += i.size(); } } size = internalSize; return size; }
@Override public void insertionIdsRemoved(final InsertionIds insertionIds) { for (final SinglePartitionInsertionIds partitionId : insertionIds.getPartitionKeys()) { final byte first = partitionId.getPartitionKey()[0]; if (first == pointCurveMultiDimensionalId) { pointCurveCount -= partitionId.getSortKeys().size(); } else if (first == xzCurveMultiDimensionalId) { xzCurveCount -= partitionId.getSortKeys().size(); } } }
private InsertionIds trimPartitionForSubstrategy(final InsertionIds insertionIds) { final List<SinglePartitionInsertionIds> retVal = new ArrayList<>(); for (final SinglePartitionInsertionIds partitionIds : insertionIds.getPartitionKeys()) { final byte[] trimmedPartitionId = CompoundIndexStrategy.trimPartitionForSubstrategy( partition1Length, index == 0, partitionIds.getPartitionKey()); if (trimmedPartitionId == null) { return insertionIds; } else { retVal.add( new SinglePartitionInsertionIds(trimmedPartitionId, partitionIds.getSortKeys())); } } return new InsertionIds(retVal); }
public InsertionIds(final byte[] partitionKey) { this(new SinglePartitionInsertionIds(partitionKey)); }
@Override public MultiDimensionalNumericData getRangeForId( final byte[] partitionKey, final byte[] sortKey) { final List<byte[]> insertionIds = new SinglePartitionInsertionIds(partitionKey, sortKey).getCompositeInsertionIds(); if (insertionIds.isEmpty()) { LOGGER.warn("Unexpected empty insertion ID in getRangeForId()"); return null; } final byte[] rowId = insertionIds.get(0); if (rowId.length > 0) { final Integer orderedSfcIndex = orderedSfcIndexToTierId.inverse().get(rowId[0]); return BinnedSFCUtils.getRangeForId(rowId, baseDefinitions, orderedSfcs[orderedSfcIndex]); } else { LOGGER.warn("Row must at least contain a byte for tier"); } return null; }
@Override public void insertionIdsAdded(final InsertionIds insertionIds) { for (final SinglePartitionInsertionIds partitionId : insertionIds.getPartitionKeys()) { final byte first = partitionId.getPartitionKey()[0]; if (first == pointCurveMultiDimensionalId) { pointCurveCount += partitionId.getSortKeys().size(); } else if (first == xzCurveMultiDimensionalId) { xzCurveCount += partitionId.getSortKeys().size(); } } }
public InsertionIds(final byte[] partitionKey, final List<byte[]> sortKeys) { this(new SinglePartitionInsertionIds(partitionKey, sortKeys)); }
@Override public SinglePartitionQueryRanges apply(final SinglePartitionInsertionIds input) { return new SinglePartitionQueryRanges( input.getPartitionKey(), Collections2.transform( input.getSortKeys(), new Function<byte[], ByteArrayRange>() { @Override public ByteArrayRange apply(final byte[] input) { return new ByteArrayRange(input, input, false); } })); } }));
private synchronized SinglePartitionInsertionIds getRowIds( final BinnedNumericDataset index, final BigInteger maxEstimatedDuplicateIds) { // most times this should be a single row ID, but if the lowest // precision tier does not have a single SFC value for this data, it // will be multiple row IDs // what tier does this entry belong in? for (int sfcIndex = orderedSfcs.length - 1; sfcIndex >= 0; sfcIndex--) { final SpaceFillingCurve sfc = orderedSfcs[sfcIndex]; // loop through space filling curves and stop when both the min and // max of the ranges fit the same row ID final byte tierId = orderedSfcIndexToTierId.get(sfcIndex); final SinglePartitionInsertionIds rowIdsAtTier = getRowIdsAtTier(index, tierId, sfc, maxEstimatedDuplicateIds, sfcIndex); if (rowIdsAtTier != null) { return rowIdsAtTier; } } // this should never happen because of the check for tier 0 return new SinglePartitionInsertionIds(null, new ArrayList<byte[]>()); }
@Override public void insertionIdsRemoved(final InsertionIds ids) { for (final SinglePartitionInsertionIds partitionIds : ids.getPartitionKeys()) { final byte first = partitionIds.getPartitionKey()[0]; if (orderedTierIdToSfcIndex.containsKey(first)) { tierCounts[orderedTierIdToSfcIndex.get(partitionIds.getPartitionKey()[0]).intValue()] -= partitionIds.getSortKeys().size(); } } }