Exemplo n.º 1
0
  @TimeDepend
  @Test
  public void testGetWith_Ts() throws Exception {
    recreateTable();
    fillData();

    Get get = new Get(rowKey_ForTest);
    get.addColumn(ColumnFamilyNameBytes, QName1);
    get.setMaxVersions(3);

    get.setTimeStamp(3L);
    Result result = table.get(get);
    Assert.assertEquals(1, result.raw().length);

    get.setTimeStamp(2L);
    result = table.get(get);
    Assert.assertEquals(1, result.raw().length);

    get.setTimeStamp(1L);
    result = table.get(get);
    Assert.assertEquals(1, result.raw().length);

    get.setTimeStamp(0L);
    result = table.get(get);
    Assert.assertEquals(0, result.raw().length);

    get.setTimeRange(1, 4);
    result = table.get(get);
    Assert.assertEquals(3, result.raw().length);

    recreateTable();
  }
Exemplo n.º 2
0
  public static String get(String keyspace, String rowKey, String column, long timestamp)
      throws Exception {
    String columnValue = null;

    HTable htable = new HTable(keyspace);
    Get get = new Get(rowKey.getBytes());
    get = get.setTimeStamp(timestamp);
    get = get.setMaxVersions();

    Result res = htable.get(get);

    KeyValue[] data = res.raw();

    for (int i = 0; i < data.length; i++) {
      KeyValue d = data[i];
      String family = new String(data[i].getFamily());
      String qualifier = new String(data[i].getQualifier());
      if (qualifier.toLowerCase().equals(column.toLowerCase())) {
        columnValue = new String(d.getValue());
        System.out.println(
            data[i].toString()
                + " Family:"
                + family
                + " Qualifier:"
                + qualifier
                + " Value:"
                + columnValue);
        break;
      }
    }

    return columnValue;
  }
  public static List<String> getFreeBooks() throws IOException {

    List list = new ArrayList<String>();
    Scan scan = new Scan();
    scan.setMaxVersions();
    Filter filter =
        new SingleColumnValueFilter(
            Bytes.toBytes("statics"),
            Bytes.toBytes("price"),
            CompareOp.EQUAL,
            Bytes.toBytes("0.00"));
    scan.setFilter(filter);
    ResultScanner rs = table.getScanner(scan);
    for (Result r : rs) {
      String str = "title: " + Bytes.toString(r.getRow());
      for (KeyValue kv : r.raw()) {

        str = str + " " + Bytes.toString(kv.getQualifier()) + ": ";
        str += Bytes.toString(kv.getValue());
      }
      /*
       * for (KeyValue kv : r.raw()) { System.out.println(String.format(
       * "row:%s, family:%s, qualifier:%s, qualifiervalue:%s, timestamp:%s."
       * , Bytes.toString(kv.getRow()), Bytes.toString(kv.getFamily()),
       * Bytes.toString(kv.getQualifier()), Bytes.toString(kv.getValue()),
       * kv.getTimestamp())); }
       */
      System.out.println(str);
      list.add(str);
    }
    return list;
  }
Exemplo n.º 4
0
 /**
  * make a general method that takes a pair of lat/lon and a radius and give a boolean whether it
  * was in or out.
  *
  * @throws IOException
  */
 @Override
 public Map<String, Integer> getAvailableBikesFromAPoint(
     double lat, double lon, double radius, Get get) throws IOException {
   Result r = ((RegionCoprocessorEnvironment) getEnvironment()).getRegion().get(get, null);
   log.debug("r is " + r);
   log.debug(r.getMap().toString());
   Map<String, Integer> result = new HashMap<String, Integer>();
   try {
     String s = null, latStr = null, lonStr = null;
     for (KeyValue kv : r.raw()) {
       s = Bytes.toString(kv.getValue());
       log.debug("cell value is: " + s);
       String[] sArr = s.split(BIXI_DELIMITER); // array of key=value pairs
       latStr = sArr[3];
       lonStr = sArr[4];
       latStr = latStr.substring(latStr.indexOf("=") + 1);
       lonStr = lonStr.substring(lonStr.indexOf("=") + 1);
       log.debug("lon/lat values are: " + lonStr + "; " + latStr);
       double distance =
           giveDistance(Double.parseDouble(latStr), Double.parseDouble(lonStr), lat, lon) - radius;
       log.debug("distance is : " + distance);
       if (distance < 0) { // add it
         result.put(sArr[0], getFreeBikes(kv));
       }
     }
   } finally {
   }
   return result;
 }
Exemplo n.º 5
0
  public static void main(String[] args) {
    Integer id = Integer.parseInt(args[0]);
    System.out.println(id);
    byte[] k = new byte[5];
    k[0] = (byte) 1;
    byte[] col = getColIdbyte(id);

    for (int i = 0; i < 4; i++) {
      k[i + 1] = col[i];
    }
    System.out.println(Bytes.toStringBinary(k));

    Get get = new Get(k);
    // get.addColumn(Bytes.toBytes("A:i"));
    HTable table;
    try {
      table = new HTable(hconf, "new");
      Result result = table.get(get);
      KeyValue[] g = result.raw();
      System.out.println("dfgsdfgsdfgsdfgsdfffffffffffffffffffffffffffffffffff");
      System.out.println("dfgsdfgsdfgsdfgsdfffffffffffffffffffffffffffffffffff");
      System.out.println("dfgsdfgsdfgsdfgsdfffffffffffffffffffffffffffffffffff");
      System.out.println("dfgsdfgsdfgsdfgsdfffffffffffffffffffffffffffffffffff");
      System.out.println("dfgsdfgsdfgsdfgsdfffffffffffffffffffffffffffffffffff");
      System.out.println("dfgsdfgsdfgsdfgsdfffffffffffffffffffffffffffffffffff");
      for (int i = 0; i < g.length; i++) {
        System.out.println(Bytes.toStringBinary(g[i].getValue()) + " kkkkkkkkkkkkkkkkkkkkkkk");
      }
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
  public static List<String> getBooksbyPrice(String min, String max) throws IOException {

    List list = new ArrayList<String>();
    Scan scan = new Scan();
    scan.setMaxVersions();

    FilterList filterList = new FilterList();
    Filter maxFilter =
        new SingleColumnValueFilter(
            Bytes.toBytes("statics"),
            Bytes.toBytes("price"),
            CompareOp.GREATER_OR_EQUAL,
            Bytes.toBytes(min));
    Filter minFilter =
        new SingleColumnValueFilter(
            Bytes.toBytes("statics"),
            Bytes.toBytes("price"),
            CompareOp.LESS_OR_EQUAL,
            Bytes.toBytes(max));
    filterList.addFilter(maxFilter);
    filterList.addFilter(minFilter);
    scan.setFilter(filterList);
    ResultScanner rs = table.getScanner(scan);
    for (Result r : rs) {
      String str = "title: " + Bytes.toString(r.getRow());
      for (KeyValue kv : r.raw()) {

        str = str + " " + Bytes.toString(kv.getQualifier()) + ": ";
        str += Bytes.toString(kv.getValue());
      }
      System.out.println(str);
      list.add(str);
    }
    return list;
  }
Exemplo n.º 7
0
 public static HBaseTuple getHBaseTuple(Result result) {
   HBaseTuple tuple = null;
   KeyValue[] kvs = result.raw();
   for (KeyValue kv : kvs) {
     tuple = getHBaseTuple(kv);
     break;
   }
   return tuple;
 }
Exemplo n.º 8
0
  private static void assertGet(byte[] row, byte[] familiy, byte[] qualifier, byte[] value)
      throws IOException {
    // run a get and see if the value matches
    Get get = new Get(row);
    get.addColumn(familiy, qualifier);
    Result result = region.get(get, null);
    assertEquals(1, result.size());

    KeyValue kv = result.raw()[0];
    byte[] r = kv.getValue();
    assertTrue(Bytes.compareTo(r, value) == 0);
  }
Exemplo n.º 9
0
  /**
   * Read a record from the database. Each field/value pair from the result will be stored in a
   * HashMap.
   *
   * @param table The name of the table
   * @param key The record key of the record to read.
   * @param fields The list of fields to read, or null for all of them
   * @param result A HashMap of field/value pairs for the result
   * @return Zero on success, a non-zero error code on error
   */
  public int read(
      String table, String key, Set<String> fields, HashMap<String, ByteIterator> result) {
    // if this is a "new" table, init HTable object.  Else, use existing one
    if (!_table.equals(table)) {
      _hTable = null;
      try {
        getHTable(table);
        _table = table;
      } catch (IOException e) {
        System.err.println("Error accessing HBase table: " + e);
        return ServerError;
      }
    }

    Result r = null;
    try {
      if (_debug) {
        System.out.println("Doing read from HBase columnfamily " + _columnFamily);
        System.out.println("Doing read for key: " + key);
      }
      Get g = new Get(Bytes.toBytes(key));
      if (fields == null) {
        g.addFamily(_columnFamilyBytes);
      } else {
        for (String field : fields) {
          g.addColumn(_columnFamilyBytes, Bytes.toBytes(field));
        }
      }
      r = _hTable.get(g);
    } catch (IOException e) {
      System.err.println("Error doing get: " + e);
      return ServerError;
    } catch (ConcurrentModificationException e) {
      // do nothing for now...need to understand HBase concurrency model better
      return ServerError;
    }

    for (KeyValue kv : r.raw()) {
      result.put(Bytes.toString(kv.getQualifier()), new ByteArrayByteIterator(kv.getValue()));
      if (_debug) {
        System.out.println(
            "Result for field: "
                + Bytes.toString(kv.getQualifier())
                + " is: "
                + Bytes.toString(kv.getValue()));
      }
    }
    return Ok;
  }
Exemplo n.º 10
0
  public static void main(String[] args) throws IOException, SolrServerException {

    final Configuration conf;
    HttpSolrServer solrServer = new HttpSolrServer("http://c1master:8983/solr");
    conf = HBaseConfiguration.create();

    // Define Hbase Table Name
    HTable table = new HTable(conf, "test_global_shop");
    Scan scan = new Scan();

    // Define Hbase Column Family
    scan.addFamily(Bytes.toBytes("shop"));
    scan.setCaching(1000);
    scan.setCacheBlocks(false);
    ResultScanner ss = table.getScanner(scan);

    System.out.println("start Storing...");
    int i = 0;
    try {
      for (Result r : ss) {
        SolrInputDocument solrDoc = new SolrInputDocument();
        solrDoc.addField("key", new String(r.getRow()));
        for (KeyValue kv : r.raw()) {
          String fieldName = new String(kv.getQualifier());
          String fieldValue = new String(kv.getValue());
          if (fieldName.equalsIgnoreCase("address")
              || fieldName.equalsIgnoreCase("category")
              || fieldName.equalsIgnoreCase("name")
              || fieldName.equalsIgnoreCase("province")
              || fieldName.equalsIgnoreCase("tel")) {
            solrDoc.addField(fieldName, fieldValue);
          }
        }
        solrServer.add(solrDoc);
        solrServer.commit(true, true, true);
        i = i + 1;
        System.out.println("Already Succcess " + i + " number data");
      }
      ss.close();
      table.close();
      System.out.println("done !");
    } catch (IOException e) {
    } finally {
      ss.close();
      table.close();
      System.out.println("error !");
    }
  }
Exemplo n.º 11
0
 public static String selectRowKey(String rowKey, int tableNum) throws IOException {
   Get g = new Get(rowKey.getBytes());
   Result rs = htable[tableNum].get(g);
   String result = "";
   for (KeyValue kv : rs.raw()) {
     if (new String(kv.getQualifier()).equals("text")) {
       result +=
           new String(kv.getValue())
                   .replace("\\n", "\n")
                   .replace("\\t", "\t")
                   .replace("\\r", "\r")
                   .replace("\\\\", "\\")
               + "\n";
     }
   }
   return result;
 }
    @Override
    public void map(ImmutableBytesWritable row, Result value, Context context)
        throws InterruptedException, IOException {

      KeyValue[] kvs = value.raw();

      if (lastRowKey == null) {
        lastRowKey = row.get();
      } else if (Bytes.compareTo(lastRowKey, row.get()) != 0) {
        writeLine(context, Bytes.toString(lastRowKey));
        columnValueMap.clear();
      }
      for (KeyValue kv : kvs) {
        String qualifier = Bytes.toString(kv.getQualifier());
        byte[] val = kv.getValue();
        columnValueMap.put(qualifier, val);
      }
    }
Exemplo n.º 13
0
  @TimeDepend
  @Test
  public void testPutMultiVersionSameTime() throws Exception {
    recreateTable();

    Put put = new Put(rowKey_ForTest);
    put.add(ColumnFamilyNameBytes, QName1, 1000, Bytes.toBytes("a"));
    put.add(ColumnFamilyNameBytes, QName1, 2000, Bytes.toBytes("b"));
    table.put(put);

    Get get = new Get(rowKey_ForTest);
    get.setMaxVersions(10);
    Result result = table.get(get);
    KeyValue[] keyValues = result.raw();
    Assert.assertEquals(2, keyValues.length);
    // have a and b both.
    Assert.assertEquals('a' + 'b', keyValues[0].getValue()[0] + keyValues[1].getValue()[0]);

    recreateTable();
  }
 public static PlaceModel Map(Result r) {
   PlaceModel place = new PlaceModel();
   place.rowkey = UUID.fromString(new String(r.getRow()));
   for (KeyValue keyValue : r.raw()) {
     if (new String(keyValue.getFamily()).compareTo(Constants.PLACE_INFO_FAMILYCOLUMNNAME) == 0)
       place.Info.put(new String(keyValue.getQualifier()), new String(keyValue.getValue()));
     else if (new String(keyValue.getFamily()).compareTo(Constants.PLACE_LOCATION_FAMILYCOLUMNNAME)
         == 0)
       place.Location.put(new String(keyValue.getQualifier()), new String(keyValue.getValue()));
     else if (new String(keyValue.getFamily())
             .compareTo(Constants.PLACE_OPENINGHOURS_FAMILYCOLUMNNAME)
         == 0)
       place.OpeningHours.put(
           new String(keyValue.getQualifier()), new String(keyValue.getValue()));
     else if (new String(keyValue.getFamily()).compareTo(Constants.PLACE_OTHERS_FAMILYCOLUMNNAME)
         == 0)
       place.OpeningHours.put(
           new String(keyValue.getQualifier()), new String(keyValue.getValue()));
   }
   return place;
 }
Exemplo n.º 15
0
 public void dump(String table, String[] rows, String[] fams, String[] quals) throws IOException {
   HTable tbl = new HTable(conf, table);
   List<Get> gets = new ArrayList<Get>();
   for (String row : rows) {
     Get get = new Get(Bytes.toBytes(row));
     get.setMaxVersions();
     if (fams != null) {
       for (String fam : fams) {
         for (String qual : quals) {
           get.addColumn(Bytes.toBytes(fam), Bytes.toBytes(qual));
         }
       }
     }
     gets.add(get);
   }
   Result[] results = tbl.get(gets);
   for (Result result : results) {
     for (KeyValue kv : result.raw()) {
       System.out.println("KV: " + kv + ", Value: " + Bytes.toString(kv.getValue()));
     }
   }
 }
Exemplo n.º 16
0
  /**
   * Perform a range scan for a set of records in the database. Each field/value pair from the
   * result will be stored in a HashMap.
   *
   * @param table The name of the table
   * @param startkey The record key of the first record to read.
   * @param recordcount The number of records to read
   * @param fields The list of fields to read, or null for all of them
   * @param result A Vector of HashMaps, where each HashMap is a set field/value pairs for one
   *     record
   * @return Zero on success, a non-zero error code on error
   */
  public int scan(
      String table,
      String startkey,
      int recordcount,
      Set<String> fields,
      Vector<HashMap<String, ByteIterator>> result) {
    // if this is a "new" table, init HTable object.  Else, use existing one
    if (!_table.equals(table)) {
      _hTable = null;
      try {
        getHTable(table);
        _table = table;
      } catch (IOException e) {
        System.err.println("Error accessing HBase table: " + e);
        return ServerError;
      }
    }

    Scan s = new Scan(Bytes.toBytes(startkey));
    // HBase has no record limit.  Here, assume recordcount is small enough to bring back in one
    // call.
    // We get back recordcount records
    s.setCaching(recordcount);

    // add specified fields or else all fields
    if (fields == null) {
      s.addFamily(_columnFamilyBytes);
    } else {
      for (String field : fields) {
        s.addColumn(_columnFamilyBytes, Bytes.toBytes(field));
      }
    }

    // get results
    ResultScanner scanner = null;
    try {
      scanner = _hTable.getScanner(s);
      int numResults = 0;
      for (Result rr = scanner.next(); rr != null; rr = scanner.next()) {
        // get row key
        String key = Bytes.toString(rr.getRow());
        if (_debug) {
          System.out.println("Got scan result for key: " + key);
        }

        HashMap<String, ByteIterator> rowResult = new HashMap<String, ByteIterator>();

        for (KeyValue kv : rr.raw()) {
          rowResult.put(
              Bytes.toString(kv.getQualifier()), new ByteArrayByteIterator(kv.getValue()));
        }
        // add rowResult to result vector
        result.add(rowResult);
        numResults++;
        if (numResults >= recordcount) // if hit recordcount, bail out
        {
          break;
        }
      } // done with row

    } catch (IOException e) {
      if (_debug) {
        System.out.println("Error in getting/parsing scan result: " + e);
      }
      return ServerError;
    } finally {
      scanner.close();
    }

    return Ok;
  }
Exemplo n.º 17
0
  /** @param args */
  public static void main(String[] args) throws Exception {

    // Configuration conf = HBaseConfiguration.create();
    // change here if you want to change the HBase installation.
    // conf.set("hbase.master", "localhost:60000");

    Configuration config = HBaseConfiguration.create();
    // config.set("hbase.master", "localhost:60020");
    HTable table = new HTable(config, TABLE_NAME);

    // Change here if you want to change the input file.
    BufferedReader reader =
        new BufferedReader(new FileReader("/home/cloudera/ebooks/Hbase/hdi-data.csv"));

    try {
      String line = null;
      // skip first line
      reader.readLine();
      while ((line = reader.readLine()) != null) {
        try {

          String[] tokens = CSVLineParser.tokenizeCSV(line).toArray(new String[0]);
          String country = tokens[1];
          double lifeExpectacny = Double.parseDouble(tokens[3].replaceAll(",", ""));
          double meanYearsOfSchooling = Double.parseDouble(tokens[4].replaceAll(",", ""));
          double gnip = Double.parseDouble(tokens[6].replaceAll(",", ""));

          Put put = new Put(Bytes.toBytes(country));
          put.add(
              "ByCountry".getBytes(),
              Bytes.toBytes("lifeExpectacny"),
              Bytes.toBytes(lifeExpectacny));
          put.add(
              "ByCountry".getBytes(),
              Bytes.toBytes("meanYearsOfSchooling"),
              Bytes.toBytes(meanYearsOfSchooling));
          put.add("ByCountry".getBytes(), Bytes.toBytes("gnip"), Bytes.toBytes(gnip));
          table.put(put);
        } catch (Exception e) {
          e.printStackTrace();
          System.out.println("Error processing " + line + " caused by " + e.getMessage());
        }
      }
    } catch (IOException e) {
      try {
        reader.close();
      } catch (IOException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
      }
    }

    // Following print back the results
    Scan s = new Scan();
    s.addFamily(Bytes.toBytes("ByCountry"));
    ResultScanner results = table.getScanner(s);

    try {
      for (Result result : results) {
        KeyValue[] keyValuePairs = result.raw();
        System.out.println(new String(result.getRow()));
        for (KeyValue keyValue : keyValuePairs) {
          System.out.println(
              new String(keyValue.getFamily())
                  + " "
                  + new String(keyValue.getQualifier())
                  + "="
                  + Bytes.toDouble(keyValue.getValue()));
        }
      }
    } finally {
      results.close();
    }
  }
Exemplo n.º 18
0
  /**
   * Override the preAppend for checkAndPut and checkAndDelete, as we need the ability to a) set the
   * TimeRange for the Get being done and b) return something back to the client to indicate
   * success/failure
   */
  @SuppressWarnings("deprecation")
  @Override
  public Result preAppend(
      final ObserverContext<RegionCoprocessorEnvironment> e, final Append append)
      throws IOException {
    byte[] opBuf = append.getAttribute(OPERATION_ATTRIB);
    if (opBuf == null) {
      return null;
    }
    Op op = Op.values()[opBuf[0]];

    long clientTimestamp = HConstants.LATEST_TIMESTAMP;
    byte[] clientTimestampBuf = append.getAttribute(MAX_TIMERANGE_ATTRIB);
    if (clientTimestampBuf != null) {
      clientTimestamp = Bytes.toLong(clientTimestampBuf);
    }
    boolean hadClientTimestamp = (clientTimestamp != HConstants.LATEST_TIMESTAMP);
    if (hadClientTimestamp) {
      // Prevent race condition of creating two sequences at the same timestamp
      // by looking for a sequence at or after the timestamp at which it'll be
      // created.
      if (op == Op.CREATE_SEQUENCE) {
        clientTimestamp++;
      }
    } else {
      clientTimestamp = EnvironmentEdgeManager.currentTimeMillis();
      clientTimestampBuf = Bytes.toBytes(clientTimestamp);
    }

    RegionCoprocessorEnvironment env = e.getEnvironment();
    // We need to set this to prevent region.append from being called
    e.bypass();
    e.complete();
    HRegion region = env.getRegion();
    byte[] row = append.getRow();
    region.startRegionOperation();
    try {
      Integer lid = region.getLock(null, row, true);
      try {
        KeyValue keyValue = append.getFamilyMap().values().iterator().next().iterator().next();
        byte[] family = keyValue.getFamily();
        byte[] qualifier = keyValue.getQualifier();

        Get get = new Get(row);
        get.setTimeRange(MetaDataProtocol.MIN_TABLE_TIMESTAMP, clientTimestamp);
        get.addColumn(family, qualifier);
        Result result = region.get(get);
        if (result.isEmpty()) {
          if (op == Op.DROP_SEQUENCE || op == Op.RESET_SEQUENCE) {
            return getErrorResult(
                row, clientTimestamp, SQLExceptionCode.SEQUENCE_UNDEFINED.getErrorCode());
          }
        } else {
          if (op == Op.CREATE_SEQUENCE) {
            return getErrorResult(
                row, clientTimestamp, SQLExceptionCode.SEQUENCE_ALREADY_EXIST.getErrorCode());
          }
        }
        Mutation m = null;
        switch (op) {
          case RESET_SEQUENCE:
            KeyValue currentValueKV = result.raw()[0];
            long expectedValue =
                PDataType.LONG
                    .getCodec()
                    .decodeLong(append.getAttribute(CURRENT_VALUE_ATTRIB), 0, null);
            long value =
                PDataType.LONG
                    .getCodec()
                    .decodeLong(currentValueKV.getBuffer(), currentValueKV.getValueOffset(), null);
            // Timestamp should match exactly, or we may have the wrong sequence
            if (expectedValue != value || currentValueKV.getTimestamp() != clientTimestamp) {
              return new Result(
                  Collections.singletonList(
                      KeyValueUtil.newKeyValue(
                          row,
                          PhoenixDatabaseMetaData.SEQUENCE_FAMILY_BYTES,
                          QueryConstants.EMPTY_COLUMN_BYTES,
                          currentValueKV.getTimestamp(),
                          ByteUtil.EMPTY_BYTE_ARRAY)));
            }
            m = new Put(row, currentValueKV.getTimestamp());
            m.getFamilyMap().putAll(append.getFamilyMap());
            break;
          case DROP_SEQUENCE:
            m = new Delete(row, clientTimestamp, null);
            break;
          case CREATE_SEQUENCE:
            m = new Put(row, clientTimestamp);
            m.getFamilyMap().putAll(append.getFamilyMap());
            break;
        }
        if (!hadClientTimestamp) {
          for (List<KeyValue> kvs : m.getFamilyMap().values()) {
            for (KeyValue kv : kvs) {
              kv.updateLatestStamp(clientTimestampBuf);
            }
          }
        }
        @SuppressWarnings("unchecked")
        Pair<Mutation, Integer>[] mutations = new Pair[1];
        mutations[0] = new Pair<Mutation, Integer>(m, lid);
        region.batchMutate(mutations);
        long serverTimestamp = MetaDataUtil.getClientTimeStamp(m);
        // Return result with single KeyValue. The only piece of information
        // the client cares about is the timestamp, which is the timestamp of
        // when the mutation was actually performed (useful in the case of .
        return new Result(
            Collections.singletonList(
                KeyValueUtil.newKeyValue(
                    row,
                    PhoenixDatabaseMetaData.SEQUENCE_FAMILY_BYTES,
                    QueryConstants.EMPTY_COLUMN_BYTES,
                    serverTimestamp,
                    SUCCESS_VALUE)));
      } finally {
        region.releaseRowLock(lid);
      }
    } catch (Throwable t) {
      ServerUtil.throwIOException("Increment of sequence " + Bytes.toStringBinary(row), t);
      return null; // Impossible
    } finally {
      region.closeRegionOperation();
    }
  }