private static void appendCondition(StringBuilder aql, Map<String, Object> params, char entity, Document document, String condition) { String nameParam = getNameParam(document.getName(), params); aql.append(SEPARATOR).append(entity).append('.').append(document.getName()) .append(condition).append(PARAM_APPENDER).append(nameParam); if(IN.equals(condition)) { params.put(nameParam, ValueUtil.convertToList(document.getValue())); } else { params.put(nameParam, document.get()); } }
static String getPrefix(Document document, String collection) { String id = document.get(String.class); return getPrefix(collection, id); }
private static void appendCondition(StringBuilder query, List<Object> params, Document document, String condition, List<ORecordId> ids) { if(OrientDBConverter.RID_FIELD.equals(document.getName())) { ids.add(new ORecordId(document.get(String.class))); return; } query.append(document.getName()) .append(condition).append(PARAM_APPENDER); if(IN.equals(condition)) { params.add(ValueUtil.convertToList(document.getValue())); } else { params.add(document.get()); } }
private static void convertDocument(JsonObject jsonObject, Document d, Object value) { Document document = Document.class.cast(value); jsonObject.put(d.getName(), Collections.singletonMap(document.getName(), document.get())); }
private Document getConditions(DocumentCondition columnCondition, Condition condition) { List<DocumentCondition> conditions = new ArrayList<>(document.get(new TypeReference<List<DocumentCondition>>() { })); conditions.add(columnCondition); return Document.of(condition.getNameField(), conditions); }
private static void toDocument(Map<String, Object> entityValues, Document document) { Object value = ValueUtil.convert(document.getValue()); if (Document.class.isInstance(value)) { Document subDocument = Document.class.cast(value); entityValues.put(document.getName(), singletonMap(subDocument.getName(), subDocument.get())); } else if (isDocumentIterable(value)) { entityValues.put(document.getName(), getMap(value)); } else if (isSudDocumentList(value)) { entityValues.put(document.getName(), StreamSupport.stream(Iterable.class.cast(value).spliterator(), false) .map(OrientDBConverter::getMap).collect(toList())); } else { entityValues.put(document.getName(), value); } }
private static void inKeys(List<String> keys, String documentCollection, Document document) { if(document.getName().equals(KEY_FIELD)){ keys.addAll(document.get(new TypeReference<List<String>>() { })); } else { List<String> ids = document.get(new TypeReference<List<String>>() {}); ids.stream().map(id -> EntityConverter.getPrefix(documentCollection, id)) .forEach(keys::add); } }
static DocumentCondition in(Document document) { Objects.requireNonNull(document, "document is required"); Object value = document.get(); checkInClause(value); return new DefaultDocumentCondition(document, Condition.IN); }
return x(document.getName()).between(x(PARAM_PREFIX + document.getName())); case AND: return document.get(new TypeReference<List<DocumentCondition>>() { }) .stream() return document.get(new TypeReference<List<DocumentCondition>>() { }) .stream() .orElseThrow(() -> new IllegalStateException("An or condition cannot be empty")); case NOT: DocumentCondition dc = document.get(DocumentCondition.class); return getCondition(dc, params, keys, documentCollection).not(); default:
@Override public Map<String, Object> toMap() { Map<String, Object> map = new HashMap<>(); for (Map.Entry<String, Document> entry : documents.entrySet()) { Document value = entry.getValue(); map.put(value.getName(), convert(value.get())); } return Collections.unmodifiableMap(map); }
static DocumentCondition between(Document document) { Objects.requireNonNull(document, "document is required"); checkBetweenClause(document.get()); return new DefaultDocumentCondition(document, Condition.BETWEEN); }
private Object convert(Object value) { if (value instanceof Document) { Document column = Document.class.cast(value); return singletonMap(column.getName(), convert(column.get())); } else if (value instanceof Iterable) { List<Object> list = new ArrayList<>(); Iterable.class.cast(value).forEach(e -> list.add(convert(e))); return list; } return value; }
private <T> Consumer<Document> convertDocument(T instance, FieldRepresentation field, AbstractDocumentEntityConverter converter) { return document -> { GenericFieldRepresentation genericField = GenericFieldRepresentation.class.cast(field); Collection collection = genericField.getCollectionInstance(); List<List<Document>> embeddable = (List<List<Document>>) document.get(); for (List<Document> documentList : embeddable) { Object element = converter.toEntity(genericField.getElementType(), documentList); collection.add(element); } converter.getReflections().setValue(instance, field.getNativeField(), collection); }; } }
static List<DocumentEntity> convert(N1qlQueryResult result, String database) { return result.allRows().stream() .map(N1qlQueryRow::value) .map(JsonObject::toMap) .map(m -> m.get(database)) .filter(Objects::nonNull) .filter(Map.class::isInstance) .map(m -> (Map<String, Object>) m) .map(map -> { List<Document> documents = toDocuments(map); Optional<Document> keyDocument = documents.stream().filter(d -> KEY_FIELD.equals(d.getName())).findFirst(); String collection = keyDocument.map(d -> d.get(String.class)).orElse(database).split(SPLIT_KEY)[0]; return DocumentEntity.of(collection, documents); }).collect(toList()); }
@Override public <T> void convert(T instance, List<Document> documents, Optional<Document> document, FieldRepresentation field, AbstractDocumentEntityConverter converter) { if (document.isPresent()) { Document sudDocument = document.get(); Object value = sudDocument.get(); if (Map.class.isInstance(value)) { Map map = Map.class.cast(value); List<Document> embeddedDocument = new ArrayList<>(); for (Map.Entry entry : (Set<Map.Entry>) map.entrySet()) { embeddedDocument.add(Document.of(entry.getKey().toString(), entry.getValue())); } converter.getReflections().setValue(instance, field.getNativeField(), converter.toEntity(field.getNativeField().getType(), embeddedDocument)); } else { converter.getReflections().setValue(instance, field.getNativeField(), converter.toEntity(field.getNativeField().getType(), sudDocument.get(new TypeReference<List<Document>>() { }))); } } else { converter.getReflections().setValue(instance, field.getNativeField(), converter.toEntity(field.getNativeField().getType(), documents)); } } }
private static void convertIterable(JsonObject jsonObject, Document document, Object value) { JsonObject map = JsonObject.create(); JsonArray array = JsonArray.create(); Iterable.class.cast(value).forEach(element -> { if (Document.class.isInstance(element)) { Document subdocument = Document.class.cast(element); map.put(subdocument.getName(), subdocument.get()); } else if (isSudDocument(element)) { JsonObject subJson = JsonObject.create(); stream(Iterable.class.cast(element).spliterator(), false) .forEach(getSubdocument(subJson)); array.add(subJson); } else { array.add(element); } }); if (array.isEmpty()) { jsonObject.put(document.getName(), map); } else { jsonObject.put(document.getName(), array); } }
@Override public DocumentCondition negate() { if (NOT.equals(this.condition)) { return this.document.get(DocumentCondition.class); } else { Document document = Document.of(NOT.getNameField(), this); return new DefaultDocumentCondition(document, NOT); } }
return; case AND: for (DocumentCondition dc : document.get(new TypeReference<List<DocumentCondition>>() { })) { for (DocumentCondition dc : document.get(new TypeReference<List<DocumentCondition>>() { })) { if (isFirstCondition(query, counter)) { DocumentCondition documentCondition = document.get(DocumentCondition.class); query.append("NOT ("); definesCondition(documentCondition, query, params, ++counter, ids);
case AND: for (DocumentCondition dc : document.get(new TypeReference<List<DocumentCondition>>() { })) { case OR: for (DocumentCondition dc : document.get(new TypeReference<List<DocumentCondition>>() { })) { if (isFirstCondition(aql, counter)) { DocumentCondition documentCondition = document.get(DocumentCondition.class); aql.append(NOT); definesCondition(documentCondition, aql, params, entity, ++counter);