コード例 #1
0
ファイル: BaseRepository.java プロジェクト: sreev/lilyproject
  public List<Record> readVersions(
      RecordId recordId, Long fromVersion, Long toVersion, QName... fieldNames)
      throws RepositoryException, InterruptedException {
    ArgumentValidator.notNull(recordId, "recordId");
    ArgumentValidator.notNull(fromVersion, "fromVersion");
    ArgumentValidator.notNull(toVersion, "toVersion");
    if (fromVersion > toVersion) {
      throw new IllegalArgumentException(
          "fromVersion '"
              + fromVersion
              + "' must be smaller or equal to toVersion '"
              + toVersion
              + "'");
    }

    FieldTypes fieldTypes = typeManager.getFieldTypesSnapshot();
    List<FieldType> fields = getFieldTypesFromNames(fieldTypes, fieldNames);

    int numberOfVersionsToRetrieve = (int) (toVersion - fromVersion + 1);
    Result result = getRow(recordId, toVersion, numberOfVersionsToRetrieve, fields);
    if (fromVersion < 1L) fromVersion = 1L; // Put the fromVersion to a sensible value
    Long latestVersion = recdec.getLatestVersion(result);
    if (latestVersion < toVersion)
      toVersion = latestVersion; // Limit the toVersion to the highest possible version
    List<Long> versionsToRead = new ArrayList<Long>();
    for (long version = fromVersion; version <= toVersion; version++) {
      versionsToRead.add(version);
    }
    return recdec.decodeRecords(recordId, versionsToRead, result, fieldTypes);
  }
コード例 #2
0
ファイル: BaseRepository.java プロジェクト: sreev/lilyproject
  public List<Record> readVersions(RecordId recordId, List<Long> versions, QName... fieldNames)
      throws RepositoryException, InterruptedException {
    ArgumentValidator.notNull(recordId, "recordId");
    ArgumentValidator.notNull(versions, "versions");

    if (versions.isEmpty()) return new ArrayList<Record>();

    Collections.sort(versions);

    FieldTypes fieldTypes = typeManager.getFieldTypesSnapshot();
    List<FieldType> fields = getFieldTypesFromNames(fieldTypes, fieldNames);

    Long lowestRequestedVersion = versions.get(0);
    Long highestRequestedVersion = versions.get(versions.size() - 1);
    int numberOfVersionsToRetrieve = (int) (highestRequestedVersion - lowestRequestedVersion + 1);
    Result result = getRow(recordId, highestRequestedVersion, numberOfVersionsToRetrieve, fields);
    Long latestVersion = recdec.getLatestVersion(result);

    // Drop the versions that are higher than the latestVersion
    List<Long> validVersions = new ArrayList<Long>();
    for (Long version : versions) {
      if (version > latestVersion) break;
      validVersions.add(version);
    }
    return recdec.decodeRecords(recordId, validVersions, result, fieldTypes);
  }
コード例 #3
0
ファイル: BaseRepository.java プロジェクト: sreev/lilyproject
  // Retrieves the row from the table and check if it exists and has not been flagged as deleted
  protected Map<RecordId, Result> getRows(List<RecordId> recordIds, List<FieldType> fields)
      throws RecordException {
    Map<RecordId, Result> results = new HashMap<RecordId, Result>();

    try {
      List<Get> gets = new ArrayList<Get>();
      for (RecordId recordId : recordIds) {
        Get get = new Get(recordId.toBytes());
        // Add the columns for the fields to get
        addFieldsToGet(get, fields);
        get.setMaxVersions(1); // Only retrieve the most recent version of each field
        gets.add(get);
      }

      // Retrieve the data from the repository
      int i = 0;
      for (Result result : recordTable.get(gets)) {
        if (result == null || result.isEmpty()) {
          i++; // Skip this recordId (instead of throwing a RecordNotFoundException)
          continue;
        }
        // Check if the record was deleted
        byte[] deleted = recdec.getLatest(result, RecordCf.DATA.bytes, RecordColumn.DELETED.bytes);
        if ((deleted == null) || (Bytes.toBoolean(deleted))) {
          i++; // Skip this recordId (instead of throwing a RecordNotFoundException)
          continue;
        }
        results.put(recordIds.get(i++), result);
      }
    } catch (IOException e) {
      throw new RecordException(
          "Exception occurred while retrieving records '" + recordIds + "' from HBase table", e);
    }
    return results;
  }
コード例 #4
0
ファイル: BaseRepository.java プロジェクト: sreev/lilyproject
 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);
   }
 }
コード例 #5
0
ファイル: BaseRepository.java プロジェクト: sreev/lilyproject
  private List<Record> read(List<RecordId> recordIds, List<FieldType> fields, FieldTypes fieldTypes)
      throws RepositoryException, InterruptedException {
    long before = System.currentTimeMillis();
    try {
      ArgumentValidator.notNull(recordIds, "recordIds");
      List<Record> records = new ArrayList<Record>();
      if (recordIds.isEmpty()) return records;

      Map<RecordId, Result> results = getRows(recordIds, fields);

      for (Entry<RecordId, Result> entry : results.entrySet()) {
        Long version = recdec.getLatestVersion(entry.getValue());
        records.add(
            recdec.decodeRecord(entry.getKey(), version, null, entry.getValue(), fieldTypes));
      }
      return records;
    } finally {
      if (metrics != null) metrics.report(Action.READ, System.currentTimeMillis() - before);
    }
  }
コード例 #6
0
ファイル: BaseRepository.java プロジェクト: sreev/lilyproject
  protected Record read(
      RecordId recordId, Long requestedVersion, List<FieldType> fields, FieldTypes fieldTypes)
      throws RepositoryException, InterruptedException {
    long before = System.currentTimeMillis();
    try {
      ArgumentValidator.notNull(recordId, "recordId");

      Result result = getRow(recordId, requestedVersion, 1, fields);

      Long latestVersion = recdec.getLatestVersion(result);
      if (requestedVersion == null) {
        // Latest version can still be null if there are only non-versioned fields in the record
        requestedVersion = latestVersion;
      } else {
        if (latestVersion == null || latestVersion < requestedVersion) {
          // The requested version is higher than the highest existing version
          throw new VersionNotFoundException(recordId, requestedVersion);
        }
      }
      return recdec.decodeRecord(recordId, requestedVersion, null, result, fieldTypes);
    } finally {
      if (metrics != null) metrics.report(Action.READ, System.currentTimeMillis() - before);
    }
  }
コード例 #7
0
ファイル: BaseRepository.java プロジェクト: sreev/lilyproject
  private ResultScanner createHBaseResultScanner(RecordScan scan)
      throws RepositoryException, InterruptedException {
    Scan hbaseScan = new Scan();

    hbaseScan.setMaxVersions(1);

    if (scan.getRawStartRecordId() != null) {
      hbaseScan.setStartRow(scan.getRawStartRecordId());
    } else if (scan.getStartRecordId() != null) {
      hbaseScan.setStartRow(scan.getStartRecordId().toBytes());
    }

    if (scan.getRawStopRecordId() != null) {
      hbaseScan.setStopRow(scan.getRawStopRecordId());
    } else if (scan.getStopRecordId() != null) {
      hbaseScan.setStopRow(scan.getStopRecordId().toBytes());
    }

    // Filters
    FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);

    // filter out deleted records
    filterList.addFilter(REAL_RECORDS_FILTER);

    // add user's filter
    if (scan.getRecordFilter() != null) {
      Filter filter = filterFactory.createHBaseFilter(scan.getRecordFilter(), this, filterFactory);
      filterList.addFilter(filter);
    }

    hbaseScan.setFilter(filterList);

    hbaseScan.setCaching(scan.getCaching());

    hbaseScan.setCacheBlocks(scan.getCacheBlocks());

    ReturnFields returnFields = scan.getReturnFields();
    if (returnFields != null && returnFields.getType() != ReturnFields.Type.ALL) {
      RecordDecoder.addSystemColumnsToScan(hbaseScan);
      switch (returnFields.getType()) {
        case ENUM:
          for (QName field : returnFields.getFields()) {
            FieldTypeImpl fieldType = (FieldTypeImpl) typeManager.getFieldTypeByName(field);
            hbaseScan.addColumn(RecordCf.DATA.bytes, fieldType.getQualifier());
          }
          break;
        case NONE:
          // nothing to add
          break;
        default:
          throw new RuntimeException("Unrecognized ReturnFields type: " + returnFields.getType());
      }
    } else {
      hbaseScan.addFamily(RecordCf.DATA.bytes);
    }

    ResultScanner hbaseScanner;
    try {
      hbaseScanner = recordTable.getScanner(hbaseScan);
    } catch (IOException e) {
      throw new RecordException("Error creating scanner", e);
    }
    return hbaseScanner;
  }
コード例 #8
0
ファイル: BaseRepository.java プロジェクト: sreev/lilyproject
 @Override
 public Record newRecord(RecordId recordId) {
   ArgumentValidator.notNull(recordId, "recordId");
   return recdec.newRecord(recordId);
 }
コード例 #9
0
ファイル: BaseRepository.java プロジェクト: sreev/lilyproject
 @Override
 public Record newRecord() {
   return recdec.newRecord();
 }