@Override public Object eval(Record record, TypeManager typeManager) throws RepositoryException, InterruptedException { return record.getId(); } },
private Record merge(Record record, Record original) { Record result = original.clone(); if (record.getRecordTypeName() != null) { result.setRecordType(record.getRecordTypeName()); } // TODO merge meta map for(Map.Entry<QName,Object> entry : record.getFields().entrySet()) { result.setField(entry.getKey(), entry.getValue()); } for (QName toDelete : record.getFieldsToDelete()) { result.getFields().remove(toDelete); } return result; }
@Override public void beforeCreate(Record newRecord, Repository repository, FieldTypes fieldTypes, RecordEvent recordEvent) throws RepositoryException, InterruptedException { QName name = new QName("ns", "f1"); String currentValue = (String)newRecord.getField(name); newRecord.setField(name, currentValue + "-create-hook"); }
@Override public Object eval(Record record, TypeManager typeManager) { return formatNameVersion(record.getRecordTypeName(), record.getRecordTypeVersion()); } },
@Override public void delete(Record record) throws RepositoryException { delete(record.getId(), null, record.hasAttributes() ? record.getAttributes() : null); }
writeNullOrBytes(record.getId() != null ? record.getId().toBytes() : null, output); writeNullOrVLong(record.getVersion(), output); writeNullOrQName(record.getRecordTypeName(scope), output); writeNullOrVLong(record.getRecordTypeVersion(scope), output); output.writeVInt(record.getFields().size()); for (Map.Entry<QName, Object> entry : record.getFields().entrySet()) { if (entry.getKey() == null) { throw new IllegalArgumentException("Record contains field with null key."); output.writeVInt(record.getFieldsToDelete().size()); for (QName name : record.getFieldsToDelete()) { writeQName(name, output); if (record.hasAttributes()) { output.writeVInt(record.getAttributes().size()); for (String key : record.getAttributes().keySet()) { String value = record.getAttributes().get(key); output.writeUTF(key); output.writeUTF(value); writeNullOrVInt(record.getResponseStatus() != null ? record.getResponseStatus().ordinal() : null, output); Map<QName, Metadata> metadatas = record.getMetadataMap(); if (metadatas.size() > 0) { output.writeVInt(metadatas.size());
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 Record updateRecord(Record record, boolean useLatestRecordType, List<MutationCondition> conditions, FieldTypes fieldTypes) throws RepositoryException { RecordId recordId = record.getId(); Pair<Record, byte[]> recordAndOcc = readWithOcc(record.getId(), null, null, fieldTypes); Record originalRecord = new UnmodifiableRecord(recordAndOcc.getV1()); recordEvent.setType(Type.UPDATE); recordEvent.setTableName(getTableName()); if (record.hasAttributes()) { recordEvent.getAttributes().putAll(record.getAttributes()); Record newRecord = record.cloneRecord(); Put put = new Put(newRecord.getId().toBytes()); Set<BlobReference> referencedBlobs = new HashSet<BlobReference>(); Set<BlobReference> unReferencedBlobs = new HashSet<BlobReference>(); long newVersion = originalRecord.getVersion() == null ? 1 : originalRecord.getVersion() + 1; reserveBlobs(record.getId(), referencedBlobs); newRecord.setResponseStatus(ResponseStatus.UPDATED); } else { newRecord.setResponseStatus(ResponseStatus.UP_TO_DATE);
if (record.getId() != null) { recordNode.put("id", record.getId().toString()); if (record.getVersion() != null) { recordNode.put("version", record.getVersion()); if (record.getRecordTypeName() != null) { recordNode.put("type", typeToJson(record.getRecordTypeName(), record.getRecordTypeVersion(), namespaces)); QName versionedTypeName = record.getRecordTypeName(Scope.VERSIONED); if (versionedTypeName != null) { long version = record.getRecordTypeVersion(Scope.VERSIONED); recordNode.put("versionedType", typeToJson(versionedTypeName, version, namespaces)); QName versionedMutableTypeName = record.getRecordTypeName(Scope.VERSIONED_MUTABLE); if (versionedMutableTypeName != null) { long version = record.getRecordTypeVersion(Scope.VERSIONED_MUTABLE); recordNode.put("versionedMutableType", typeToJson(versionedMutableTypeName, version, namespaces)); Map<QName, Object> fields = record.getFields(); if (fields.size() > 0) { ObjectNode fieldsNode = recordNode.putObject("fields"); Map<String, String> attributes = record.getAttributes(); if (attributes.size() > 0) { ObjectNode attributesNode = recordNode.putObject("attributes"); Map<QName, Metadata> metadatas = record.getMetadataMap(); if (!metadatas.isEmpty()) {
record.setId(repository.getIdGenerator().fromBytes(idBytes)); record.setVersion(readNullOrVLong(input)); QName recordType = readNullOrQName(input); Long rtVersion = readNullOrVLong(input); record.setRecordType(scope, recordType, rtVersion); ValueType valueType = typeManager.getValueType(valueTypeName); Object value = valueType.read(input); record.setField(name, value); record.getFieldsToDelete().add(readQName(input)); String value = input.readUTF(); record.getAttributes().put(key, value); record.setResponseStatus(ResponseStatus.values()[responseStatusOrdinal]); QName fieldName = readQName(input); Metadata metadata = MetadataSerDeser.read(input); record.setMetadata(fieldName, metadata);
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()); } }
final QName newRecordTypeName; final Long newRecordTypeVersion; if (record.getRecordTypeName() == null) { newRecordTypeName = originalRecord.getRecordTypeName(); newRecordTypeVersion = null; } else { newRecordTypeName = record.getRecordTypeName(); newRecordTypeVersion = useLatestRecordType ? null : record.getRecordTypeVersion(); || changedScopes.contains(Scope.VERSIONED_MUTABLE); if (!versionedFieldsHaveChanged) { version = originalRecord.getVersion(); boolean recordTypeHasChanged = !newRecordTypeName.equals(originalRecord.getRecordTypeName()) || !actualRecordTypeVersion.equals(originalRecord.getRecordTypeVersion()); record.setRecordType(newRecordTypeName, actualRecordTypeVersion); if (version != null) { byte[] versionBytes = Bytes.toBytes(version); record.setVersion(version);
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()); } } } }
for (Map.Entry<QName, Object> field : record.getFields().entrySet()) { FieldType fieldType = null; try { out.println("ID = " + record.getId()); out.println("Version = " + record.getVersion());
@Override public void beforeDelete(Record originalRecord, Repository repository, FieldTypes fieldTypes, RecordEvent recordEvent) throws RepositoryException, InterruptedException { Collection<IndexInfo> indexInfos = indexesInfo.getIndexInfos(); if (indexInfos.size() > 0) { TypeManager typeMgr = repository.getTypeManager(); RecordEvent.IndexRecordFilterData idxSel = new RecordEvent.IndexRecordFilterData(); recordEvent.setIndexRecordFilterData(idxSel); idxSel.setOldRecordExists(true); idxSel.setNewRecordExists(false); if (indexesInfo.getRecordFilterDependsOnRecordType()) { idxSel.setOldRecordType(typeMgr.getRecordTypeByName(originalRecord.getRecordTypeName(), null).getId()); } Set<QName> names = indexesInfo.getRecordFilterFieldDependencies(); for (QName name : names) { if (originalRecord.hasField(name)) { Object oldValue = originalRecord.getField(name); FieldType type = fieldTypes.getFieldType(name); addField(type, oldValue, null, idxSel); } } calculateIndexInclusion(repository.getRepositoryName(), recordEvent.getTableName(), originalRecord, null, idxSel); } }
private static void printRecordValue(PrintStream out, int indent, Record record) { println(out, indent, "Record of type " + record.getRecordTypeName() + ", version " + record.getRecordTypeVersion()); for (Map.Entry<QName, Object> field : record.getFields().entrySet()) { printField(out, indent, field.getKey(), field.getValue()); } }
@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()); } }
@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; }
/** * Removes any versioned information from the supplied record object. */ public static void reduceToNonVersioned(Record record, Set<QName> fields, TypeManager typeManager) throws RepositoryException, InterruptedException { if (record.getVersion() == null) { // The record has no versions so there should be no versioned fields in it return; } Iterator<Map.Entry<QName, Object>> fieldsIt = record.getFields().entrySet().iterator(); while (fieldsIt.hasNext()) { Map.Entry<QName, Object> entry = fieldsIt.next(); if (fields != null && !fields.contains(entry.getKey())) { fieldsIt.remove(); } else if (typeManager.getFieldTypeByName(entry.getKey()).getScope() != Scope.NON_VERSIONED) { fieldsIt.remove(); } } // Remove versioned record type info record.setRecordType(Scope.VERSIONED, (QName) null, null); record.setRecordType(Scope.VERSIONED_MUTABLE, (QName) null, null); }
@Override public IdRecord readWithIds(RecordId recordId, Long aLong, List<SchemaId> schemaIds) throws RepositoryException, InterruptedException { Record record = getRecord(recordId); TypeManager typeManager = this.getTypeManager(); Map<SchemaId, QName> map = Maps.newHashMap(); for (QName qname : record.getFields().keySet()) { map.put(typeManager.getFieldTypeByName(qname).getId(), qname); } Map<Scope,SchemaId> recordTypeIds = Maps.newHashMap(); for (Scope scope : Scope.values()) { RecordType recordType = typeManager.getRecordTypeByName(record.getRecordTypeName(scope), record.getVersion()); if (recordType != null) { recordTypeIds.put(scope, recordType.getId()); } } IdRecord idRecord = new IdRecordImpl(record, map, recordTypeIds); return idRecord; }