Example #1
0
 @Override
 public List<SpanBo> selectSpans(TransactionId transactionId) {
   if (transactionId == null) {
     throw new NullPointerException("transactionId must not be null");
   }
   byte[] transactionIdRowKey = rowKeyDecoder.encodeRowKey(transactionId);
   Get get = new Get(transactionIdRowKey);
   get.addFamily(HBaseTables.TRACES_CF_SPAN);
   get.addFamily(HBaseTables.TRACES_CF_TERMINALSPAN);
   return template2.get(HBaseTables.TRACES, get, spanMapper);
 }
Example #2
0
 @SuppressWarnings("deprecation")
 @Override
 public DResult get(Get get, long startId) throws IOException {
   if (get.hasFamilies()) get.addFamily(DominoConst.INNER_FAMILY);
   get.setTimeRange(0, startId + 1); // [x, y)
   get.setMaxVersions();
   Result preRead = region.get(get);
   List<KeyValue> status = preRead.getColumn(DominoConst.INNER_FAMILY, DominoConst.STATUS_COL);
   if (status == null || status.size() == 0) {
     Result ret = MVCC.handleResult(this, getTrxMetaTable(), preRead, startId, null);
     return new DResult(ret, null);
   }
   Integer lockId = region.getLock(null, get.getRow(), true);
   try {
     Result r =
         MVCC.handleResult(this, getTrxMetaTable(), region.get(get, lockId), startId, lockId);
     return new DResult(r, null);
   } catch (TransactionOutOfDateException oode) {
     return new DResult(null, oode.getMessage());
   } catch (InvalidRowStatusException e) {
     return new DResult(null, e.getMessage());
   } finally {
     region.releaseRowLock(lockId);
   }
 }
Example #3
0
  public List<Query> getQueries(final String creator) throws IOException {
    if (null == creator) {
      return null;
    }

    List<Query> queries = new ArrayList<Query>();
    HTableInterface htable = null;
    try {
      htable = HBaseConnection.get(hbaseUrl).getTable(userTableName);
      Get get = new Get(Bytes.toBytes(creator));
      get.addFamily(Bytes.toBytes(USER_QUERY_FAMILY));
      Result result = htable.get(get);
      Query[] query =
          querySerializer.deserialize(
              result.getValue(Bytes.toBytes(USER_QUERY_FAMILY), Bytes.toBytes(USER_QUERY_COLUMN)));

      if (null != query) {
        queries.addAll(Arrays.asList(query));
      }
    } finally {
      IOUtils.closeQuietly(htable);
    }

    return queries;
  }
  public static int getDynamicTable(Configuration config) {
    /** Connection to the cluster. A single connection shared by all application threads. */
    Connection connection = null;
    /** A lightweight handle to a specific table. Used from a single thread. */
    Table table = null;

    try {
      connection = ConnectionFactory.createConnection(config);
      table = connection.getTable(TABLE_NAME1);
      Get get = new Get(Bytes.toBytes("cloudera"));
      get.addFamily(CF);
      get.setMaxVersions(Integer.MAX_VALUE);
      Result result = table.get(get);

      NavigableMap<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> map = result.getMap();
      for (Entry<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> columnFamilyEntry :
          map.entrySet()) {
        NavigableMap<byte[], NavigableMap<Long, byte[]>> columnMap = columnFamilyEntry.getValue();
        for (Entry<byte[], NavigableMap<Long, byte[]>> columnEntry : columnMap.entrySet()) {
          NavigableMap<Long, byte[]> cellMap = columnEntry.getValue();
          for (Entry<Long, byte[]> cellEntry : cellMap.entrySet()) {
            System.out.println(
                String.format(
                    "Key : %s, Value :%s",
                    Bytes.toString(columnEntry.getKey()), Bytes.toString(cellEntry.getValue())));
          }
        }
      }
    } catch (IOException e) {
      e.printStackTrace();
    }

    return 0;
  }
Example #5
0
  @Before
  public void setUp() throws Exception {
    super.setUp();
    row1 = Bytes.toBytes("row1");
    row2 = Bytes.toBytes("row2");
    row3 = Bytes.toBytes("row3");
    fam1 = Bytes.toBytes("fam1");
    fam2 = Bytes.toBytes("fam2");
    col1 = Bytes.toBytes("col1");
    col2 = Bytes.toBytes("col2");
    col3 = Bytes.toBytes("col3");
    col4 = Bytes.toBytes("col4");
    col5 = Bytes.toBytes("col5");

    data = Bytes.toBytes("data");

    // Create Get
    get = new Get(row1);
    get.addFamily(fam1);
    get.addColumn(fam2, col2);
    get.addColumn(fam2, col4);
    get.addColumn(fam2, col5);
    this.scan = new Scan(get);

    rowComparator = CellComparator.COMPARATOR;
  }
Example #6
0
 /**
  * Gets the region info and assignment for the specified region.
  *
  * @param catalogTracker
  * @param regionName Region to lookup.
  * @return Location and HRegionInfo for <code>regionName</code>
  * @throws IOException
  */
 public static Pair<HRegionInfo, ServerName> getRegion(
     CatalogTracker catalogTracker, byte[] regionName) throws IOException {
   Get get = new Get(regionName);
   get.addFamily(HConstants.CATALOG_FAMILY);
   Result r = get(getCatalogHTable(catalogTracker, regionName), get);
   return (r == null || r.isEmpty()) ? null : parseCatalogResult(r);
 }
  public static void readTest(String tableStr, String row) {
    try {
      Configuration conf = HBaseConfiguration.create();
      byte[] tableName = Bytes.toBytes(tableStr);
      HConnection hConnection = HConnectionManager.createConnection(conf);
      HTableInterface table = hConnection.getTable(tableName);

      byte[] rowkey = Bytes.toBytes(row);
      Get get = new Get(rowkey);
      get.addFamily(f0);

      Result result = table.get(get);
      NavigableMap<byte[], byte[]> m = result.getFamilyMap(f0);

      if (m == null || m.isEmpty()) {
        System.err.println("Empty." + m);
        return;
      }

      for (Map.Entry<byte[], byte[]> entry : m.entrySet()) {
        String qualifier = Bytes.toString(entry.getKey());
        String value = Bytes.toString(entry.getValue());
        System.out.println(qualifier + ":" + value);
      }
      table.close(); // very important
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
Example #8
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 Status 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 (!tableName.equals(table)) {
      currentTable = null;
      try {
        getHTable(table);
        tableName = table;
      } catch (IOException e) {
        System.err.println("Error accessing HBase table: " + e);
        return Status.ERROR;
      }
    }

    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 = currentTable.get(g);
    } catch (IOException e) {
      if (debug) {
        System.err.println("Error doing get: " + e);
      }
      return Status.ERROR;
    } catch (ConcurrentModificationException e) {
      // do nothing for now...need to understand HBase concurrency model better
      return Status.ERROR;
    }

    if (r.isEmpty()) {
      return Status.NOT_FOUND;
    }

    while (r.advance()) {
      final Cell c = r.current();
      result.put(
          Bytes.toString(CellUtil.cloneQualifier(c)),
          new ByteArrayByteIterator(CellUtil.cloneValue(c)));
      if (debug) {
        System.out.println(
            "Result for field: "
                + Bytes.toString(CellUtil.cloneQualifier(c))
                + " is: "
                + Bytes.toString(CellUtil.cloneValue(c)));
      }
    }
    return Status.OK;
  }
Example #9
0
 public static HBaseTuple getHBaseTuple(String row, String colFamily, String colName)
     throws IOException {
   Configuration conf = getConfiguration();
   HTable table1 = new HTable(conf, "table1");
   Get get = new Get(Bytes.toBytes(row));
   get.addFamily(Bytes.toBytes(colFamily));
   get.addColumn(Bytes.toBytes(colFamily), Bytes.toBytes(colName));
   Result result = table1.get(get);
   return getHBaseTuple(result);
 }
  public static void main(String[] args) throws IOException {
    Configuration conf = HBaseConfiguration.create();

    HBaseHelper helper = HBaseHelper.getHelper(conf);
    helper.dropTable("testtable");
    helper.createTable("testtable", "colfam1", "colfam2", "colfam3", "colfam4");
    System.out.println("Adding rows to table...");
    helper.fillTable("testtable", 1, 10, 2, "colfam1", "colfam2", "colfam3", "colfam4");

    HTable table = new HTable(conf, "testtable");

    // vv FamilyFilterExample
    Filter filter1 =
        new FamilyFilter(
            CompareFilter.CompareOp
                .LESS, // co FamilyFilterExample-1-Filter Create filter, while specifying the
                       // comparison operator and comparator.
            new BinaryComparator(Bytes.toBytes("colfam3")));

    Scan scan = new Scan();
    scan.setFilter(filter1);
    ResultScanner scanner =
        table.getScanner(
            scan); // co FamilyFilterExample-2-Scan Scan over table while applying the filter.
    // ^^ FamilyFilterExample
    System.out.println("Scanning table... ");
    // vv FamilyFilterExample
    for (Result result : scanner) {
      System.out.println(result);
    }
    scanner.close();

    Get get1 = new Get(Bytes.toBytes("row-5"));
    get1.setFilter(filter1);
    Result result1 =
        table.get(get1); // co FamilyFilterExample-3-Get Get a row while applying the same filter.
    System.out.println("Result of get(): " + result1);

    Filter filter2 =
        new FamilyFilter(
            CompareFilter.CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("colfam3")));
    Get get2 =
        new Get(
            Bytes.toBytes(
                "row-5")); // co FamilyFilterExample-4-Mismatch Create a filter on one column family
                           // while trying to retrieve another.
    get2.addFamily(Bytes.toBytes("colfam1"));
    get2.setFilter(filter2);
    Result result2 =
        table.get(
            get2); // co FamilyFilterExample-5-Get2 Get the same row while applying the new filter,
                   // this will return "NONE".
    System.out.println("Result of get(): " + result2);
    // ^^ FamilyFilterExample
  }
Example #11
0
 private void addFieldsToGet(Get get, List<FieldType> fields) {
   if (fields != null && (!fields.isEmpty())) {
     for (FieldType field : fields) {
       get.addColumn(RecordCf.DATA.bytes, ((FieldTypeImpl) field).getQualifier());
     }
     RecordDecoder.addSystemColumnsToGet(get);
   } else {
     // Retrieve everything
     get.addFamily(RecordCf.DATA.bytes);
   }
 }
Example #12
0
  public static void sxr(String file) throws Exception {
    Configuration conf = HBaseConfiguration.create();
    HTablePool tablePool = new HTablePool(conf, 100);
    HTableInterface cardTable = tablePool.getTable("dis_sxbzxr_new_card");
    HTableInterface nameTable = tablePool.getTable("dis_sxbzxr_new_name");

    File f = new File(file);
    BufferedReader br = new BufferedReader(new FileReader(f));
    String line;
    String[] subs;
    String name, card;
    long cnt = 0;
    long findCard = 0;
    long findName = 0;
    while ((line = br.readLine()) != null) {
      subs = line.split(",");
      name = subs[0];
      card = subs[1];
      ++cnt;

      Get get = new Get(Bytes.toBytes(card));
      get.addFamily(Bytes.toBytes("f"));
      Result result = cardTable.get(get);
      if (!result.isEmpty()) {
        ++findCard;
        LOG.info("find card: " + card + ", line: " + cnt);
      }

      Get nGet = new Get(Bytes.toBytes(name));
      nGet.addFamily(Bytes.toBytes("f"));
      Result nResult = nameTable.get(nGet);
      if (!nResult.isEmpty()) {
        ++findName;
        LOG.info("find name: " + name);
      }
    }
    br.close();
    LOG.info("line: " + cnt + ", find card: " + findCard + ", find name: " + findName);

    cardTable.close();
  }
Example #13
0
 /**
  * HBaseのsc_item_dataから、商品データを取得。
  *
  * @param shopID 店舗ID
  * @param itemID 商品ID。
  * @param families column families
  * @return 該当商品データ
  */
 public ItemData get(int shopID, int itemID, String[] families) throws IOException {
   byte[] rowkey = encodeRowkey(shopID, itemID);
   if (rowkey == null || rowkey.length == 0) {
     return null;
   }
   Get g = new Get(rowkey);
   for (String family : families) {
     byte[] bFamily = Bytes.toBytes(family);
     g.addFamily(bFamily);
   }
   g.setMaxVersions();
   Result r = table.get(g);
   return toDataStore(r);
 }
  @Override
  public List<SqlMetaDataBo> getSqlMetaData(String agentId, long time, int hashCode) {
    if (agentId == null) {
      throw new NullPointerException("agentId must not be null");
    }

    SqlMetaDataBo sqlMetaData = new SqlMetaDataBo(agentId, time, hashCode);
    byte[] sqlId = getDistributedKey(sqlMetaData.toRowKey());

    Get get = new Get(sqlId);
    get.addFamily(HBaseTables.SQL_METADATA_CF_SQL);

    return hbaseOperations2.get(HBaseTables.SQL_METADATA, get, sqlMetaDataMapper);
  }
Example #15
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;
  }
 @Override
 public Get getGet(byte[] row) {
   Get get = new Get(row);
   for (Entry<byte[], NavigableSet<byte[]>> familyMapEntry : familyMap.entrySet()) {
     byte[] columnFamily = familyMapEntry.getKey();
     if (familyMapEntry.getValue() == null) {
       get.addFamily(columnFamily);
     } else {
       for (byte[] qualifier : familyMapEntry.getValue()) {
         get.addColumn(columnFamily, qualifier);
       }
     }
   }
   return get;
 }
  /**
   * Instantiate with {@code FieldDefinitions}s and {@code DocumentExtractDefinition}s.
   *
   * @param fieldDefinitions define fields to be indexed
   * @param documentExtractDefinitions additional document extraction definitions
   */
  public DefaultResultToSolrMapper(
      String indexerName,
      List<FieldDefinition> fieldDefinitions,
      List<DocumentExtractDefinition> documentExtractDefinitions) {
    extractors = Lists.newArrayList();
    resultDocumentExtractors = Lists.newArrayList();
    for (FieldDefinition fieldDefinition : fieldDefinitions) {
      ByteArrayExtractor byteArrayExtractor =
          ByteArrayExtractors.getExtractor(
              fieldDefinition.getValueExpression(), fieldDefinition.getValueSource());
      ByteArrayValueMapper valueMapper =
          ByteArrayValueMappers.getMapper(fieldDefinition.getTypeName());
      ConfigureUtil.configure(valueMapper, ConfigureUtil.mapToJson(fieldDefinition.getParams()));
      resultDocumentExtractors.add(
          new HBaseSolrDocumentExtractor(
              fieldDefinition.getName(), byteArrayExtractor, valueMapper));
      extractors.add(byteArrayExtractor);
    }

    for (DocumentExtractDefinition extractDefinition : documentExtractDefinitions) {
      ByteArrayExtractor byteArrayExtractor =
          ByteArrayExtractors.getExtractor(
              extractDefinition.getValueExpression(), extractDefinition.getValueSource());

      extractors.add(byteArrayExtractor);
    }

    Get get = newGet();
    for (ByteArrayExtractor extractor : extractors) {

      byte[] columnFamily = extractor.getColumnFamily();
      byte[] columnQualifier = extractor.getColumnQualifier();
      if (columnFamily != null) {
        if (columnQualifier != null) {
          get.addColumn(columnFamily, columnQualifier);
        } else {
          get.addFamily(columnFamily);
        }
      }
    }
    familyMap = get.getFamilyMap();

    mappingTimer =
        Metrics.newTimer(
            metricName(getClass(), "HBase Result to Solr mapping time", indexerName),
            TimeUnit.MILLISECONDS,
            TimeUnit.SECONDS);
  }
Example #18
0
  /**
   * Transactional version of {@link HTable#delete(Delete)}
   *
   * @param transactionState Identifier of the transaction
   * @see HTable#delete(Delete)
   * @throws IOException
   */
  public void delete(TransactionState transactionState, Delete delete) throws IOException {
    final long startTimestamp = transactionState.getStartTimestamp();
    boolean issueGet = false;

    final Put deleteP = new Put(delete.getRow(), startTimestamp);
    final Get deleteG = new Get(delete.getRow());
    Map<byte[], List<KeyValue>> fmap = delete.getFamilyMap();
    if (fmap.isEmpty()) {
      issueGet = true;
    }
    for (List<KeyValue> kvl : fmap.values()) {
      for (KeyValue kv : kvl) {
        switch (KeyValue.Type.codeToType(kv.getType())) {
          case DeleteColumn:
            deleteP.add(kv.getFamily(), kv.getQualifier(), startTimestamp, null);
            break;
          case DeleteFamily:
            deleteG.addFamily(kv.getFamily());
            issueGet = true;
            break;
          case Delete:
            if (kv.getTimestamp() == HConstants.LATEST_TIMESTAMP) {
              deleteP.add(kv.getFamily(), kv.getQualifier(), startTimestamp, null);
              break;
            } else {
              throw new UnsupportedOperationException(
                  "Cannot delete specific versions on Snapshot Isolation.");
            }
        }
      }
    }
    if (issueGet) {
      Result result = this.get(deleteG);
      for (Entry<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> entryF :
          result.getMap().entrySet()) {
        byte[] family = entryF.getKey();
        for (Entry<byte[], NavigableMap<Long, byte[]>> entryQ : entryF.getValue().entrySet()) {
          byte[] qualifier = entryQ.getKey();
          deleteP.add(family, qualifier, null);
        }
      }
    }

    transactionState.addRow(
        new RowKeyFamily(delete.getRow(), getTableName(), deleteP.getFamilyMap()));

    put(deleteP);
  }
Example #19
0
 /**
  * Transactional version of {@link HTable#get(Get)}
  *
  * @param transactionState Identifier of the transaction
  * @see HTable#get(Get)
  * @throws IOException
  */
 public Result get(TransactionState transactionState, final Get get) throws IOException {
   final long readTimestamp = transactionState.getStartTimestamp();
   final Get tsget = new Get(get.getRow());
   TimeRange timeRange = get.getTimeRange();
   long startTime = timeRange.getMin();
   long endTime = Math.min(timeRange.getMax(), readTimestamp + 1);
   //      int maxVersions = get.getMaxVersions();
   tsget
       .setTimeRange(startTime, endTime)
       .setMaxVersions((int) (versionsAvg + CACHE_VERSIONS_OVERHEAD));
   Map<byte[], NavigableSet<byte[]>> kvs = get.getFamilyMap();
   for (Map.Entry<byte[], NavigableSet<byte[]>> entry : kvs.entrySet()) {
     byte[] family = entry.getKey();
     NavigableSet<byte[]> qualifiers = entry.getValue();
     if (qualifiers == null || qualifiers.isEmpty()) {
       tsget.addFamily(family);
     } else {
       for (byte[] qualifier : qualifiers) {
         tsget.addColumn(family, qualifier);
       }
     }
   }
   //      Result result;
   //      Result filteredResult;
   //      do {
   //         result = super.get(tsget);
   //         filteredResult = filter(super.get(tsget), readTimestamp, maxVersions);
   //      } while (!result.isEmpty() && filteredResult == null);
   getsPerformed++;
   Result result =
       filter(
           transactionState,
           super.get(tsget),
           readTimestamp,
           (int) (versionsAvg + CACHE_VERSIONS_OVERHEAD));
   return result == null ? new Result() : result;
   //      Scan scan = new Scan(get);
   //      scan.setRetainDeletesInOutput(true);
   //      ResultScanner rs = this.getScanner(transactionState, scan);
   //      Result r = rs.next();
   //      if (r == null) {
   //         r = new Result();
   //      }
   //      return r;
 }
Example #20
0
 @SuppressWarnings("deprecation")
 @Override
 public void rollbackRow(byte[] row, long startId, Integer lockId) throws IOException {
   byte[] family = DominoConst.INNER_FAMILY;
   Get get = new Get(row);
   get.setTimeStamp(startId);
   get.addFamily(family);
   Result r = region.get(get, lockId);
   if (r == null || r.isEmpty()) return;
   byte[] colBytes = r.getValue(family, DominoConst.COLUMNS_COL);
   if (colBytes == null || colBytes.length == 0) return;
   Delete del = new Delete(row);
   Columns cols = new Columns(colBytes);
   for (Column col : cols.cols) {
     del.deleteColumn(col.family, col.qualifier, startId);
   }
   del.deleteColumn(family, DominoConst.COLUMNS_COL, startId);
   del.deleteColumn(family, DominoConst.STATUS_COL, startId);
   mutateRow(del, lockId);
 }
Example #21
0
  private List<List<SpanBo>> getSpans0(
      List<TransactionId> transactionIdList, List<byte[]> hBaseFamiliyList) {
    if (transactionIdList == null || transactionIdList.isEmpty()) {
      return Collections.emptyList();
    }

    if (hBaseFamiliyList == null) {
      throw new NullPointerException("hBaseFamiliyList may not be null.");
    }

    final List<Get> getList = new ArrayList<>(transactionIdList.size());
    for (TransactionId transactionId : transactionIdList) {
      byte[] transactionIdRowKey = rowKeyDecoder.encodeRowKey(transactionId);
      final Get get = new Get(transactionIdRowKey);
      for (byte[] hbaseFamily : hBaseFamiliyList) {
        get.addFamily(hbaseFamily);
      }
      getList.add(get);
    }
    return template2.get(HBaseTables.TRACES, getList, spanMapper);
  }
Example #22
0
 @SuppressWarnings("deprecation")
 @Override
 public void commitRow(byte[] row, long startId, long commitId, boolean isDelete, Integer lockId)
     throws IOException {
   Get get = new Get(row);
   get.setMaxVersions();
   get.addFamily(DominoConst.INNER_FAMILY);
   Result r = region.get(get, lockId);
   if (!containsStatus(r, startId)) {
     // Other transaction may have committed this row of this version
     LOG.info(
         "Commit: No status found, returning: {}.{}", new String(this.getName()), new String(row));
     return;
   }
   List<KeyValue> versions = r.getColumn(DominoConst.INNER_FAMILY, DominoConst.VERSION_COL);
   Put commit = new Put(row);
   commit.setWriteToWAL(true);
   boolean isFresh = true;
   if (versions.size() >= DominoConst.MAX_VERSION) {
     // We need to clean the earliest version.
     LOG.info(
         "Commit: rolling version window: {}.{}", new String(this.getName()), new String(row));
     isFresh = addClearColumns(commit, versions, r, row, isDelete, commitId, startId, lockId);
   }
   KeyValue clearStatusKV =
       new KeyValue(
           row, DominoConst.INNER_FAMILY, DominoConst.STATUS_COL, startId, KeyValue.Type.Delete);
   commit.add(clearStatusKV);
   byte[] value = DominoConst.versionValue(startId, isDelete);
   if (isFresh) {
     KeyValue commitKV =
         new KeyValue(row, DominoConst.INNER_FAMILY, DominoConst.VERSION_COL, commitId, value);
     commit.add(commitKV);
   }
   // commitNumericModifications(row, startId, lockId, commit);
   mutateRow(commit, lockId);
 }
  @Override
  public Map<String, Map<String, String>> batch(List<GetItem> getItems) {
    Map<String, Map<String, String>> result = new ConcurrentHashMap<>();

    List<Get> gets = new ArrayList<>(getItems.size());
    for (GetItem getItem : getItems) {
      Get g = new Get(getItem.getRowkey());
      g.addFamily(getItem.getFamily());
      gets.add(g);
    }
    GetGroupTask task = new GetGroupTask(gets, result);
    Future<Boolean> future = AsyncThreadPoolFactory.ASYNC_HBASE_THREAD_POOL.submit(task);
    Boolean r = Boolean.FALSE;
    try {
      r = future.get(500, TimeUnit.MILLISECONDS);
    } catch (TimeoutException ignored) {
    } catch (InterruptedException | ExecutionException e) {
      e.printStackTrace();
    }
    if (!r) {
      future.cancel(Boolean.FALSE);
    }
    return result;
  }
Example #24
0
 @Override
 public GetBuilder addFamily(byte[] family) {
   get.addFamily(family);
   return this;
 }