Examples with Value com.google.firestore.v1beta1.Value used on opensource projects

Example 76 with Value

use of com.google.firestore.v1beta1.Value in project firebase-android-sdk by firebase.

the class SQLiteIndexManager method encodeValues.

/**
 * Encodes the given field values according to the specification in {@code target}. For IN
 * queries, a list of possible values is returned.
 */
@Nullable
private Object[] encodeValues(FieldIndex fieldIndex, Target target, @Nullable Collection<Value> values) {
    if (values == null)
        return null;
    List<IndexByteEncoder> encoders = new ArrayList<>();
    encoders.add(new IndexByteEncoder());
    Iterator<Value> position = values.iterator();
    for (FieldIndex.Segment segment : fieldIndex.getDirectionalSegments()) {
        Value value = position.next();
        for (IndexByteEncoder encoder : encoders) {
            if (isInFilter(target, segment.getFieldPath()) && isArray(value)) {
                encoders = expandIndexValues(encoders, segment, value);
            } else {
                DirectionalIndexByteEncoder directionalEncoder = encoder.forKind(segment.getKind());
                FirestoreIndexValueWriter.INSTANCE.writeIndexValue(value, directionalEncoder);
            }
        }
    }
    return getEncodedBytes(encoders);
}

Example 77 with Value

use of com.google.firestore.v1beta1.Value in project firebase-android-sdk by firebase.

the class Target method getDescendingBound.

/**
 * Returns the value for a descending bound of `segment`.
 *
 * @param segment The segment to get the value for.
 * @param bound A bound to restrict the index range.
 * @return a Pair with a nullable Value and a boolean indicating whether the bound is inclusive
 */
private Pair<Value, Boolean> getDescendingBound(FieldIndex.Segment segment, @Nullable Bound bound) {
    Value segmentValue = MAX_VALUE;
    boolean segmentInclusive = true;
    // Process all filters to find a value for the current field segment
    for (FieldFilter fieldFilter : getFieldFiltersForPath(segment.getFieldPath())) {
        Value filterValue = MAX_VALUE;
        boolean filterInclusive = true;
        switch(fieldFilter.getOperator()) {
            case GREATER_THAN_OR_EQUAL:
            case GREATER_THAN:
                filterValue = Values.getUpperBound(fieldFilter.getValue().getValueTypeCase());
                filterInclusive = false;
                break;
            case EQUAL:
            case IN:
            case LESS_THAN_OR_EQUAL:
                filterValue = fieldFilter.getValue();
                break;
            case LESS_THAN:
                filterValue = fieldFilter.getValue();
                filterInclusive = false;
                break;
            case NOT_EQUAL:
            case NOT_IN:
                filterValue = Values.MAX_VALUE;
                break;
            default:
        }
        if (upperBoundCompare(segmentValue, segmentInclusive, filterValue, filterInclusive) > 0) {
            segmentValue = filterValue;
            segmentInclusive = filterInclusive;
        }
    }
    // can narrow the scope.
    if (bound != null) {
        for (int i = 0; i < orderBys.size(); ++i) {
            OrderBy orderBy = this.orderBys.get(i);
            if (orderBy.getField().equals(segment.getFieldPath())) {
                Value cursorValue = bound.getPosition().get(i);
                if (upperBoundCompare(segmentValue, segmentInclusive, cursorValue, bound.isInclusive()) > 0) {
                    segmentValue = cursorValue;
                    segmentInclusive = bound.isInclusive();
                }
                break;
            }
        }
    }
    return new Pair<>(segmentValue, segmentInclusive);
}

Example 78 with Value

use of com.google.firestore.v1beta1.Value in project firebase-android-sdk by firebase.

the class OrderBy method compare.

int compare(Document d1, Document d2) {
    if (field.equals(FieldPath.KEY_PATH)) {
        return direction.getComparisonModifier() * d1.getKey().compareTo(d2.getKey());
    } else {
        Value v1 = d1.getField(field);
        Value v2 = d2.getField(field);
        Assert.hardAssert(v1 != null && v2 != null, "Trying to compare documents on fields that don't exist.");
        return direction.getComparisonModifier() * Values.compare(v1, v2);
    }
}

Example 79 with Value

use of com.google.firestore.v1beta1.Value in project firebase-android-sdk by firebase.

the class Bound method compareToDocument.

private int compareToDocument(List<OrderBy> orderBy, Document document) {
    hardAssert(position.size() <= orderBy.size(), "Bound has more components than query's orderBy");
    int comparison = 0;
    for (int i = 0; i < position.size(); i++) {
        OrderBy orderByComponent = orderBy.get(i);
        Value component = position.get(i);
        if (orderByComponent.field.equals(FieldPath.KEY_PATH)) {
            hardAssert(Values.isReferenceValue(component), "Bound has a non-key value where the key path is being used %s", component);
            comparison = DocumentKey.fromName(component.getReferenceValue()).compareTo(document.getKey());
        } else {
            Value docValue = document.getField(orderByComponent.getField());
            hardAssert(docValue != null, "Field should exist since document matched the orderBy already.");
            comparison = Values.compare(component, docValue);
        }
        if (orderByComponent.getDirection().equals(Direction.DESCENDING)) {
            comparison = comparison * -1;
        }
        if (comparison != 0) {
            break;
        }
    }
    return comparison;
}

Example 80 with Value

use of com.google.firestore.v1beta1.Value in project firebase-android-sdk by firebase.

the class ConformanceTest method executeTestCases.

private void executeTestCases(TestCase testCase, ConformanceRuntime runtime) throws Exception {
    // Note: This method is copied from Google3 and modified to match the Android API.
    TestCollection testCollection;
    TestDocument testDocument;
    for (Collection collection : testCase.getCollections()) {
        testCollection = runtime.addInitialCollectionWithPath(collection.getName());
        for (Document document : collection.getDocuments()) {
            testDocument = testCollection.addDocumentWithId(getId(document));
            for (Map.Entry<String, Value> field : document.getFieldsMap().entrySet()) {
                testDocument.putField(field.getKey(), decodeValue(firestore, field.getValue()));
            }
        }
        if (testCase.getException()) {
            runtime.expectException();
        } else {
            Result result = testCase.getResult();
            for (Document document : result.getDocuments()) {
                testDocument = runtime.addExpectedDocumentWithId(getId(document));
                for (Map.Entry<String, Value> field : document.getFieldsMap().entrySet()) {
                    testDocument.putField(field.getKey(), decodeValue(firestore, field.getValue()));
                }
            }
        }
        try {
            runtime.setup();
            try {
                Query query = runtime.createQueryAtPath(testCase.getQuery().getCollection());
                for (QueryFilter filter : testCase.getQuery().getFilters()) {
                    Where where = filter.getWhere();
                    if (where != null) {
                        switch(where.getOp()) {
                            case LESS_THAN:
                                query = query.whereLessThan(formatFieldPath(where.getField()), decodeValue(firestore, where.getValue()));
                                break;
                            case LESS_THAN_OR_EQUAL:
                                query = query.whereLessThanOrEqualTo(formatFieldPath(where.getField()), decodeValue(firestore, where.getValue()));
                                break;
                            case GREATER_THAN:
                                query = query.whereGreaterThan(formatFieldPath(where.getField()), decodeValue(firestore, where.getValue()));
                                break;
                            case GREATER_THAN_OR_EQUAL:
                                query = query.whereGreaterThanOrEqualTo(formatFieldPath(where.getField()), decodeValue(firestore, where.getValue()));
                                break;
                            case EQUAL:
                                query = query.whereEqualTo(formatFieldPath(where.getField()), decodeValue(firestore, where.getValue()));
                                break;
                            case NOT_EQUAL:
                                query = query.whereNotEqualTo(formatFieldPath(where.getField()), decodeValue(firestore, where.getValue()));
                                break;
                            case ARRAY_CONTAINS:
                                query = query.whereArrayContains(formatFieldPath(where.getField()), decodeValue(firestore, where.getValue()));
                                break;
                            case IN:
                                query = query.whereIn(formatFieldPath(where.getField()), Collections.singletonList(decodeValue(firestore, where.getValue())));
                                break;
                            case ARRAY_CONTAINS_ANY:
                                query = query.whereArrayContainsAny(formatFieldPath(where.getField()), Collections.singletonList(decodeValue(firestore, where.getValue())));
                                break;
                            case NOT_IN:
                                query = query.whereNotIn(formatFieldPath(where.getField()), Collections.singletonList(decodeValue(firestore, where.getValue())));
                                break;
                            default:
                                throw new Exception("Unexpected operation: " + where.getOp());
                        }
                    }
                    Order order = filter.getOrder();
                    if (order != null) {
                        query = query.orderBy(formatFieldPath(order.getField()), order.getDirection().equals(StructuredQuery.Direction.ASCENDING) ? Query.Direction.ASCENDING : Query.Direction.DESCENDING);
                    }
                    Value startAt = filter.getStartAt();
                    if (startAt != null) {
                        query = query.startAt(decodeValue(firestore, startAt));
                    }
                    Value startAfter = filter.getStartAfter();
                    if (startAfter != null) {
                        query = query.startAfter(decodeValue(firestore, startAfter));
                    }
                    Value endBefore = filter.getEndBefore();
                    if (endBefore != null) {
                        query = query.endBefore(decodeValue(firestore, endBefore));
                    }
                    Value endAt = filter.getEndAt();
                    if (endAt != null) {
                        query = query.endAt(decodeValue(firestore, endAt));
                    }
                    Long limit = filter.getLimit();
                    if (limit != null && limit > 0) {
                        query = query.limit(limit);
                    }
                }
                runtime.runQuery(query);
            } catch (RuntimeException | AssertionError x) {
                runtime.checkQueryError(x);
            }
        } finally {
            runtime.teardown();
        }
    }
}