private void loadConsistent() { try (DmlTransaction trans = backendService.openReadTransaction()) { Optional<KvValue<?>> valueOpt = trans.readMetaInfo(getConsistencyKey()); if (!valueOpt.isPresent()) { consistent = false; return; } KvValue<?> value = valueOpt.get(); if (!value.getType().equals(BooleanType.INSTANCE)) { throw new IllegalStateException("Unexpected consistency value " + "found. Expected a boolean but " + valueOpt + " was " + "found"); } consistent = ((KvBoolean) value).getPrimitiveValue(); } }
public static boolean equals(KvValue<?> v1, KvValue<?> v2) { return v1.accept(COMPARISON_VISITOR, v2); }
@Override public Boolean defaultCase(KvValue<?> value, KvValue<?> other) { return value.equals(other); } }
@Override public BsonValue<?> apply(@Nonnull KvValue<?> kvValue) { return kvValue.accept(this, null); }
Stream<ToroDocument> streamByAttRef(String dbName, String colName, AttributeReference attRef, KvValue<?> value) { return getTransaction().streamCollection(dbName, colName) .filter(doc -> { Optional<KvValue<?>> resolved = AttributeRefKvDocResolver.resolve( attRef, doc.getRoot()); return resolved.isPresent() && value.equals(resolved.get()); }); }
@Nonnull protected static KvType calculateElementType(Iterable<KvValue<?>> iterable) { KvType result = null; for (KvValue<?> kVValue : iterable) { KvType iestType = kVValue.getType(); if (result == null) { result = iestType; } else if (!result.equals(iestType)) { result = GenericType.INSTANCE; break; } } if (result == null) { result = GenericType.INSTANCE; } return result; } }
public static BsonValue<?> translate(KvValue<?> kvValue) { return kvValue.accept(ToBsonValueTranslator.getInstance(), null); }
void insert(String db, String col, Stream<KvDocument> docs) throws UniqueIndexViolationException { Map<Integer, KvDocument> map = getMap(db, col); List<KvDocument> docList = docs.collect(Collectors.toList()); Optional<KvDocument> repeatedDoc = docList.stream() .filter(doc -> { KvValue<?> mongoId = doc.get(_ID); if (mongoId != null) { Optional<KvDocument> withSameId = map.values().stream() .filter(otherDoc -> mongoId.equals(otherDoc.get(_ID))) .findAny(); return withSameId.isPresent(); } return false; }) .findAny(); if (repeatedDoc.isPresent()) { throw new UniqueIndexViolationException(_ID, repeatedDoc.get()); } docList.forEach(doc -> { int id = idGenerator.getAsInt(); map.put(id, doc); }); }
MetaField field = docPart.getMetaFieldByNameAndType(lastKey, FieldType.from(value.getType())); if (field != null) { valuesMap.put(field, value);
@Override public BsonValue<?> visit(KvArray value, Void arg) { List<BsonValue<?>> list = new ArrayList<>(value.size()); for (KvValue<?> kVValue : value) { list.add(kVValue.accept(this, arg)); } return newArray(list); }
/** * Two entries are equals if their keys and values are equal. * * @param obj * @return */ @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (obj == null) { return false; } if (!(obj instanceof DocEntry)) { return false; } DocEntry<?> other = (DocEntry<?>) obj; return this.getKey().equals(other.getKey()) && this.getValue().equals(other.getValue()); }
MetaField field = docPart.getMetaFieldByNameAndType(lastKey, FieldType.from(value.getType())); if (field != null) { valuesMap.put(field, value);
@Override public BsonValue<?> visit(KvDocument value, Void arg) { List<Entry<?>> entryList = new ArrayList<>(value.size()); for (DocEntry<?> docEntry : value) { entryList.add(new SimpleEntry<>(docEntry.getKey(), docEntry.getValue().accept(this, arg))); } return newDocument(entryList); }
MetaField field = docPart.getMetaFieldByNameAndType(lastKey, FieldType.from(value.getType())); if (field == null) { LOGGER.trace("Field " + dbName + '.' + colName + '.' + ref + '.' + lastKey
@Override public Void visit(KvArray value, A arg) { preKvValue(value, arg); preArray(value, arg); for (KvValue<?> element : value) { element.accept(this, arg); } postArray(value, arg); postKvValue(value, arg); return null; }
@Override public long deleteByAttRef(String dbName, String colName, AttributeReference attRef, KvValue<?> value) { MetaDatabase db = getMetaSnapshot().getMetaDatabaseByName(dbName); if (db == null) { return 0; } MetaCollection col = db.getMetaCollectionByName(colName); if (col == null) { return 0; } TableRef tableRef = extractTableRef(attRef); String lastKey = extractKeyName(attRef.getKeys().get(attRef.getKeys().size() - 1)); MetaDocPart docPart = col.getMetaDocPartByTableRef(tableRef); if (docPart == null) { return 0; } MetaField field = docPart.getMetaFieldByNameAndType(lastKey, FieldType.from(value.getType())); if (field == null) { return 0; } Collection<Integer> dids = getBackendTransaction() .findByField(db, col, docPart, field, value) .asDidCursor() .getRemaining(); getBackendTransaction().deleteDids(db, col, dids); return dids.size(); }
@Override public Void visit(KvDocument value, A arg) { preKvValue(value, arg); preDoc(value, arg); for (DocEntry<?> entry : value) { entry.getValue().accept(this, arg); } postDoc(value, arg); postKvValue(value, arg); return null; }
@Override public Boolean visit(KvDocument value, KvValue<?> other) { if (other == value) { return true; } if (other == null) { return false; } if (!(other instanceof KvDocument)) { return false; } KvDocument otherDoc = (KvDocument) other; if (value.size() != otherDoc.size()) { return false; } for (KvDocument.DocEntry<?> myEntry : value) { KvValue<?> otherValue = otherDoc.get(myEntry.getKey()); if (otherValue == null) { return false; } if (!otherValue.accept(this, myEntry.getValue())) { return false; } } return true; }
@Override public Boolean visit(KvArray value, KvValue<?> other) { if (other == value) { return true; } if (other == null) { return false; } if (!(other instanceof KvArray)) { return false; } KvArray otherArr = (KvArray) other; if (value.size() != otherArr.size()) { return false; } for (int i = 0; i < value.size(); i++) { KvValue<?> v1 = value.get(i); KvValue<?> v2 = otherArr.get(i); if (!v1.accept(this, v2)) { return false; } } return true; }