if (this.typeMap.put(type.getName(), type) != null) throw new IllegalArgumentException("schema model is invalid"); this.typeFieldMap.put(type.getStorageId(), fieldMap); for (SchemaField field : type.getSchemaFields().values()) { if (fieldMap.put(field.getName(), field) != null) throw new IllegalArgumentException("schema model is invalid"); this.typeCompositeIndexMap.put(type.getStorageId(), compositeIndexMap); for (SchemaCompositeIndex compositeIndex : type.getSchemaCompositeIndexes().values()) { if (compositeIndexMap.put(compositeIndex.getName(), compositeIndex) != null) throw new IllegalArgumentException("schema model is invalid");
@Override SchemaObjectType toSchemaItem(JSimpleDB jdb) { final SchemaObjectType schemaObjectType = new SchemaObjectType(); this.initialize(jdb, schemaObjectType); for (JField field : this.jfields.values()) { final SchemaField schemaField = field.toSchemaItem(jdb); schemaObjectType.getSchemaFields().put(schemaField.getStorageId(), schemaField); } for (JCompositeIndex index : this.jcompositeIndexes.values()) { final SchemaCompositeIndex schemaIndex = index.toSchemaItem(jdb); schemaObjectType.getSchemaCompositeIndexes().put(index.getStorageId(), schemaIndex); } return schemaObjectType; }
/** * Deep-clone this instance. */ @Override @SuppressWarnings("unchecked") public SchemaModel clone() { final SchemaModel clone = (SchemaModel)super.clone(); clone.schemaObjectTypes = new TreeMap<>(clone.schemaObjectTypes); for (Map.Entry<Integer, SchemaObjectType> entry : clone.schemaObjectTypes.entrySet()) entry.setValue(entry.getValue().clone()); return clone; } }
/** * Get the {@link SchemaCompositeIndex} with the given name in the given {@link SchemaObjectType}. * * @param type object type * @param name index name * @throws IllegalArgumentException if either paramter is null * @return the unique {@link SchemaCompositeIndex} with name {@code name} in {@code type}, or null if not found * @throws IllegalArgumentException if {@code type} is not indexed by this instance */ public SchemaCompositeIndex getSchemaCompositeIndex(SchemaObjectType type, String name) { Preconditions.checkArgument(type != null, "null type"); Preconditions.checkArgument(name != null, "null name"); final TreeMap<String, SchemaCompositeIndex> indexMap = this.typeCompositeIndexMap.get(type.getStorageId()); if (indexMap == null) throw new IllegalArgumentException("unknown type `" + type.getName() + "' with storage ID " + type.getStorageId()); return indexMap.get(name); }
private void doValidate() { // Validate object types and verify object type names are unique final TreeMap<String, SchemaObjectType> schemaObjectTypesByName = new TreeMap<>(); for (SchemaObjectType schemaObjectType : this.schemaObjectTypes.values()) { schemaObjectType.validate(); final String schemaObjectTypeName = schemaObjectType.getName(); final SchemaObjectType otherSchemaObjectType = schemaObjectTypesByName.put(schemaObjectTypeName, schemaObjectType); if (otherSchemaObjectType != null) throw new InvalidSchemaException("duplicate object name `" + schemaObjectTypeName + "'"); } // Collect all field storage ID's final TreeMap<Integer, AbstractSchemaItem> globalItemsByStorageId = new TreeMap<>(); for (SchemaObjectType schemaObjectType : this.schemaObjectTypes.values()) { for (SchemaField field : schemaObjectType.getSchemaFields().values()) { globalItemsByStorageId.put(field.getStorageId(), field); if (field instanceof ComplexSchemaField) { final ComplexSchemaField complexField = (ComplexSchemaField)field; for (SimpleSchemaField subField : complexField.getSubFields().values()) globalItemsByStorageId.put(subField.getStorageId(), subField); } } } // Verify object type, field, and index storage ID's are non-overlapping for (SchemaObjectType schemaObjectType : this.schemaObjectTypes.values()) { SchemaModel.verifyUniqueStorageId(globalItemsByStorageId, schemaObjectType); for (SchemaCompositeIndex index : schemaObjectType.getSchemaCompositeIndexes().values()) SchemaModel.verifyUniqueStorageId(globalItemsByStorageId, index); } }
ObjectType(final JsckInfo info, final SchemaObjectType objType) { super(info, objType.getStorageId()); this.objType = objType; for (SchemaField field : objType.getSchemaFields().values()) { field.visit(new SchemaFieldSwitchAdapter<Void>() { @Override for (SchemaField field : objType.getSchemaFields().values()) { field.visit(new SchemaFieldSwitchAdapter<Void>() { @Override
final SchemaObjectType schemaObjectType = new SchemaObjectType(); schemaObjectType.readXML(reader, formatVersion); final int storageId = schemaObjectType.getStorageId(); final SchemaObjectType previous = this.schemaObjectTypes.put(storageId, schemaObjectType); if (previous != null) {
/** * Get the {@link SchemaModel} associated with this instance, derived from the annotations on the scanned classes. * * @return the associated schema model */ public SchemaModel getSchemaModel() { if (this.schemaModel == null) { final SchemaModel model = new SchemaModel(); for (JClass<?> jclass : this.jclasses.values()) { final SchemaObjectType schemaObjectType = jclass.toSchemaItem(this); model.getSchemaObjectTypes().put(schemaObjectType.getStorageId(), schemaObjectType); } this.schemaModel = model; this.schemaModel.lockDown(); this.log.debug("JSimpleDB schema generated from annotated classes:\n{}", this.schemaModel); } return this.schemaModel; }
for (SchemaField field : objectType.getSchemaFields().values()) { field.visit(new SchemaFieldSwitchAdapter<Void>() { for (SchemaCompositeIndex index : objectType.getSchemaCompositeIndexes().values()) this.addStorage(schemaVersion, new CompositeIndex(this, schemaVersion, objectType, index));
CompositeIndex(JsckInfo info, int schemaVersion, SchemaObjectType objectType, SchemaCompositeIndex index) { super(info, index.getStorageId()); this.fieldStorageIds = index.getIndexedFields().stream().mapToInt(Integer::intValue).toArray(); this.fieldTypes = new FieldType<?>[this.fieldStorageIds.length]; for (int i = 0; i < this.fieldTypes.length; i++) { final SimpleSchemaField field = (SimpleSchemaField)objectType.getSchemaFields().get(fieldStorageIds[i]); this.fieldTypes[i] = this.info.findFieldType(schemaVersion, field).genericizeForIndex(); } }
@Override public Diffs differencesFrom(SchemaModel that) { Preconditions.checkArgument(that != null, "null that"); final Diffs diffs = new Diffs(); final NavigableSet<Integer> allObjectTypeIds = NavigableSets.union( this.schemaObjectTypes.navigableKeySet(), that.schemaObjectTypes.navigableKeySet()); for (int storageId : allObjectTypeIds) { final SchemaObjectType thisObjectType = this.schemaObjectTypes.get(storageId); final SchemaObjectType thatObjectType = that.schemaObjectTypes.get(storageId); if (thisObjectType == null) diffs.add("removed " + thatObjectType); else if (thatObjectType == null) diffs.add("added " + thisObjectType); else { final Diffs objectTypeDiffs = thisObjectType.differencesFrom(thatObjectType); if (!objectTypeDiffs.isEmpty()) diffs.add("changed " + thatObjectType, objectTypeDiffs); } } return diffs; }
/** * Get the {@link SchemaField} with the given name in the given {@link SchemaObjectType}. * * @param type object type * @param name field name * @throws IllegalArgumentException if either paramter is null * @return the unique {@link SchemaField} with name {@code name} in {@code type}, or null if not found * @throws IllegalArgumentException if {@code type} is not indexed by this instance */ public SchemaField getSchemaField(SchemaObjectType type, String name) { Preconditions.checkArgument(type != null, "null type"); Preconditions.checkArgument(name != null, "null name"); final TreeMap<String, SchemaField> fieldMap = this.typeFieldMap.get(type.getStorageId()); if (fieldMap == null) throw new IllegalArgumentException("unknown type `" + type.getName() + "' with storage ID " + type.getStorageId()); return fieldMap.get(name); }
private ObjType parseGeneratedType(XMLStreamReader reader, String text, String attr, Schema schema) throws XMLStreamException { // Try object type name final NameIndex nameIndex = this.nameIndexMap.get(schema.getVersionNumber()); final SchemaObjectType schemaObjectType = nameIndex.getSchemaObjectType(attr); if (schemaObjectType != null) return schema.getObjType(schemaObjectType.getStorageId()); // Try storage ID final int storageId; try { storageId = Integer.parseInt(attr); } catch (IllegalArgumentException e) { throw new XMLStreamException("invalid object type `" + attr + "' in generated object ID `" + text + "': no such object type found in schema version " + schema.getVersionNumber(), reader.getLocation()); } try { return schema.getObjType(storageId); } catch (UnknownTypeException e) { throw new XMLStreamException("invalid storage ID " + storageId + " in generated object ID `" + text + "': no such object type found in schema version " + schema.getVersionNumber(), reader.getLocation()); } }
final SchemaField field = objType.getSchemaFields().get(storageId); if (field == null) { info.handle(new InvalidKey(pair).setDetail(id, "invalid field storage ID " for (SchemaCompositeIndex index : this.objType.getSchemaCompositeIndexes().values()) this.verifyCompositeIndexEntry(info, id, index, simpleFieldValues);
super(schemaObjectType.getName(), schemaObjectType.getStorageId(), schema); for (SchemaField schemaField : schemaObjectType.getSchemaFields().values()) this.addSchemaItem(fields, fieldsByName, schemaField.visit(fieldBuilder)); for (SchemaCompositeIndex schemaIndex : schemaObjectType.getSchemaCompositeIndexes().values()) this.addCompositeIndex(this.schema, schemaIndex);
/** * Get all of the names of {@link SchemaField}s in the given {@link SchemaObjectType}. * * @param type schema object * @return unmodifiable set of {@link SchemaField} names in {@code type} * @throws IllegalArgumentException if {@code type} is not indexed by this instance */ public NavigableSet<String> getSchemaFieldNames(SchemaObjectType type) { Preconditions.checkArgument(type != null, "null type"); final TreeMap<String, SchemaField> fieldMap = this.typeFieldMap.get(type.getStorageId()); if (fieldMap == null) throw new IllegalArgumentException("unknown type `" + type.getName() + "' with storage ID " + type.getStorageId()); return Collections.unmodifiableNavigableSet(fieldMap.navigableKeySet()); }
final SchemaObjectType schemaType = ReferencePath.this.jdb.getNameIndex().getSchemaObjectType(typeName); if (schemaType != null) type = ReferencePath.this.jdb.getJClass(schemaType.getStorageId()).getType(); else { try {
/** * Get all of the names of {@link SchemaCompositeIndex}s in the given {@link SchemaObjectType}. * * @param type schema object * @return unmodifiable set of {@link SchemaCompositeIndex} names in {@code type} * @throws IllegalArgumentException if {@code type} is not indexed by this instance */ public NavigableSet<String> getSchemaCompositeIndexNames(SchemaObjectType type) { Preconditions.checkArgument(type != null, "null type"); final TreeMap<String, SchemaCompositeIndex> indexMap = this.typeCompositeIndexMap.get(type.getStorageId()); if (indexMap == null) throw new IllegalArgumentException("unknown type `" + type.getName() + "' with storage ID " + type.getStorageId()); return Collections.unmodifiableNavigableSet(indexMap.navigableKeySet()); } }
+ schema.getVersionNumber(), reader.getLocation()); objType = schema.getObjType(schemaObjectType.getStorageId());
.addCompletions(ParseUtil.complete(nameIndex.getSchemaObjectTypeNames(), typeName)); return schema.getObjType(schemaObjectType.getStorageId());