/** * * @return next element of HbaseData. */ public HBaseData next() { HBaseData data = null; Result result = resultsIter.next(); counter++; List<KeyValue> values = result.list(); for (KeyValue value : values) { data = new HBaseData(new String(value.getFamily()), value.getRow()); break; } data.setColumns(values); return data; }
if (Type.codeToType(keyValue.getType()) == Type.Put) { Delete delete = new Delete(keyValue.getRow()); KeyValue deleteKeyValue = new KeyValue(buf, keyValue.getRowOffset(), keyValue.getRowLength(), buf, keyValue.getFamilyOffset(), keyValue.getFamilyLength(), KeyValue newKeyValue = SchemaUtil.upgradeTo3(keyValue); Put put = new Put(newKeyValue.getRow()); put.add(newKeyValue); mutations.add(put); newKeyValue.getTimestamp(), Type.Put, ORIG_DEF_CF_NAME,0,ORIG_DEF_CF_NAME.length); Put defCFNamePut = new Put(defCFNameKeyValue.getRow()); defCFNamePut.add(defCFNameKeyValue); mutations.add(defCFNamePut); Delete delete = new Delete(newKeyValue.getRow());
Pair<byte[],List<KeyValue>> row = dataIterator.next(); for(KeyValue kv : row.getSecond()){ context.write(new ImmutableBytesWritable(kv.getRow()), kv);
@Override public Object[] scanRowKeys(final HTableInterface hTable, final Filter filter, final String columnFamilyName, final String columnName, final Class rowKeyClazz) throws IOException { List<Object> rowKeys = new ArrayList<Object>(); if (scanner == null) { Scan s = new Scan(); s.setFilter(filter); s.addColumn(Bytes.toBytes(columnFamilyName), Bytes.toBytes(columnName)); scanner = hTable.getScanner(s); resultsIter = scanner.iterator(); } if (fetchSize == null) { for (Result result : scanner) { for (KeyValue keyValue : result.list()) { rowKeys.add(HBaseUtils.fromBytes(keyValue.getRow(), rowKeyClazz)); } } } if (rowKeys != null && !rowKeys.isEmpty()) { return rowKeys.toArray(new Object[0]); } return null; }
value.getRow()); break;
value.getRow()); break;
@Override public KeyValue getHint(KeyValue peeked) { // check to see if we have another column to seek ImmutableBytesPtr nextFamily = getNextFamily(new ImmutableBytesPtr(peeked.getBuffer(), peeked.getFamilyOffset(), peeked.getFamilyLength())); if (nextFamily == null) { // no known next family, so we can be completely done done = true; return KeyValue.LOWESTKEY; } // there is a valid family, so we should seek to that return KeyValue.createFirstOnRow(peeked.getRow(), nextFamily.copyBytesIfNecessary(), HConstants.EMPTY_BYTE_ARRAY); }
value.getRow()); break;
private static void assertRow1(Iterator<KeyValue> iterator, byte[] expectedRowKey1) { KeyValue kv; assertTrue(iterator.hasNext()); kv = iterator.next(); assertArrayEquals(expectedRowKey1, kv.getRow()); assertEquals(name1, PDataType.VARCHAR.toObject(kv.getValue())); assertTrue(iterator.hasNext()); kv = iterator.next(); assertArrayEquals(expectedRowKey1, kv.getRow()); assertEquals(now, PDataType.DATE.toObject(kv.getValue())); assertTrue(iterator.hasNext()); kv = iterator.next(); assertArrayEquals(expectedRowKey1, kv.getRow()); assertNull(PDataType.VARCHAR.toObject(kv.getValue())); }
private static void assertRow2(Iterator<KeyValue> iterator, byte[] expectedRowKey2) { KeyValue kv; assertTrue(iterator.hasNext()); kv = iterator.next(); assertArrayEquals(expectedRowKey2, kv.getRow()); assertEquals(name2, PDataType.VARCHAR.toObject(kv.getValue())); assertTrue(iterator.hasNext()); kv = iterator.next(); assertArrayEquals(expectedRowKey2, kv.getRow()); assertEquals(now, PDataType.DATE.toObject(kv.getValue())); assertTrue(iterator.hasNext()); kv = iterator.next(); assertArrayEquals(expectedRowKey2, kv.getRow()); assertNull(PDataType.VARCHAR.toObject(kv.getValue())); }
@Override public Collection<Pair<Mutation, byte[]>> getIndexUpdateForFilteredRows( Collection<KeyValue> filtered) throws IOException { // stores all the return values IndexUpdateManager updateMap = new IndexUpdateManager(); // batch the updates by row to make life easier and ordered Collection<Batch> batches = batchByRow(filtered); for (Batch batch : batches) { Put p = new Put(batch.getKvs().iterator().next().getRow()); for (KeyValue kv : batch.getKvs()) { // we only need to cleanup Put entries byte type = kv.getType(); Type t = KeyValue.Type.codeToType(type); if (!t.equals(Type.Put)) { continue; } // add the kv independently p.add(kv); } // do the usual thing as for deletes Collection<Batch> timeBatch = createTimestampBatchesFromMutation(p); LocalTableState state = new LocalTableState(env, localTable, p); for (Batch entry : timeBatch) { //just set the timestamp on the table - it already has all the future state state.setCurrentTimestamp(entry.getTimestamp()); this.addDeleteUpdatesToMap(updateMap, state, entry.getTimestamp()); } } return updateMap.toMap(); }
/** * Gets the KeyValue's row key. * * <p>This requires some array copying, which is only done once within the wrapped * KeyValue object and cached.</p> * * @return The row key. * @see org.apache.hadoop.hbase.KeyValue */ public byte[] getRowKey() { return mKeyValue.getRow(); }
List<KeyValue> dataKeyValues = iterator.next().getSecond(); Map<ColumnReference,byte[]> valueMap = Maps.newHashMapWithExpectedSize(dataKeyValues.size()); ImmutableBytesWritable rowKeyPtr = new ImmutableBytesWritable(dataKeyValues.get(0).getRow()); Put dataMutation = new Put(rowKeyPtr.copyBytes()); for (KeyValue kv : dataKeyValues) {
Delete delete = new Delete(results.get(0).getRow(),ts,null); mutations.add(new Pair<Mutation,Integer>(delete,null)); } else if (isUpsert) { Delete delete = new Delete(results.get(0).getRow()); delete.deleteColumns(deleteCF, deleteCQ, ts); mutations.add(new Pair<Mutation,Integer>(delete,null)); long kvts = kv.getTimestamp(); if (!timeStamps.contains(kvts)) { Put put = new Put(kv.getRow()); put.add(emptyCF, QueryConstants.EMPTY_COLUMN_BYTES, kvts, ByteUtil.EMPTY_BYTE_ARRAY); mutations.add(new Pair<Mutation,Integer>(put,null));
byte[] rowKey; do { rowKey = results.get(0).getRow(); int nColumns = getVarChars(rowKey, rowKeyMetaData); if (nColumns == 5 && rowKeyMetaData[PhoenixDatabaseMetaData.COLUMN_NAME_INDEX].length == 0 && rowKeyMetaData[PhoenixDatabaseMetaData.INDEX_NAME_INDEX].length > 0) {
filter = new ApplyAndFilterDeletesFilter(asSet(laterFamily)); assertEquals(ReturnCode.SKIP, filter.filterKeyValue(kv)); KeyValue expected = KeyValue.createFirstOnRow(kv.getRow(), laterFamily, new byte[0]); assertEquals("Didn't get a hint from a family delete", ReturnCode.SEEK_NEXT_USING_HINT, filter.filterKeyValue(next));
private void validate(KeyValue kv, byte[] row, byte[] family, byte[] qualifier, long ts, Type type, byte[] value) throws IOException { DataOutputBuffer out = new DataOutputBuffer(); kv.write(out); out.close(); byte[] data = out.getData(); // read it back in KeyValue read = new KeyValue(); DataInputBuffer in = new DataInputBuffer(); in.reset(data, data.length); read.readFields(in); in.close(); // validate that its the same assertTrue("Row didn't match!", Bytes.equals(row, read.getRow())); assertTrue("Family didn't match!", Bytes.equals(family, read.getFamily())); assertTrue("Qualifier didn't match!", Bytes.equals(qualifier, read.getQualifier())); assertTrue("Value didn't match!", Bytes.equals(value, read.getValue())); assertEquals("Timestamp didn't match", ts, read.getTimestamp()); assertEquals("Type didn't match", type.getCode(), read.getType()); }
public static HBaseTuple getHBaseTuple(KeyValue kv) { HBaseTuple tuple = new HBaseTuple(); tuple.setRow(new String(kv.getRow())); tuple.setColFamily(new String(kv.getFamily())); tuple.setColName(new String(kv.getQualifier())); tuple.setColValue(new String(kv.getValue())); return tuple; }
protected static KeyValue getLockKv(KeyValue dataKv, byte[] lockBytes) { Column lockColumn = ColumnUtil.getLockColumn(new Column(dataKv.getFamily(), dataKv .getQualifier())); return new KeyValue(dataKv.getRow(), lockColumn.getFamily(), lockColumn.getQualifier(), PREWRITE_TS, Type.Put, lockBytes); }
protected void checkGetOneColumnConflictResult(ColumnCoordinate columnCoordinate, Result internalResult, long prewriteTs) throws IOException { Assert.assertTrue(ThemisCpUtil.isLockResult(internalResult)); Assert.assertEquals(1, internalResult.list().size()); KeyValue kv = internalResult.list().get(0); Assert.assertTrue(ColumnUtil.getLockColumn(columnCoordinate).equals( new ColumnCoordinate(columnCoordinate.getTableName(), kv.getRow(), kv.getFamily(), kv.getQualifier()))); Assert.assertEquals(prewriteTs, kv.getTimestamp()); Assert.assertArrayEquals(ThemisLock.toByte(getLock(columnCoordinate, prewriteTs)), kv.getValue()); }