/** * Convert Titan internal Mutation representation into HBase native commands. * * @param mutations Mutations to convert into HBase commands. * @param putTimestamp The timestamp to use for Put commands. * @param delTimestamp The timestamp to use for Delete commands. * @return Commands sorted by key converted from Titan internal representation. */ private static Map<ByteBuffer, Pair<Put, Delete>> convertToCommands( Map<String, Map<ByteBuffer, KCVMutation>> mutations, final long putTimestamp, final long delTimestamp) { Map<ByteBuffer, Pair<Put, Delete>> commandsPerKey = new HashMap<ByteBuffer, Pair<Put, Delete>>(); for (Map.Entry<String, Map<ByteBuffer, KCVMutation>> entry : mutations.entrySet()) { byte[] cfName = entry.getKey().getBytes(); for (Map.Entry<ByteBuffer, KCVMutation> m : entry.getValue().entrySet()) { ByteBuffer key = m.getKey(); KCVMutation mutation = m.getValue(); Pair<Put, Delete> commands = commandsPerKey.get(key); if (commands == null) { commands = new Pair<Put, Delete>(); commandsPerKey.put(key, commands); } if (mutation.hasDeletions()) { if (commands.getSecond() == null) commands.setSecond(new Delete(ByteBufferUtil.getArray(key), delTimestamp, null)); for (ByteBuffer b : mutation.getDeletions()) { commands.getSecond().deleteColumns(cfName, ByteBufferUtil.getArray(b), delTimestamp); } } if (mutation.hasAdditions()) { if (commands.getFirst() == null) commands.setFirst(new Put(ByteBufferUtil.getArray(key), putTimestamp)); for (Entry e : mutation.getAdditions()) { commands .getFirst() .add( cfName, ByteBufferUtil.getArray(e.getColumn()), putTimestamp, ByteBufferUtil.getArray(e.getValue())); } } } } return commandsPerKey; }
private void handleScvf(SingleColumnValueFilter scvf) { ValuePartition vp = null; if (scvf instanceof SingleColumnValuePartitionFilter) { vp = ((SingleColumnValuePartitionFilter) scvf).getValuePartition(); } Column column = new Column(scvf.getFamily(), scvf.getQualifier(), vp); Pair<Value, Value> pair = colWithOperators.get(column); if (pair == null) { pair = new Pair<Value, Value>(); // The first operator should be set here pair.setFirst(new Value(scvf.getOperator(), scvf.getComparator().getValue(), scvf)); colWithOperators.put(column, pair); } else { if (pair.getFirst() != null && pair.getSecond() == null) { // TODO As Anoop said we may have to check the Value type also.. // We can not compare and validate this way. btw "a" and "K". // Only in case of Numeric col type we can have this check. byte[] curBoundValue = scvf.getComparator().getValue(); byte[] prevBoundValue = pair.getFirst().getValue(); int result = Bytes.compareTo(prevBoundValue, curBoundValue); CompareOp curBoundOperator = scvf.getOperator(); CompareOp prevBoundOperator = pair.getFirst().getOperator(); switch (curBoundOperator) { case GREATER: case GREATER_OR_EQUAL: if (prevBoundOperator == CompareOp.GREATER || prevBoundOperator == CompareOp.GREATER_OR_EQUAL) { LOG.warn("Wrong usage. It should be < > || > <. Cannot be > >"); if (result > 1) { pair.setFirst(new Value(curBoundOperator, curBoundValue, scvf)); } pair.setSecond(null); } else if (prevBoundOperator == CompareOp.LESS || prevBoundOperator == CompareOp.LESS_OR_EQUAL) { if (result < 1) { LOG.warn("Possible wrong usage as there cannot be a value < 10 and > 20"); pair.setFirst(null); pair.setSecond(null); } else { pair.setSecond(new Value(curBoundOperator, curBoundValue, scvf)); } } else if (prevBoundOperator == CompareOp.EQUAL) { LOG.warn("Use the equal operator and ignore the current one"); pair.setSecond(null); } break; case LESS: case LESS_OR_EQUAL: if (prevBoundOperator == CompareOp.LESS || prevBoundOperator == CompareOp.LESS_OR_EQUAL) { LOG.warn("Wrong usage. It should be < > || > <. Cannot be > >"); if (result < 1) { pair.setFirst(new Value(curBoundOperator, curBoundValue, scvf)); } pair.setSecond(null); } else if (prevBoundOperator == CompareOp.GREATER || prevBoundOperator == CompareOp.GREATER_OR_EQUAL) { if (result > 1) { LOG.warn("Possible wrong usage as there cannot be a value < 10 and > 20"); pair.setFirst(null); pair.setSecond(null); } else { pair.setSecond(new Value(curBoundOperator, curBoundValue, scvf)); } } else if (prevBoundOperator == CompareOp.EQUAL) { LOG.warn("Use the EQUAL operator only and ignore the current one."); pair.setSecond(null); } break; case EQUAL: // For equal condition give priority to equals only.. // If the prevOperator is also == and the current is also == // take the second one.(Currently) if (prevBoundOperator == CompareOp.LESS || prevBoundOperator == CompareOp.LESS_OR_EQUAL || prevBoundOperator == CompareOp.EQUAL || prevBoundOperator == CompareOp.GREATER || prevBoundOperator == CompareOp.GREATER_OR_EQUAL) { pair.setFirst(new Value(curBoundOperator, curBoundValue, scvf)); pair.setSecond(null); } break; case NOT_EQUAL: case NO_OP: // Need to check this break; } } else { LOG.warn( "Am getting an extra comparison coming for the same col family." + "I cannot have 3 conditions on the same column"); pair.setFirst(null); pair.setSecond(null); } } }
@Override public void asSubByteBuffer(int offset, int length, Pair<ByteBuffer, Integer> pair) { // Just return the single BB that is available pair.setFirst(this.buf); pair.setSecond(offset); }