Esempio n. 1
0
  /**
   * Processes a List of Rows (Put, Delete) and writes them to an HTable instance in RegionServer
   * buckets via the htable.batch method. <br>
   * <br>
   * The benefit of submitting Puts in this manner is to minimize the number of RegionServer RPCs,
   * thus this will produce one RPC of Puts per RegionServer. <br>
   * <br>
   * Assumption #1: Regions have been pre-created for the table. If they haven't, then all of the
   * Puts will go to the same region, defeating the purpose of this utility method. See the Apache
   * HBase book for an explanation of how to do this. <br>
   * Assumption #2: Row-keys are not monotonically increasing. See the Apache HBase book for an
   * explanation of this problem. <br>
   * Assumption #3: That the input list of Rows is big enough to be useful (in the thousands or
   * more). The intent of this method is to process larger chunks of data. <br>
   * <br>
   * This method accepts a list of Row objects because the underlying .batch method accepts a list
   * of Row objects. <br>
   * <br>
   *
   * @param htable HTable instance for target HBase table
   * @param rows List of Row instances
   * @throws IOException if a remote or network exception occurs
   */
  public static void bucketRsBatch(HTable htable, List<Row> rows) throws IOException {

    try {
      Map<String, List<Row>> rowMap = createRsRowMap(htable, rows);
      for (List<Row> rsRows : rowMap.values()) {
        htable.batch(rsRows);
      }
    } catch (InterruptedException e) {
      throw new IOException(e);
    }
  }
Esempio n. 2
0
  @Override
  public void tweet(User user, String tweetText) throws IOException {
    final long epoch = System.currentTimeMillis();
    final long tranposeEpoch = Long.MAX_VALUE - epoch;
    final byte[] epochBytes = Bytes.toBytes(epoch);

    final byte[] tweetBytes = Bytes.toBytes(tweetText);
    byte[] nameBytes = Bytes.toBytes(user.getName());

    /** put tweet into tweets */
    Put tweetRowPut = new Put(generateTweetId(user));

    tweetRowPut.add(_DEFAULT, _NAME, nameBytes);
    tweetRowPut.add(_DEFAULT, _MAIL, Bytes.toBytes(user.getEmail()));
    tweetRowPut.add(_DEFAULT, _TWEET, tweetBytes);
    tweetRowPut.add(_DEFAULT, _TIME, epochBytes);

    tweetsTable.put(tweetRowPut);

    /** put tweets for followers */
    Scan followerScan = new Scan();
    followerScan.setStartRow(Bytes.toBytes(user.getUserId() + "-"));
    followerScan.setStopRow(Bytes.toBytes((user.getUserId() + 1) + "-"));

    ResultScanner followerRS = followersTable.getScanner(followerScan);

    /** put users on tweet to her own tweetline */
    Put put =
        new Put(Bytes.toBytes(user.getUserId() + "-" + tranposeEpoch + "-" + user.getUserId()));
    put.add(_DEFAULT, _NAME, nameBytes);
    put.add(_DEFAULT, _TWEET, tweetBytes);
    put.add(_DEFAULT, _TIME, epochBytes);

    List<Row> puts = new ArrayList<Row>();
    puts.add(put);
    for (Result result : followerRS) {

      Long followerid = Bytes.toLong(result.getColumnLatest(_DEFAULT, _USERID).getValue());

      put = new Put(Bytes.toBytes(followerid + "-" + tranposeEpoch + "-" + user.getUserId()));
      put.add(_DEFAULT, _NAME, nameBytes);
      put.add(_DEFAULT, _TWEET, tweetBytes);
      put.add(_DEFAULT, _TIME, epochBytes);

      puts.add(put);
    }
    followerRS.close();
    try {
      tweetlineTable.batch(puts);
    } catch (InterruptedException e) {
      e.printStackTrace(); // @TODO log and handle properly.
    }
  }
Esempio n. 3
0
 /**
  * Execute the passed <code>mutations</code> against <code>.META.</code> table.
  *
  * @param ct CatalogTracker on whose back we will ride the edit.
  * @param mutations Puts and Deletes to execute on .META.
  * @throws IOException
  */
 static void mutateMetaTable(final CatalogTracker ct, final List<Mutation> mutations)
     throws IOException {
   HTable t = MetaReader.getMetaHTable(ct);
   try {
     t.batch(mutations);
   } catch (InterruptedException e) {
     InterruptedIOException ie = new InterruptedIOException(e.getMessage());
     ie.initCause(e);
     throw ie;
   } finally {
     t.close();
   }
 }
Esempio n. 4
0
 public void write(List<Mutation> mutations) throws IOException, InterruptedException {
   Object[] results = new Object[mutations.size()];
   table.batch(mutations, results);
 }