@Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("keyvalues="); if(this.result.isEmpty()) { sb.append("NONE"); return sb.toString(); } sb.append("{"); boolean moreThanOne = false; for(KeyValue kv : this.result.list()) { if(moreThanOne) { sb.append(", \n"); } else { moreThanOne = true; } sb.append(kv.toString()+"/value="+Bytes.toString(kv.getValue())); } sb.append("}\n"); return sb.toString(); }
/** * * @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; }
@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; }
List<KeyValue> values = result.list(); for (KeyValue value : values)
List<KeyValue> values = result.list();
/** * Initialize the managed local state. Generally, this will only be called by * {@link #getNonIndexedColumnsTableState(List)}, which is unlikely to be called concurrently from the outside. * Even then, there is still fairly low contention as each new Put/Delete will have its own table * state. */ private synchronized void ensureLocalStateInitialized( Collection<? extends ColumnReference> columns) throws IOException { // check to see if we haven't initialized any columns yet Collection<? extends ColumnReference> toCover = this.columnSet.findNonCoveredColumns(columns); // we have all the columns loaded, so we are good to go. if (toCover.isEmpty()) { return; } // add the current state of the row this.addUpdate(this.table.getCurrentRowState(update, toCover).list(), false); // add the covered columns to the set for (ColumnReference ref : toCover) { this.columnSet.addColumn(ref); } }
private int getKeyValueCount(HTable table) throws IOException { Scan scan = new Scan(); scan.setMaxVersions(Integer.MAX_VALUE - 1); ResultScanner results = table.getScanner(scan); int count = 0; for (Result res : results) { count += res.list().size(); System.out.println(count + ") " + res); } results.close(); return count; } }
/** * Verify the state of the index table between the given key and time ranges against the list of * expected keyvalues. * @throws IOException */ @SuppressWarnings("javadoc") public static void verifyIndexTableAtTimestamp(HTable index1, List<KeyValue> expected, long start, long end, byte[] startKey, byte[] endKey) throws IOException { LOG.debug("Scanning " + Bytes.toString(index1.getTableName()) + " between times (" + start + ", " + end + "] and keys: [" + Bytes.toString(startKey) + ", " + Bytes.toString(endKey) + "]."); Scan s = new Scan(startKey, endKey); // s.setRaw(true); s.setMaxVersions(); s.setTimeRange(start, end); List<KeyValue> received = new ArrayList<KeyValue>(); ResultScanner scanner = index1.getScanner(s); for (Result r : scanner) { received.addAll(r.list()); LOG.debug("Received: " + r.list()); } scanner.close(); assertEquals("Didn't get the expected kvs from the index table!", expected, received); }
private static boolean checkResultExist(Result result) { if (result.list() == null) { return false; } else { return true; } }
@Override protected void map(ImmutableBytesWritable key, Result result, Context context) throws IOException, InterruptedException { // DebugHack.log("Snapshot mapper running"); for (KeyValue kv : result.list()) { context.write(key, kv); } } }
@Override public void map(ImmutableBytesWritable row, Result columns, Context context) throws IOException, InterruptedException { for (KeyValue kv : columns.list()) { byte[] value = kv.getValue(); Stock stock = stockReader.decode(value); outputKey.set(stock.symbol.toString()); outputValue.set(stock.close); context.write(outputKey, outputValue); } }
public static boolean isLockResult(Result result) { if (result.isEmpty()) { return false; } KeyValue firstKv = result.list().get(0); return ColumnUtil.isLockColumn(firstKv.getFamily(), firstKv.getQualifier()); }
protected byte[] readLockBytes(HRegion region, byte[] row, Integer lid, Column column, long prewriteTs, MetricsTimeVaryingRate latency) throws IOException { Column lockColumn = ColumnUtil.getLockColumn(column); Get get = new Get(row).addColumn(lockColumn.getFamily(), lockColumn.getQualifier()); get.setTimeStamp(prewriteTs); Result result = getFromRegion(region, get, lid, latency); return result.isEmpty() ? null : result.list().get(0).getValue(); }
protected void checkScanRow(ColumnCoordinate[] columns, Result result) throws IOException { Assert.assertEquals(columns.length, result.size()); for (ColumnCoordinate columnCoordinate : columns) { Assert.assertArrayEquals(VALUE, result.getValue(columnCoordinate.getFamily(), columnCoordinate.getQualifier())); } for (int i = 0; i < result.list().size(); ++i) { Assert.assertEquals(lastTs(prewriteTs), result.list().get(i).getTimestamp()); } Assert.assertArrayEquals(columns[0].getRow(), result.getRow()); }
@Test public void testGetEntireRow() throws IOException { commitTestTransaction(); nextTransactionTs(); createTransactionWithMock(); Result result = transaction.get(TABLENAME, new ThemisGet(ROW)); Assert.assertEquals(2, result.size()); checkResultKvColumn(COLUMN_WITH_ANOTHER_FAMILY, result.list().get(0)); checkResultKvColumn(COLUMN, result.list().get(1)); }
public void map(ImmutableBytesWritable row, Result values, Context context) throws IOException, InterruptedException { byte[] reduceKey = getRowKeyWithPrefix(row.copyBytes()); Put put = new Put(reduceKey); for (KeyValue kv : values.list()) { put.add(kv.getFamily(), kv.getQualifier(), kv.getValue()); } TableMutations tableMuation = new TableMutations(tableName); tableMuation.add(put); context.write(new ImmutableBytesWritable(reduceKey), tableMuation); } }
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()); }
protected void checkReadColumnResultWithTs(Result result, ColumnCoordinate columnCoordinate, long ts) { Assert.assertEquals(1, result.size()); KeyValue kv = result.list().get(0); Assert.assertArrayEquals(columnCoordinate.getRow(), kv.getRow()); Assert.assertArrayEquals(columnCoordinate.getFamily(), kv.getFamily()); Assert.assertArrayEquals(columnCoordinate.getQualifier(), kv.getQualifier()); Assert.assertEquals(ts, kv.getTimestamp()); Assert.assertArrayEquals(VALUE, kv.getValue()); }