@Override public Object eval(Record record, TypeManager typeManager) throws RepositoryException, InterruptedException { return record.getId(); } },
@Override public RecordId getId() { return delegate.getId(); }
@Override public RecordId getId() { return record.getId(); }
@Override public void delete(Record record) throws RepositoryException, InterruptedException { records.remove(record.getId()); }
/** * If the dependency is not matched by the configuration of the indexer, we log a warning because updates to this * dependency will not trigger 'denormalized data updates'. */ private void warnForUnmatchedDependencies(Record dependency) { if (dependency != null && dependency.getId() != null && this.indexRecordFilter.getIndexCase(table, dependency) == null) { log.warn(String.format("discovered dependency on record [%s] which will not be matched by the record filter of the index", dependency.getId())); } }
@Override public Object eval(Record record, TypeManager typeManager) throws RepositoryException, InterruptedException { return new Link(record.getId()); } }
/** * A shortcut for resolve(contextRecord.getId(), idGenerator). */ public RecordId resolve(Record contextRecord, IdGenerator idGenerator) { return resolve(contextRecord.getId(), idGenerator); }
/** * Build a Put for inserting a new (blank) record into a Lily repository table. */ public Put buildPut(Record newRecord, long version, FieldTypes fieldTypes, RecordEvent recordEvent, Set<BlobReference> referencedBlobs, Set<BlobReference> unReferencedBlobs, long occ) throws RecordException, InterruptedException, RepositoryException { Record dummyOriginalRecord = newRecord(); Put put = new Put(newRecord.getId().toBytes()); put.add(RecordCf.DATA.bytes, RecordColumn.DELETED.bytes, 1L, Bytes.toBytes(false)); calculateRecordChanges(newRecord, dummyOriginalRecord, version, put, recordEvent, referencedBlobs, unReferencedBlobs, false, fieldTypes); put.add(RecordCf.DATA.bytes, RecordColumn.OCC.bytes, 1L, Bytes.toBytes(occ)); return put; }
@Override public Record create(Record record) throws RepositoryException, InterruptedException { if (record.getId() == null) { record.setId(repository.getIdGenerator().newRecordId()); } if (records.containsKey(record.getId())) { throw new RecordExistsException(record.getId()); } record.setVersion(0l); record = writeRecord(record); return record; }
private void checkCreatePreconditions(Record record) throws InvalidRecordException { ArgumentValidator.notNull(record, "record"); if (record.getRecordTypeName() == null) { throw new InvalidRecordException("The recordType cannot be null for a record to be created.", record.getId()); } if (record.getFields().isEmpty()) { throw new InvalidRecordException("Creating an empty record is not allowed", record.getId()); } }
@Override public Record update(Record record, boolean updateVersion, boolean useLatestRecordType, List<MutationCondition> conditions) throws RepositoryException, InterruptedException { long before = System.currentTimeMillis(); RecordId recordId = record.getId(); try { if (recordId == null) { throw new InvalidRecordException("The recordId cannot be null for a record to be updated.", record.getId()); } FieldTypes fieldTypes = typeManager.getFieldTypesSnapshot(); // Check if the update is an update of mutable fields if (updateVersion) { try { return updateMutableFields(record, useLatestRecordType, conditions, fieldTypes); } catch (BlobException e) { throw new RecordException("Exception occurred while updating record '" + record.getId() + "'", e); } } else { return updateRecord(record, useLatestRecordType, conditions, fieldTypes); } } finally { metrics.report(Action.UPDATE, System.currentTimeMillis() - before); } }
@Override public void delete(Record record) throws RepositoryException { delete(record.getId(), null, record.hasAttributes() ? record.getAttributes() : null); }
@Override public void write(Record record) throws IOException, InterruptedException { if (bulkIngester.isBulkMode()) { Put put; try { put = bulkIngester.buildPut(record); recordsWritten++; } catch (RepositoryException e) { throw new RuntimeException(e); } rowKey.set(record.getId().toBytes()); context.write(rowKey, put); } else { try { bulkIngester.write(record); recordsWritten++; } catch (RepositoryException e) { throw new RuntimeException(e); } } }
@Override public Object resolve(TemplatePart part) { RecordContext ctx = contexts.peek(); //TODO: add dependencies caused by resolving name template variables if (part instanceof FieldTemplatePart) { QName fieldName = ((FieldTemplatePart) part).getFieldType().getName(); if (ctx.record.hasField(fieldName)) { return ctx.record.getField(fieldName); } else { throw new NameTemplateEvaluationException( "Error evaluating name template: Record does not have field " + fieldName); } } else if (part instanceof VariantPropertyTemplatePart) { VariantPropertyTemplatePart vpPart = (VariantPropertyTemplatePart) part; return contexts.peek().contextRecord.getId().getVariantProperties().get(vpPart.getName()); } else if (part instanceof LiteralTemplatePart) { return ((LiteralTemplatePart) part).getString(); } else { throw new NameTemplateEvaluationException("Unsupported TemplatePart type " + part.getClass().getName()); } }
InterruptedException { if (record.getId() == null) { byte[] rowId = record.getId().toBytes(); Get get = new Get(rowId); get.addColumn(RecordCf.DATA.bytes, RecordColumn.DELETED.bytes); result = recordTable.get(get); } catch (IOException e) { throw new RecordException("Error reading record row for record id " + record.getId(), e);
private void validateRecord(Record record, Record originalRecord, RecordType recordType, FieldTypes fieldTypes) throws TypeException, InvalidRecordException, InterruptedException { // Check mandatory fields Collection<FieldTypeEntry> fieldTypeEntries = recordType.getFieldTypeEntries(); List<QName> fieldsToDelete = record.getFieldsToDelete(); for (FieldTypeEntry fieldTypeEntry : fieldTypeEntries) { if (fieldTypeEntry.isMandatory()) { FieldType fieldType = fieldTypes.getFieldType(fieldTypeEntry.getFieldTypeId()); QName fieldName = fieldType.getName(); if (fieldsToDelete.contains(fieldName)) { throw new InvalidRecordException("Field: '" + fieldName + "' is mandatory.", record.getId()); } if (!record.hasField(fieldName) && !originalRecord.hasField(fieldName)) { throw new InvalidRecordException("Field: '" + fieldName + "' is mandatory.", record.getId()); } } } }
private Record writeRecord(Record record) throws RepositoryException, InterruptedException{ record = record.cloneRecord(); Record originalRecord = record; ResponseStatus status = ResponseStatus.UP_TO_DATE; if (records.containsKey(record.getId())) { originalRecord = records.get(record.getId()); record = merge(record, originalRecord); if (!originalRecord.equals(record)) { status = ResponseStatus.UPDATED; } } else { status = ResponseStatus.CREATED; } QName recordTypeName = record.getRecordTypeName(); Long recordTypeVersion = getTypeManager().getRecordTypeByName(recordTypeName, null).getVersion(); record.setRecordType(recordTypeName, recordTypeVersion); validateRecord(record, originalRecord, getTypeManager().getRecordTypeByName(recordTypeName, null)); Long version = record.getVersion() == null ? 0l : record.getVersion(); record.setVersion(version + 1); records.put(record.getId(), record.cloneRecord()); record.setResponseStatus(status); return record; }
private void validateRecord(Record record, Record originalRecord, RecordType recordType) throws TypeException, InvalidRecordException, InterruptedException, RepositoryException { // Check mandatory fields Collection<FieldTypeEntry> fieldTypeEntries = recordType.getFieldTypeEntries(); List<QName> fieldsToDelete = record.getFieldsToDelete(); for (FieldTypeEntry fieldTypeEntry : fieldTypeEntries) { if (fieldTypeEntry.isMandatory()) { FieldType fieldType = getTypeManager().getFieldTypeById(fieldTypeEntry.getFieldTypeId()); QName fieldName = fieldType.getName(); if (fieldsToDelete.contains(fieldName)) { throw new InvalidRecordException("Field: '" + fieldName + "' is mandatory.", record.getId()); } if (!record.hasField(fieldName) && !originalRecord.hasField(fieldName)) { throw new InvalidRecordException("Field: '" + fieldName + "' is mandatory.", record.getId()); } } } }
/** * Build the {@code Put} that represents a record for inserting into HBase. * * @param record The record to be translated into an HBase {@code Put} * @return Put which can be directly written to HBase */ public Put buildPut(Record record) throws InterruptedException, RepositoryException { RecordEvent recordEvent = new RecordEvent(); recordEvent.setType(Type.CREATE); recordEvent.setTableName(hbaseRepo.getTableName()); // set empty IndexRecordFilterData to omit the warnings in the IndexEditFilter recordEvent.setIndexRecordFilterData(new RecordEvent.IndexRecordFilterData()); if (record.getId() == null) { record.setId(getIdGenerator().newRecordId()); } Put put = hbaseRepo.buildPut(record, 1L, fieldTypes, recordEvent, Sets.<BlobReference>newHashSet(), Sets.<BlobReference>newHashSet(), 1L); put.add(LilyHBaseSchema.RecordCf.DATA.bytes, LilyHBaseSchema.RecordColumn.PAYLOAD.bytes, recordEvent.toJsonBytes()); return put; }
@Override public void delete(Record record) throws RepositoryException, InterruptedException { try { lilyProxy.delete(getAuthzContext(), converter.convert(record.getId()), repositoryName, tableName, null, record.getAttributes()); } catch (AvroRepositoryException e) { throw converter.convert(e); } catch (AvroGenericException e) { throw converter.convert(e); } catch (AvroRemoteException e) { throw handleAvroRemoteException(e); } catch (UndeclaredThrowableException e) { throw handleUndeclaredRecordThrowable(e); } }