Examples of org.kiji.schema.KijiRowScanner

org.kiji.schema.KijiRowScanner
ys close resources: scanner.close(); } }

Note: the scanner is backed by a single iterator: {@link KijiRowScanner#iterator()} returns the same iterator always.As a result, the scanner and its iterator should not be used simultaneously from multiple places (eg. from multiple threads). Similarly, when chaining two for loops on the same row scanner, the second for loop will restart where the first for loop stopped.
.

      assert myreader instanceof CassandraKijiTableReader;
      final CassandraKijiTableReader reader = (CassandraKijiTableReader) myreader;


      try {
        // Fire up a row scanner!
        final KijiRowScanner scanner = reader.getScanner(dataRequest);
        try {
          checkScannerResults(
              alice, bob, cathy, david, scanner);
        } finally {
          scanner.close();
        }


        final KijiRowScanner scannerWithStartToken = reader.getScannerWithOptions(
            dataRequest, CassandraKijiScannerOptions.withStartToken(Long.MIN_VALUE));
        try {
          checkScannerResults(
              alice, bob, cathy, david, scannerWithStartToken);
        } finally {
          scannerWithStartToken.close();
        }


        final KijiRowScanner scannerWithStopToken = reader.getScannerWithOptions(
            dataRequest, CassandraKijiScannerOptions.withStopToken(Long.MAX_VALUE));
        try {
          checkScannerResults(
              alice, bob, cathy, david, scannerWithStopToken);
        } finally {
          scannerWithStopToken.close();
        }


        final KijiRowScanner scannerWithTokens = reader.getScannerWithOptions(
            dataRequest, CassandraKijiScannerOptions.withTokens(Long.MIN_VALUE, Long.MAX_VALUE));
        try {
          checkScannerResults(
              alice, bob, cathy, david, scannerWithTokens);
        } finally {
          scannerWithTokens.close();
        }


      } finally {
        reader.close();
      }

View Full Code Here

          ).build();


      final KijiTableReader reader = table.openTableReader();
      try {
        // Fire up a row scanner!
        final KijiRowScanner scanner = reader.getScanner(dataRequest);
        try {
          // There is a small enough amount of data that we can just put all of the rows into a hash
          // from entity ID to row data.
          HashMap<EntityId, KijiRowData> allData = new HashMap<EntityId, KijiRowData>();


          for (KijiRowData row : scanner) {
            EntityId eid = row.getEntityId();
            assert (!allData.containsKey(eid));
            allData.put(eid, row);
          }


          assertTrue(allData.containsKey(alice));
          assertTrue(allData.containsKey(bob));
          assertTrue(allData.containsKey(cathy));
          assertTrue(allData.containsKey(david));


          assertTrue(allData.get(alice).containsColumn(pets, cat));
          assertTrue(allData.get(alice).containsColumn(pets, dog));
          assertFalse(allData.get(alice).containsColumn(pets, rabbit));
          assertFalse(allData.get(alice).containsColumn(pets, fish));
          assertFalse(allData.get(alice).containsColumn(pets, bird));


          assertTrue(allData.get(bob).containsColumn(pets, cat));
          assertTrue(allData.get(bob).containsColumn(pets, rabbit));
          assertFalse(allData.get(bob).containsColumn(pets, dog));
          assertFalse(allData.get(bob).containsColumn(pets, fish));
          assertFalse(allData.get(bob).containsColumn(pets, bird));


          assertTrue(allData.get(cathy).containsColumn(pets, cat));
          assertTrue(allData.get(cathy).containsColumn(pets, fish));
          assertFalse(allData.get(cathy).containsColumn(pets, dog));
          assertFalse(allData.get(cathy).containsColumn(pets, rabbit));
          assertFalse(allData.get(cathy).containsColumn(pets, bird));


          assertTrue(allData.get(david).containsColumn(pets, cat));
          assertTrue(allData.get(david).containsColumn(pets, bird));
          assertFalse(allData.get(david).containsColumn(pets, dog));
          assertFalse(allData.get(david).containsColumn(pets, rabbit));
          assertFalse(allData.get(david).containsColumn(pets, fish));
        } finally {
          scanner.close();
        }
      } finally {
        reader.close();
      }
    } finally {

View Full Code Here

      final KijiDataRequest dataRequest = KijiDataRequest.create(family, column);
      final CassandraKijiTableReader reader = table.openTableReader();


      try {
        // Fire up a row scanner!
        final KijiRowScanner scanner = reader.getScanner(dataRequest);
        try {
          HashMap<EntityId, KijiRowData> allData = new HashMap<EntityId, KijiRowData>();


          for (KijiRowData row : scanner) {
            EntityId eid = row.getEntityId();
            assert (!allData.containsKey(eid));
            allData.put(eid, row);
          }
          assertEquals(4, allData.size());
        } finally {
          scanner.close();
        }
      } finally {
        reader.close();
      }
    } finally {

View Full Code Here

            .build();
        final KijiRowFilter rowFilter = new StripValueRowFilter();
        final KijiScannerOptions scannerOptions =
            new KijiScannerOptions().setKijiRowFilter(rowFilter);


        final KijiRowScanner scanner = reader.getScanner(dataRequest, scannerOptions);
        try {
          for (KijiRowData row : scanner) {
            final NavigableSet<String> qualifiers = row.getQualifiers("family");
            assertEquals(1, qualifiers.size());
            assertTrue(qualifiers.contains("column"));


            // Ensure that we can use getTimestamps() to count.
            assertEquals(2, row.getTimestamps("family", "column").size());
            try {
              // Cell value is stripped, hence IOException on the wrong schema hash:
              row.getMostRecentValue("family", "column");
              fail("row.getMostRecentValue() did not throw IOException.");
            } catch (IOException ioe) {
              assertTrue(ioe.getMessage(),
                  ioe.getMessage().contains(
                      "Schema with hash 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00 "
                      + "not found in schema table."));
            }
          }
        } finally {
          scanner.close();
        }
      } finally {
        reader.close();
      }
    } finally {

View Full Code Here

      final EntityId eid,
      final KijiDataRequest dataRequest
  ) throws IOException {
    final KijiScannerOptions options = new KijiScannerOptions();
    options.setStartRow(eid);
    final KijiRowScanner scanner = reader.getScanner(dataRequest, options);
    try {
      final Iterator<KijiRowData> itr = scanner.iterator();
      if (itr.hasNext()) {
        final KijiRowData scanData = itr.next();
        if (scanData.getEntityId().equals(eid)) {
          return scanData;
        }
      }
      // Fall back to normal get (should be empty);
      final KijiRowData getData = reader.get(eid, dataRequest);


      for (final Column columnRequest : dataRequest.getColumns()) {
        if (!columnRequest.isPagingEnabled()) {
          final KijiColumnName column = columnRequest.getColumnName();


          if (column.isFullyQualified()) {
            Preconditions.checkState(
                getData.getCells(column.getFamily(), column.getQualifier()).isEmpty(),
                "Fell back to a get of a non-empty row.");
          } else {
            final FamilyLayout family = table.getLayout().getFamilyMap().get(column.getFamily());


            if (family.isMapType()) {
              Preconditions.checkState(getData.getCells(columnRequest.getFamily()).isEmpty(),
                  "Fell back to a get of a non-empty row.");
            } else {
              for (final String qualifier : family.getColumnMap().keySet()) {
                Preconditions.checkState(
                    getData.getCells(columnRequest.getFamily(), qualifier).isEmpty(),
                    "Fell back to a get of a non-empty row.");
              }
            }
          }
        }
      }
      return getData;
    } finally {
      scanner.close();
    }
  }

View Full Code Here

            .addColumns(ColumnsDef.create()
                .withMaxVersions(HConstants.ALL_VERSIONS)
                .withPageSize(1)
                .addFamily("map"))
            .build();
        final KijiRowScanner scanner = reader.getScanner(dataRequest);
        try {
          int nrows = 0;
          boolean foundRow0 = false;
          for (KijiRowData row : scanner) {
            LOG.debug("Scanning row: {}", row);


            // All rows but "row3" should be scanned through:
            assertFalse(row.getEntityId().getComponentByIndex(0).equals("row3"));


            // Validate "row0", which contains both paged and non-paged cells:
            if (row.getEntityId().getComponentByIndex(0).equals("row0")) {
              foundRow0 = true;


              // Make sure we can still read the columns that are not paged:
              assertEquals(ImmutableMap.builder()
                  .put(3L, new Utf8("value3"))
                  .put(2L, new Utf8("value2"))
                  .put(1L, new Utf8("value1"))
                  .build(),
                  row.getValues("family", "qual0"));


              // The values for "map:*" should ideally not be retrieved.
              // We cannot use KeyOnlyFilter, but we can use FirstKeyOnlyFilter to limit
              // the number of KeyValues fetched:
              assertEquals(ImmutableMap.builder()
                  .put("int1", ImmutableMap.builder()
                      .put(1L, 11)
                      .build())
                  .build(),
                  row.getValues("map"));
            }


            nrows += 1;
          }
          assertEquals(3, nrows);
          assertTrue(foundRow0);
        } finally {
          scanner.close();
        }
      } finally {
        reader.close();
      }
    } finally {

View Full Code Here

                .add("family", "qual0"))
            .addColumns(ColumnsDef.create()
                .withMaxVersions(HConstants.ALL_VERSIONS)
                .addFamily("map"))
            .build();
        final KijiRowScanner scanner = reader.getScanner(dataRequest);
        try {
          int nrows = 0;
          boolean foundRow0 = false;
          for (KijiRowData row : scanner) {
            LOG.debug("Scanning row: {}", row);


            // All rows but "row3" should be scanned through:
            assertFalse(row.getEntityId().getComponentByIndex(0).equals("row3"));


            // Validate "row0", which contains both paged and non-paged cells:
            if (row.getEntityId().getComponentByIndex(0).equals("row0")) {
              foundRow0 = true;


              // The values for "family:qual0" should ideally not be retrieved.
              // We cannot use KeyOnlyFilter, but we can use FirstKeyOnlyFilter to limit
              // the number of KeyValues fetched:
              assertEquals(ImmutableMap.builder()
                  .put(3L, new Utf8("value3"))
                  .build(),
                  row.getValues("family", "qual0"));


              // Make sure we can still read the columns that are not paged:
              assertEquals(ImmutableMap.builder()
                  .put("int1", ImmutableMap.builder()
                      .put(0L, 10)
                      .put(1L, 11)
                      .build())
                  .put("int2", ImmutableMap.builder()
                      .put(0L, 20)
                      .put(1L, 21)
                      .build())
                  .build(),
                  row.getValues("map"));
            }


            nrows += 1;
          }
          assertEquals(3, nrows);
          assertTrue(foundRow0);
        } finally {
          scanner.close();
        }
      } finally {
        reader.close();
      }
    } finally {

View Full Code Here

            .addColumns(ColumnsDef.create()
                .withPageSize(1)
                .add("family", "qual0")
                .add("family", "qual1"))
            .build();
        final KijiRowScanner scanner = reader.getScanner(dataRequest);
        try {
          int nrows = 0;
          for (KijiRowData row : scanner) {
            LOG.debug("Scanning row: {}", row);


            // All rows but "row2" should be scanned through:
            assertFalse(row.getEntityId().getComponentByIndex(0).equals("row2"));
            nrows += 1;
          }
          assertEquals(2, nrows);
        } finally {
          scanner.close();
        }
      } finally {
        reader.close();
      }
    } finally {

View Full Code Here

        final KijiDataRequest dataRequest = KijiDataRequest.builder()
            .addColumns(ColumnsDef.create()
                .withPageSize(1)
                .addFamily("map"))
            .build();
        final KijiRowScanner scanner = reader.getScanner(dataRequest);
        try {
          int nrows = 0;
          for (KijiRowData row : scanner) {
            LOG.debug("Scanning row: {}", row);


            // All rows but "row2" should be scanned through:
            assertFalse(row.getEntityId().getComponentByIndex(0).equals("row2"));
            nrows += 1;
          }
          assertEquals(2, nrows);
        } finally {
          scanner.close();
        }
      } finally {
        reader.close();
      }
    } finally {

View Full Code Here

        String s = rowData.getValue("family", "column", 0L).toString();
        assertEquals(s, "Value at timestamp 0.");


        // Try this as a scan.
        int rowCounter = 0;
        final KijiRowScanner rowScanner = reader.getScanner(dataRequest);
        try {
          // Should be just one row, with two versions.
          for (KijiRowData kijiRowData : rowScanner) {
            LOG.info("Read from scanner! " + kijiRowData.toString());
            // Should see two versions for qualifier "column".
            assertEquals(
                "Value at timestamp 0.", kijiRowData.getValue("family", "column", 0L).toString());
            assertEquals(
                "Value at timestamp 1.", kijiRowData.getValue("family", "column", 1L).toString());
            rowCounter++;
          }
        } finally {
          rowScanner.close();
        }
        assertEquals(1, rowCounter);
      } finally {
        reader.close();
      }

View Full Code Here

0 1

TOP

Related Classes of org.kiji.schema.KijiRowScanner

org.kiji.schema.cassandra.TestCassandraCreateKijiTable

org.kiji.schema.cassandra.TestCassandraReadAndWrite

org.kiji.schema.filter.TestStripValueRowFilter

org.kiji.schema.impl.hbase.TestHBaseDataRequestAdapter

org.kiji.schema.impl.hbase.TestHBaseScanKijiRowData

org.kiji.schema.tools.ScanTool

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.