@Override public Iterator<RowColumnValue> iterator() { return Iterators.transform(wrappedScanner.iterator(), rcv -> { log.trace("txid: {} scanId: {} next()-> {} {}", txid, scanId, Hex.encNonAscii(rcv.getRowColumn()), Hex.encNonAscii(rcv.getValue())); return rcv; }); } }
RowColumnValue rcv = rcvIter.next(); boolean retval = diff("fluo row", rcv.getRow(), actualRcv.getRow()); retval |= diff("fluo fam", rcv.getColumn().getFamily(), actualRcv.getColumn().getFamily()); retval |= diff("fluo qual", rcv.getColumn().getQualifier(), actualRcv.getColumn().getQualifier()); retval |= diff("fluo val", rcv.getValue(), actualRcv.getValue()); log.error("Difference found - row {} cf {} cq {} val {}", rcv.getsRow(), rcv.getColumn().getsFamily(), rcv.getColumn().getsQualifier(), rcv.getsValue()); return false;
private Set<RowColumnValue> genData() { Set<RowColumnValue> expected = new HashSet<>(); expected.add(new RowColumnValue("r1", new Column("f1", "q1"), "v1")); expected.add(new RowColumnValue("r1", new Column("f2", "q3"), "v2")); expected.add(new RowColumnValue("r2", new Column("f1", "q1"), "v3")); expected.add(new RowColumnValue("r2", new Column("f1", "q2"), "v4")); expected.add(new RowColumnValue("r4", new Column("f2", "q5"), "v5")); Assert.assertEquals(5, expected.size()); try (Transaction tx = client.newTransaction()) { for (RowColumnValue rcv : expected) { tx.set(rcv.getRow(), rcv.getColumn(), rcv.getValue()); } tx.commit(); } return expected; } }
@Test public void testSame() { Set<RowColumnValue> expected = genData(); Column col1 = new Column("f1", "q1"); Column col2 = new Column("f2", "q3"); HashSet<RowColumnValue> expectedC = new HashSet<>(); Iterables.addAll(expectedC, Iterables.filter(expected, rcv -> rcv.getColumn().equals(col1) || rcv.getColumn().equals(col2))); Assert.assertEquals(3, expectedC.size()); try (Snapshot snap = client.newSnapshot()) { CellScanner scanner = snap.scanner().fetch(col1, col2).build(); HashSet<RowColumnValue> actual = new HashSet<>(); Bytes prevRow = null; for (RowColumnValue rcv : scanner) { actual.add(rcv); Column c = rcv.getColumn(); Assert.assertTrue((col1.equals(c) && col1 == c) || (col2.equals(c) && col2 == c)); if (col2.equals(c)) { Assert.assertEquals(Bytes.of("r1"), rcv.getRow()); Assert.assertSame(rcv.getRow(), prevRow); } prevRow = rcv.getRow(); } Assert.assertEquals(expectedC, actual); } }
@Override public void process(TransactionBase tx, Bytes row, Column col) throws Exception { CellScanner cellScanner = tx.scanner().over(row, new Column(Bytes.of("stats"))).build(); int sum = 0; for (RowColumnValue rcv : cellScanner) { sum += Integer.parseInt(rcv.getValue().toString()); tx.delete(row, rcv.getColumn()); } if (sum != 0) { sum += TestUtil.getOrDefault(tx, row.toString(), STAT_COUNT, 0); tx.set(row.toString(), STAT_COUNT, sum + ""); } } }
Iterables.addAll(expectedR2, Iterables.filter(expected, rcv -> rcv.getsRow().equals("r2"))); Assert.assertEquals(2, expectedR2.size()); rcv -> rcv.getsRow().equals("r2") && rcv.getColumn().equals(new Column("f1", "q2")))); Assert.assertEquals(1, expectedR2c.size()); Iterables.filter(expected, rcv -> rcv.getColumn().equals(new Column("f1", "q1")))); Assert.assertEquals(2, expectedC.size()); Iterables.filter(expected, rcv -> rcv.getColumn().getsFamily().equals("f2"))); Assert.assertEquals(2, expectedCF.size()); Iterables.filter(expected, rcv -> rcv.getColumn().equals(new Column("f2", "q5")) || rcv.getColumn().equals(new Column("f1", "q1")))); Assert.assertEquals(3, expectedCols.size());
@Override public Bytes getCurrentValue() throws IOException, InterruptedException { return rowColVal.getValue(); }
/** * A helper method for parsing test data. Each string passed in is split using the specified * splitter into four fields for row, family, qualifier, and value. */ public static List<RowColumnValue> parse(Splitter splitter, String... data) { ArrayList<RowColumnValue> ret = new ArrayList<>(); for (String line : data) { Iterable<String> cols = splitter.split(line); if (Iterables.size(cols) != 4) { throw new IllegalArgumentException("Bad input " + line); } Iterator<String> iter = cols.iterator(); RowColumnValue rcv = new RowColumnValue(Bytes.of(iter.next()), new Column(iter.next(), iter.next()), Bytes.of(iter.next())); ret.add(rcv); } return ret; } }
static void setAlias(TransactionBase tx, String node, String alias) { tx.set("r:" + node, new Column("node", "alias"), alias); CellScanner scanner = tx.scanner().over(Span.prefix("r:" + node + ":")).build(); for (RowColumnValue rcv : scanner) { String otherNode = rcv.getsRow().split(":")[2]; String[] aliases = rcv.getsValue().split(":"); if (aliases.length != 2) { throw new RuntimeException("bad alias " + rcv); } if (!alias.equals(aliases[0])) { tx.delete("d:" + aliases[0] + ":" + aliases[1], new Column("edge", node + ":" + otherNode)); tx.delete("d:" + aliases[1] + ":" + aliases[0], new Column("edge", otherNode + ":" + node)); addEdge(tx, node, otherNode, alias, aliases[1]); } } }
private static Predicate<RowColumnValue> createColumnFilter(Collection<Column> allColumns) { if (allColumns.isEmpty()) { return rcv -> true; } else { Set<Bytes> families = allColumns.stream().filter(col -> !col.isQualifierSet()) .map(col -> col.getFamily()).collect(toSet()); Set<Column> columns = allColumns.stream().filter(col -> col.isQualifierSet()).collect(toSet()); if (families.isEmpty()) { return rcv -> columns.contains(rcv.getColumn()); } else if (columns.isEmpty()) { return rcv -> families.contains(rcv.getColumn().getFamily()); } else { return rcv -> families.contains(rcv.getColumn().getFamily()) || columns.contains(rcv.getColumn()); } } }
@Override public String toString() { return getRowColumn() + " " + val; }
/** * Print all statements in the repo for demo and diagnostic purposes. * @param fluoClient * @throws Exception */ public static void printTriples(final FluoClient fluoClient) throws Exception { try (Snapshot snapshot = fluoClient.newSnapshot()) { final CellScanner cscanner = snapshot.scanner().fetch(new Column("triples", "SPO")).build(); for (final RowColumnValue rcv : cscanner) { System.out.println("Triple: "+rcv.getsRow()); } } }
/** * Finds all queries that are being managed by this instance of Fluo that * are also being exported to the provided instance of Accumulo. * * @param fluo - The Fluo instance that will be searched. (not null) * @return An ascending alphabetically sorted list of the Query IDs being * managed by the Fluo app and exported to an instance of Accumulo. */ public List<String> listQueryIds(final FluoClient fluo) { checkNotNull(fluo); final List<String> queryIds = new ArrayList<>(); try(Snapshot snap = fluo.newSnapshot() ) { // Create an iterator that iterates over the QUERY_ID column. final CellScanner cellScanner = snap.scanner().fetch( FluoQueryColumns.QUERY_NODE_ID).build(); for (RowColumnValue rcv : cellScanner) { queryIds.add(rcv.getsValue()); //TODO this was doing a snap.get that seemed unnecessary } } // Sort them alphabetically. Collections.sort(queryIds); return queryIds; } }
if (options.hexEncNonAscii) { sb.setLength(0); Hex.encNonAscii(sb, rcv.getRow()); sb.append(" "); Hex.encNonAscii(sb, rcv.getColumn(), " "); sb.append("\t"); Hex.encNonAscii(sb, rcv.getValue()); System.out.println(sb.toString()); } else { sb.setLength(0); sb.append(rcv.getsRow()); sb.append(" "); sb.append(rcv.getColumn()); sb.append("\t"); sb.append(rcv.getsValue()); System.out.println(sb.toString());
@Override public ExportEntry next() { RowColumnValue rowColVal = rowIter.next(); Bytes row = rowColVal.getRow(); Bytes keyBytes = row.subSequence(bucketRow.length() + 1, row.length() - 8); Bytes seqBytes = row.subSequence(row.length() - 8, row.length()); ExportEntry ee = new ExportEntry(); ee.key = keyBytes.toArray(); ee.seq = decodeSeq(seqBytes); // TODO maybe leave as Bytes? ee.value = rowColVal.getValue().toArray(); lastRow = row; return ee; }
@Override public Bytes getCurrentValue() throws IOException, InterruptedException { return rowColVal.getValue(); }
@Override public Iterator<RowColumnValue> iterator() { Iterator<RowColumnValue> iter = Iterators.transform(scanner.iterator(), entry -> { Notification n = Notification.from(entry.getKey()); return new RowColumnValue(n.getRow(), n.getColumn(), Bytes.of(entry.getValue().get())); }); return Iterators.filter(iter, rcv -> filter.test(rcv)); } }