Java HConstants.LATEST_TIMESTAMP屬性代碼示例

/**
 * Opens a scanner across memstore, snapshot, and all StoreFiles. Assumes we
 * are not in a compaction.
 *
 * @param store   who we scan
 * @param scan    the spec
 * @param columns which columns we are scanning
 * @throws IOException
 */
public StoreScanner(Store store, ScanInfo scanInfo, Scan scan, final NavigableSet<byte[]> columns,
    long readPt) throws IOException {
  this(store, scan, scanInfo, columns, readPt, scan.getCacheBlocks());
  if (columns != null && scan.isRaw()) {
    throw new DoNotRetryIOException("Cannot specify any column for a raw scan");
  }
  matcher = new ScanQueryMatcher(scan, scanInfo, columns, ScanType.USER_SCAN, Long.MAX_VALUE,
      HConstants.LATEST_TIMESTAMP, oldestUnexpiredTS, now, store.getCoprocessorHost());
  this.store.addChangedReaderObserver(this);
  // Pass columns to try to filter out unnecessary StoreFiles.
  List<KeyValueScanner> scanners = getScannersNoCompaction();
  // Seek all scanners to the start of the Row (or if the exact matching row
  // key does not exist, then to the start of the next matching Row).
  // Always check bloom filter to optimize the top row seek for delete
  // family marker.
  seekScanners(scanners, matcher.getStartKey(), explicitColumnQuery && lazySeekEnabledGlobally,
      parallelSeekEnabled);
  // set storeLimit
  this.storeLimit = scan.getMaxResultsPerColumnFamily();
  // set rowOffset
  this.storeOffset = scan.getRowOffsetPerColumnFamily();
  // Combine all seeked scanners with a heap
  resetKVHeap(scanners, store.getComparator());
}
 

public static TDelete deleteFromHBase(Delete in) {
  TDelete out = new TDelete(ByteBuffer.wrap(in.getRow()));

  List<TColumn> columns = new ArrayList<TColumn>();
  long rowTimestamp = in.getTimeStamp();
  if (rowTimestamp != HConstants.LATEST_TIMESTAMP) {
    out.setTimestamp(rowTimestamp);
  }

  // Map<family, List<KeyValue>>
  for (Map.Entry<byte[], List<org.apache.hadoop.hbase.Cell>> familyEntry:
      in.getFamilyCellMap().entrySet()) {
    TColumn column = new TColumn(ByteBuffer.wrap(familyEntry.getKey()));
    for (org.apache.hadoop.hbase.Cell cell: familyEntry.getValue()) {
      byte[] family = CellUtil.cloneFamily(cell);
      byte[] qualifier = CellUtil.cloneQualifier(cell);
      long timestamp = cell.getTimestamp();
      if (family != null) {
        column.setFamily(family);
      }
      if (qualifier != null) {
        column.setQualifier(qualifier);
      }
      if (timestamp != HConstants.LATEST_TIMESTAMP) {
        column.setTimestamp(timestamp);
      }
    }
    columns.add(column);
  }
  out.setColumns(columns);

  return out;
}
 

/** Constructor for testing. */
ReversedStoreScanner(final Scan scan, ScanInfo scanInfo, ScanType scanType,
    final NavigableSet<byte[]> columns, final List<KeyValueScanner> scanners)
    throws IOException {
  super(scan, scanInfo, scanType, columns, scanners,
      HConstants.LATEST_TIMESTAMP);
}
 

private KeyValue createKV(int noOfTags) {
  byte[] row = Bytes.toBytes("myRow");
  byte[] cf = Bytes.toBytes("myCF");
  byte[] q = Bytes.toBytes("myQualifier");
  byte[] value = Bytes.toBytes("myValue");
  List<Tag> tags = new ArrayList<Tag>(noOfTags);
  for (int i = 1; i <= noOfTags; i++) {
    tags.add(new Tag((byte) i, Bytes.toBytes("tagValue" + i)));
  }
  return new KeyValue(row, cf, q, HConstants.LATEST_TIMESTAMP, value, tags);
}
 

private void doPuts(Region region) throws IOException{
  LoadTestKVGenerator dataGenerator = new LoadTestKVGenerator(MIN_VALUE_SIZE, MAX_VALUE_SIZE);
   for (int i = 0; i < NUM_ROWS; ++i) {
    byte[] key = LoadTestKVGenerator.md5PrefixedKey(i).getBytes();
    for (int j = 0; j < NUM_COLS_PER_ROW; ++j) {
      Put put = new Put(key);
      put.setDurability(Durability.ASYNC_WAL);
      byte[] col = Bytes.toBytes(String.valueOf(j));
      byte[] value = dataGenerator.generateRandomSizeValue(key, col);
      if (includeTags) {
        Tag[] tag = new Tag[1];
        tag[0] = new Tag((byte) 1, "Visibility");
        KeyValue kv = new KeyValue(key, CF_BYTES, col, HConstants.LATEST_TIMESTAMP, value, tag);
        put.add(kv);
      } else {
        put.add(CF_BYTES, col, value);
      }
      if(VERBOSE){
        KeyValue kvPut = new KeyValue(key, CF_BYTES, col, value);
        System.err.println(Strings.padFront(i+"", ' ', 4)+" "+kvPut);
      }
      region.put(put);
    }
    if (i % NUM_ROWS_PER_FLUSH == 0) {
      region.flush(true);
    }
  }
}
 

private void resetTSAndType() {
  latestTSOfCurrentColumn = HConstants.LATEST_TIMESTAMP;
  latestTypeOfCurrentColumn = 0;
}
 

private void resetTS() {
  latestTSOfCurrentColumn = HConstants.LATEST_TIMESTAMP;
}
 

ScanQueryMatcher(Scan scan, ScanInfo scanInfo,
    NavigableSet<byte[]> columns, long oldestUnexpiredTS, long now) throws IOException {
  this(scan, scanInfo, columns, ScanType.USER_SCAN,
        Long.MAX_VALUE, /* max Readpoint to track versions */
      HConstants.LATEST_TIMESTAMP, oldestUnexpiredTS, now, null);
}
 

@Override public Cell getRowKeyAtOrBefore(final byte[] row) throws IOException {
  // If minVersions is set, we will not ignore expired KVs.
  // As we're only looking for the latest matches, that should be OK.
  // With minVersions > 0 we guarantee that any KV that has any version
  // at all (expired or not) has at least one version that will not expire.
  // Note that this method used to take a KeyValue as arguments. KeyValue
  // can be back-dated, a row key cannot.
  long ttlToUse = scanInfo.getMinVersions() > 0 ? Long.MAX_VALUE : this.scanInfo.getTtl();

  KeyValue kv = new KeyValue(row, HConstants.LATEST_TIMESTAMP);

  GetClosestRowBeforeTracker state = new GetClosestRowBeforeTracker(this.comparator, kv, ttlToUse,
      this.getRegionInfo().isMetaRegion());
  this.lock.readLock().lock();
  try {
    // First go to the memstore. Pick up deletes and candidates.
    this.memstore.getRowKeyAtOrBefore(state);
    // Check if match, if we got a candidate on the asked for 'kv' row.
    // Process each relevant store file. Run through from newest to oldest.
    Iterator<StoreFile> sfIterator = this.storeEngine.getStoreFileManager()
        .getCandidateFilesForRowKeyBefore(state.getTargetKey());
    while (sfIterator.hasNext()) {
      StoreFile sf = sfIterator.next();
      sfIterator.remove(); // Remove sf from iterator.
      boolean haveNewCandidate = rowAtOrBeforeFromStoreFile(sf, state);
      Cell candidate = state.getCandidate();
      // we have an optimization here which stops the search if we find exact
      // match.
      if (candidate != null && CellUtil.matchingRow(candidate, row)) {
        return candidate;
      }
      if (haveNewCandidate) {
        sfIterator = this.storeEngine.getStoreFileManager()
            .updateCandidateFilesForRowKeyBefore(sfIterator, state.getTargetKey(), candidate);
      }
    }
    return state.getCandidate();
  } finally {
    this.lock.readLock().unlock();
  }
}
 

@Test
public void testCellWithTag() throws IOException {
  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  CountingOutputStream cos = new CountingOutputStream(baos);
  DataOutputStream dos = new DataOutputStream(cos);
  Codec codec = new CellCodecWithTags();
  Codec.Encoder encoder = codec.getEncoder(dos);
  final Cell cell1 = new KeyValue(Bytes.toBytes("r"), Bytes.toBytes("f"), Bytes.toBytes("1"),
      HConstants.LATEST_TIMESTAMP, Bytes.toBytes("1"), new Tag[] {
          new Tag((byte) 1, Bytes.toBytes("teststring1")),
          new Tag((byte) 2, Bytes.toBytes("teststring2")) });
  final Cell cell2 = new KeyValue(Bytes.toBytes("r"), Bytes.toBytes("f"), Bytes.toBytes("2"),
      HConstants.LATEST_TIMESTAMP, Bytes.toBytes("2"), new Tag[] { new Tag((byte) 1,
          Bytes.toBytes("teststring3")), });
  final Cell cell3 = new KeyValue(Bytes.toBytes("r"), Bytes.toBytes("f"), Bytes.toBytes("3"),
      HConstants.LATEST_TIMESTAMP, Bytes.toBytes("3"), new Tag[] {
          new Tag((byte) 2, Bytes.toBytes("teststring4")),
          new Tag((byte) 2, Bytes.toBytes("teststring5")),
          new Tag((byte) 1, Bytes.toBytes("teststring6")) });

  encoder.write(cell1);
  encoder.write(cell2);
  encoder.write(cell3);
  encoder.flush();
  dos.close();
  long offset = cos.getCount();
  CountingInputStream cis = new CountingInputStream(new ByteArrayInputStream(baos.toByteArray()));
  DataInputStream dis = new DataInputStream(cis);
  Codec.Decoder decoder = codec.getDecoder(dis);
  assertTrue(decoder.advance());
  Cell c = decoder.current();
  assertTrue(CellComparator.equals(c, cell1));
  List<Tag> tags = Tag.asList(c.getTagsArray(), c.getTagsOffset(), c.getTagsLength());
  assertEquals(2, tags.size());
  Tag tag = tags.get(0);
  assertEquals(1, tag.getType());
  assertTrue(Bytes.equals(Bytes.toBytes("teststring1"), tag.getValue()));
  tag = tags.get(1);
  assertEquals(2, tag.getType());
  assertTrue(Bytes.equals(Bytes.toBytes("teststring2"), tag.getValue()));
  assertTrue(decoder.advance());
  c = decoder.current();
  assertTrue(CellComparator.equals(c, cell2));
  tags = Tag.asList(c.getTagsArray(), c.getTagsOffset(), c.getTagsLength());
  assertEquals(1, tags.size());
  tag = tags.get(0);
  assertEquals(1, tag.getType());
  assertTrue(Bytes.equals(Bytes.toBytes("teststring3"), tag.getValue()));
  assertTrue(decoder.advance());
  c = decoder.current();
  assertTrue(CellComparator.equals(c, cell3));
  tags = Tag.asList(c.getTagsArray(), c.getTagsOffset(), c.getTagsLength());
  assertEquals(3, tags.size());
  tag = tags.get(0);
  assertEquals(2, tag.getType());
  assertTrue(Bytes.equals(Bytes.toBytes("teststring4"), tag.getValue()));
  tag = tags.get(1);
  assertEquals(2, tag.getType());
  assertTrue(Bytes.equals(Bytes.toBytes("teststring5"), tag.getValue()));
  tag = tags.get(2);
  assertEquals(1, tag.getType());
  assertTrue(Bytes.equals(Bytes.toBytes("teststring6"), tag.getValue()));
  assertFalse(decoder.advance());
  dis.close();
  assertEquals(offset, cis.getCount());
}
 

@Test
public void testKeyValueWithTag() throws IOException {
  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  CountingOutputStream cos = new CountingOutputStream(baos);
  DataOutputStream dos = new DataOutputStream(cos);
  Codec codec = new KeyValueCodecWithTags();
  Codec.Encoder encoder = codec.getEncoder(dos);
  final KeyValue kv1 = new KeyValue(Bytes.toBytes("r"), Bytes.toBytes("f"), Bytes.toBytes("1"),
      HConstants.LATEST_TIMESTAMP, Bytes.toBytes("1"), new Tag[] {
          new Tag((byte) 1, Bytes.toBytes("teststring1")),
          new Tag((byte) 2, Bytes.toBytes("teststring2")) });
  final KeyValue kv2 = new KeyValue(Bytes.toBytes("r"), Bytes.toBytes("f"), Bytes.toBytes("2"),
      HConstants.LATEST_TIMESTAMP, Bytes.toBytes("2"), new Tag[] { new Tag((byte) 1,
          Bytes.toBytes("teststring3")), });
  final KeyValue kv3 = new KeyValue(Bytes.toBytes("r"), Bytes.toBytes("f"), Bytes.toBytes("3"),
      HConstants.LATEST_TIMESTAMP, Bytes.toBytes("3"), new Tag[] {
          new Tag((byte) 2, Bytes.toBytes("teststring4")),
          new Tag((byte) 2, Bytes.toBytes("teststring5")),
          new Tag((byte) 1, Bytes.toBytes("teststring6")) });

  encoder.write(kv1);
  encoder.write(kv2);
  encoder.write(kv3);
  encoder.flush();
  dos.close();
  long offset = cos.getCount();
  CountingInputStream cis = new CountingInputStream(new ByteArrayInputStream(baos.toByteArray()));
  DataInputStream dis = new DataInputStream(cis);
  Codec.Decoder decoder = codec.getDecoder(dis);
  assertTrue(decoder.advance());
  Cell c = decoder.current();
  assertTrue(CellComparator.equals(c, kv1));
  List<Tag> tags = Tag.asList(c.getTagsArray(), c.getTagsOffset(), c.getTagsLength());
  assertEquals(2, tags.size());
  Tag tag = tags.get(0);
  assertEquals(1, tag.getType());
  assertTrue(Bytes.equals(Bytes.toBytes("teststring1"), tag.getValue()));
  tag = tags.get(1);
  assertEquals(2, tag.getType());
  assertTrue(Bytes.equals(Bytes.toBytes("teststring2"), tag.getValue()));
  assertTrue(decoder.advance());
  c = decoder.current();
  assertTrue(CellComparator.equals(c, kv2));
  tags = Tag.asList(c.getTagsArray(), c.getTagsOffset(), c.getTagsLength());
  assertEquals(1, tags.size());
  tag = tags.get(0);
  assertEquals(1, tag.getType());
  assertTrue(Bytes.equals(Bytes.toBytes("teststring3"), tag.getValue()));
  assertTrue(decoder.advance());
  c = decoder.current();
  assertTrue(CellComparator.equals(c, kv3));
  tags = Tag.asList(c.getTagsArray(), c.getTagsOffset(), c.getTagsLength());
  assertEquals(3, tags.size());
  tag = tags.get(0);
  assertEquals(2, tag.getType());
  assertTrue(Bytes.equals(Bytes.toBytes("teststring4"), tag.getValue()));
  tag = tags.get(1);
  assertEquals(2, tag.getType());
  assertTrue(Bytes.equals(Bytes.toBytes("teststring5"), tag.getValue()));
  tag = tags.get(2);
  assertEquals(1, tag.getType());
  assertTrue(Bytes.equals(Bytes.toBytes("teststring6"), tag.getValue()));
  assertFalse(decoder.advance());
  dis.close();
  assertEquals(offset, cis.getCount());
}
 

private byte[] getSomeKey(int rowId) {
  KeyValue kv = new KeyValue(String.format(localFormatter, Integer.valueOf(rowId)).getBytes(),
      Bytes.toBytes("family"), Bytes.toBytes("qual"), HConstants.LATEST_TIMESTAMP, Type.Put);
  return kv.getKey();
}
 

Response updateBinary(final byte[] message, final HttpHeaders headers,
    final boolean replace) {
  servlet.getMetrics().incrementRequests(1);
  if (servlet.isReadOnly()) {
    servlet.getMetrics().incrementFailedPutRequests(1);
    return Response.status(Response.Status.FORBIDDEN)
      .type(MIMETYPE_TEXT).entity("Forbidden" + CRLF)
      .build();
  }
  Table table = null;
  try {
    byte[] row = rowspec.getRow();
    byte[][] columns = rowspec.getColumns();
    byte[] column = null;
    if (columns != null) {
      column = columns[0];
    }
    long timestamp = HConstants.LATEST_TIMESTAMP;
    List<String> vals = headers.getRequestHeader("X-Row");
    if (vals != null && !vals.isEmpty()) {
      row = Bytes.toBytes(vals.get(0));
    }
    vals = headers.getRequestHeader("X-Column");
    if (vals != null && !vals.isEmpty()) {
      column = Bytes.toBytes(vals.get(0));
    }
    vals = headers.getRequestHeader("X-Timestamp");
    if (vals != null && !vals.isEmpty()) {
      timestamp = Long.valueOf(vals.get(0));
    }
    if (column == null) {
      servlet.getMetrics().incrementFailedPutRequests(1);
      return Response.status(Response.Status.BAD_REQUEST)
          .type(MIMETYPE_TEXT).entity("Bad request: Column found to be null." + CRLF)
          .build();
    }
    Put put = new Put(row);
    byte parts[][] = KeyValue.parseColumn(column);
    if (parts.length != 2) {
      return Response.status(Response.Status.BAD_REQUEST)
        .type(MIMETYPE_TEXT).entity("Bad request" + CRLF)
        .build();
    }
    put.addImmutable(parts[0], parts[1], timestamp, message);
    table = servlet.getTable(tableResource.getName());
    table.put(put);
    if (LOG.isDebugEnabled()) {
      LOG.debug("PUT " + put.toString());
    }
    servlet.getMetrics().incrementSucessfulPutRequests(1);
    return Response.ok().build();
  } catch (Exception e) {
    servlet.getMetrics().incrementFailedPutRequests(1);
    return processException(e);
  } finally {
    if (table != null) try {
      table.close();
    } catch (IOException ioe) {
      LOG.debug(ioe);
    }
  }
}
 

/**
 * Create a Delete operation for the specified row and timestamp.<p>
 *
 * If no further operations are done, this will delete all columns in all
 * families of the specified row with a timestamp less than or equal to the
 * specified timestamp.<p>
 *
 * This timestamp is ONLY used for a delete row operation.  If specifying
 * families or columns, you must specify each timestamp individually.
 * @param rowArray We make a local copy of this passed in row.
 * @param rowOffset
 * @param rowLength
 */
public Delete(final byte [] rowArray, final int rowOffset, final int rowLength) {
  this(rowArray, rowOffset, rowLength, HConstants.LATEST_TIMESTAMP);
}
 

/**
 * Constructor
 * @param column
 * @param qualifier
 * @param value
 */
public CellModel(byte[] column, byte[] qualifier, byte[] value) {
  this(column, qualifier, HConstants.LATEST_TIMESTAMP, value);
}