public FieldType registerFieldType(SchemaId fieldId, TypeManager typeMgr) throws Exception { for (FieldType entry : fields) { if (entry.getId().equals(fieldId)) { return entry; } } FieldType fieldType = typeMgr.getFieldTypeById(fieldId); fields.add(fieldType); return fieldType; }
/** * Filters the given set of fields to only those that are vtag fields. */ public static Set<SchemaId> filterVTagFields(Set<SchemaId> fieldIds, TypeManager typeManager) throws RepositoryException, InterruptedException { Set<SchemaId> result = new HashSet<SchemaId>(); for (SchemaId field : fieldIds) { try { if (isVersionTag(typeManager.getFieldTypeById(field))) { result.add(field); } } catch (FieldTypeNotFoundException e) { // ignore, if it does not exist, it can't be a version tag } } return result; }
private List<FieldType> getSortedFieldTypes(RecordType recordType) throws RepositoryException, InterruptedException { Collection<FieldTypeEntry> fieldTypeEntries = getFieldTypeEntries(recordType); List<FieldType> fieldTypes = new ArrayList<FieldType>(); for (FieldTypeEntry fieldTypeEntry : fieldTypeEntries) { fieldTypes.add(typeManager.getFieldTypeById(fieldTypeEntry.getFieldTypeId())); } return fieldTypes; }
public static Map<Scope, Set<FieldType>> getFieldTypeAndScope(Set<SchemaId> fieldIds, FieldFilter fieldFilter, TypeManager typeManager) throws RepositoryException, InterruptedException { // Could be written more elegantly using Multimaps.index, but we want to limit dependencies Map<Scope, Set<FieldType>> result = new EnumMap<Scope, Set<FieldType>>(Scope.class); for (Scope scope : Scope.values()) { result.put(scope, new HashSet<FieldType>()); } for (SchemaId fieldId : fieldIds) { FieldType fieldType; try { fieldType = typeManager.getFieldTypeById(fieldId); } catch (FieldTypeNotFoundException e) { // A field whose field type does not exist: skip it continue; } if (fieldFilter.accept(fieldType)) { result.get(fieldType.getScope()).add(fieldType); } } return result; }
/** * Extracts the links from a record. The provided Record object should * be "fully loaded" (= contain all fields). */ public static void extract(IdRecord record, LinkCollector collector, LRepository repository) throws RepositoryException, InterruptedException { for (Map.Entry<SchemaId, Object> field : record.getFieldsById().entrySet()) { FieldType fieldType; try { fieldType = repository.getTypeManager().getFieldTypeById(field.getKey()); } catch (FieldTypeNotFoundException e) { // Can not do anything with a field if we cannot load its type continue; } extract(field.getValue(), fieldType, collector, fieldType, record.getId(), repository); } }
private Map<SchemaId, Long> getTagsById(IdRecord record, TypeManager typeManager) throws InterruptedException, RepositoryException { Map<SchemaId, Long> vtags = new HashMap<SchemaId, Long>(); for (Map.Entry<SchemaId, Object> field : record.getFieldsById().entrySet()) { FieldType fieldType; try { fieldType = typeManager.getFieldTypeById(field.getKey()); } catch (FieldTypeNotFoundException e) { // A field whose field type does not exist: skip it continue; } if (VersionTag.isVersionTag(fieldType)) { vtags.put(fieldType.getId(), (Long) field.getValue()); } } vtags.put(getLastVTag(), record.getVersion() == null ? 0 : record.getVersion()); return vtags; }
/** * Removes any versioned information from the supplied record object. * * <p>This method can be removed once we have a repository method that is able to filter this when loading * the record. */ public static void reduceToNonVersioned(IdRecord record, TypeManager typeManager) throws RepositoryException, InterruptedException { if (record.getVersion() == null) { // The record has no versions so there should be no versioned fields in it return; } // Remove all non-versioned fields from the record Map<SchemaId, QName> mapping = record.getFieldIdToNameMapping(); Iterator<Map.Entry<SchemaId, QName>> it = mapping.entrySet().iterator(); while (it.hasNext()) { Map.Entry<SchemaId, QName> entry = it.next(); if (typeManager.getFieldTypeById(entry.getKey()).getScope() != Scope.NON_VERSIONED) { record.delete(entry.getValue(), false); it.remove(); } } // Remove versioned record type info record.setRecordType(Scope.VERSIONED, (QName) null, null); record.setRecordType(Scope.VERSIONED_MUTABLE, (QName) null, null); } }
@Override public AvroFieldType getFieldTypeById(AvroSchemaId id) throws AvroRepositoryException, AvroInterruptedException { try { return converter.convert(typeManager.getFieldTypeById(converter.convert(id))); } catch (RepositoryException e) { throw converter.convert(e); } catch (InterruptedException e) { throw converter.convert(e); } }
/** * Lookup name of field type, for use in debug logs. Beware, this might be slow. */ private String safeLoadTagName(SchemaId fieldTypeId) { if (fieldTypeId == null) { return "null"; } try { return repositoryManager.getDefaultRepository().getTypeManager().getFieldTypeById(fieldTypeId).getName().getName(); } catch (Throwable t) { return "failed to load name"; } }
FieldType fieldType = null; try { fieldType = repository.getTypeManager().getFieldTypeById(fte.getFieldTypeId()); } catch (Throwable t) {
SchemaId schemaId = new SchemaIdImpl(Bytes.tail(columnQualifier, columnQualifier.length - 1)); FieldType fieldType = typeManager.getFieldTypeById(schemaId); ValueType valueType = fieldType.getValueType(); NavigableMap<Long, byte[]> cells = column.getValue();
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()); } } } }
public SolrInputDocument build() throws InterruptedException, RepositoryException { solrDoc.setField("lily.id", recordId.toString()); solrDoc.setField("lily.table", table); solrDoc.setField("lily.key", key); solrDoc.setField("lily.vtagId", vtag.toString()); solrDoc.setField("lily.vtag", typeManager.getFieldTypeById(vtag).getName().getName()); solrDoc.setField("lily.version", version); return solrDoc; }
private Result getBlobUsage(byte[] blobKey, SchemaId recordId, SchemaId fieldId) throws FieldTypeNotFoundException, TypeException, InterruptedException, IOException, RepositoryException { FieldTypeImpl fieldType = (FieldTypeImpl)typeManager.getFieldTypeById(fieldId); ValueType valueType = fieldType.getValueType(); Get get = new Get(recordId.getBytes()); get.addColumn(RecordCf.DATA.bytes, fieldType.getQualifier()); byte[] valueToCompare = Bytes.toBytes(valueType.getNestingLevel()); valueToCompare = Bytes.add(valueToCompare, blobKey); WritableByteArrayComparable valueComparator = new ContainsValueComparator(valueToCompare); Filter filter = new SingleColumnValueFilter(RecordCf.DATA.bytes, fieldType.getQualifier(), CompareOp.EQUAL, valueComparator); get.setFilter(filter); for (RepositoryTable repoTable : tableManager.getTables()) { HTableInterface recordTable = LilyHBaseSchema.getRecordTable(tableFactory, repoTable.getRepositoryName(), repoTable.getName()); Result result = recordTable.get(get); if (result != null && !result.isEmpty()) { return result; } } return null; } }
try { if (idMode == IdentificationMode.ID) { oldFieldType = typeManager.getFieldTypeById(newFieldType.getId()); } else { oldFieldType = typeManager.getFieldTypeByName(identifyingName);
FieldType fieldType = typeManager.getFieldTypeById(fieldChange.getId()); QName name = fieldType.getName();