com.arangodb.internal.ArangoCollectionAsyncImpl Maven / Gradle / Ivy

Go to download
/*
 * DISCLAIMER
 *
 * Copyright 2018 ArangoDB GmbH, Cologne, Germany
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Copyright holder is ArangoDB GmbH, Cologne, Germany
 */

package com.arangodb.internal;

import com.arangodb.ArangoCollectionAsync;
import com.arangodb.ArangoDBException;
import com.arangodb.ArangoDatabaseAsync;
import com.arangodb.entity.*;
import com.arangodb.model.*;
import com.arangodb.util.RawData;

import java.util.Collection;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;

import static com.arangodb.internal.ArangoErrors.*;
import static com.arangodb.internal.serde.SerdeUtils.constructParametricType;

/**
 * @author Mark Vollmary
 * @author Michele Rastelli
 */
public class ArangoCollectionAsyncImpl extends InternalArangoCollection implements ArangoCollectionAsync {

    private final ArangoDatabaseAsync db;

    protected ArangoCollectionAsyncImpl(final ArangoDatabaseAsyncImpl db, final String name) {
        super(db, db.name(), name);
        this.db = db;
    }

    @Override
    public ArangoDatabaseAsync db() {
        return db;
    }

    @Override
    public CompletableFuture> insertDocument(final Object value) {
        return executorAsync().execute(() -> insertDocumentRequest(value, new DocumentCreateOptions()),
                constructParametricType(DocumentCreateEntity.class, Void.class));
    }

    @Override
    @SuppressWarnings("unchecked")
    public  CompletableFuture> insertDocument(final T value, final DocumentCreateOptions options) {
        return insertDocument(value, options, (Class) value.getClass());
    }

    @Override
    public  CompletableFuture> insertDocument(final T value, final DocumentCreateOptions options,
                                                                         final Class type) {
        return executorAsync().execute(() -> insertDocumentRequest(value, options),
                constructParametricType(DocumentCreateEntity.class, type));
    }

    @Override
    public CompletableFuture>> insertDocuments(RawData values) {
        return executorAsync()
                .execute(() -> insertDocumentsRequest(values, new DocumentCreateOptions()),
                        insertDocumentsResponseDeserializer(Void.class));
    }

    @Override
    @SuppressWarnings("unchecked")
    public CompletableFuture>> insertDocuments(RawData values,
                                                                                                 DocumentCreateOptions options) {
        return executorAsync()
                .execute(() -> insertDocumentsRequest(values, options),
                        insertDocumentsResponseDeserializer((Class) values.getClass()));
    }

    @Override
    public CompletableFuture>> insertDocuments(final Iterable values) {
        return insertDocuments(values, new DocumentCreateOptions());
    }

    @Override
    public CompletableFuture>> insertDocuments(
            final Iterable values, final DocumentCreateOptions options) {
        return executorAsync()
                .execute(() -> insertDocumentsRequest(values, options),
                        insertDocumentsResponseDeserializer(Void.class));
    }

    @Override
    public  CompletableFuture>> insertDocuments(Iterable values,
                                                                                               DocumentCreateOptions options,
                                                                                               Class type) {
        return executorAsync()
                .execute(() -> insertDocumentsRequest(values, options), insertDocumentsResponseDeserializer(type));
    }

    @Override
    public CompletableFuture importDocuments(final Iterable values) {
        return importDocuments(values, new DocumentImportOptions());
    }

    @Override
    public CompletableFuture importDocuments(final Iterable values, final DocumentImportOptions options) {
        return executorAsync().execute(() -> importDocumentsRequest(values, options), DocumentImportEntity.class);
    }

    @Override
    public CompletableFuture importDocuments(RawData values) {
        return importDocuments(values, new DocumentImportOptions());
    }

    @Override
    public CompletableFuture importDocuments(RawData values, DocumentImportOptions options) {
        return executorAsync().execute(() -> importDocumentsRequest(values, options), DocumentImportEntity.class);
    }

    @Override
    public  CompletableFuture getDocument(final String key, final Class type) {
        return getDocument(key, type, new DocumentReadOptions());
    }

    @Override
    public  CompletableFuture getDocument(final String key, final Class type, final DocumentReadOptions options) {
        return executorAsync().execute(() -> getDocumentRequest(key, options), getDocumentResponseDeserializer(type))
                .exceptionally(err -> {
                    Throwable e = err instanceof CompletionException ? err.getCause() : err;
                    if (e instanceof ArangoDBException) {
                        ArangoDBException aEx = (ArangoDBException) e;
                        if (matches(aEx, 304)
                                || matches(aEx, 404, ERROR_ARANGO_DOCUMENT_NOT_FOUND)
                                || matches(aEx, 412, ERROR_ARANGO_CONFLICT)
                        ) {
                            return null;
                        }
                    }
                    throw ArangoDBException.of(e);
                });
    }

    @Override
    public  CompletableFuture> getDocuments(final Iterable keys, final Class type) {
        return getDocuments(keys, type, new DocumentReadOptions());
    }

    @Override
    public  CompletableFuture> getDocuments(
            final Iterable keys, final Class type, final DocumentReadOptions options) {
        return executorAsync().execute(() -> getDocumentsRequest(keys, options), getDocumentsResponseDeserializer(type));
    }

    @Override
    public CompletableFuture> replaceDocument(final String key, final Object value) {
        return executorAsync().execute(() -> replaceDocumentRequest(key, value, new DocumentReplaceOptions()),
                constructParametricType(DocumentUpdateEntity.class, Void.class));
    }

    @Override
    @SuppressWarnings("unchecked")
    public  CompletableFuture> replaceDocument(
            final String key, final T value, final DocumentReplaceOptions options) {
        return replaceDocument(key, value, options, (Class) value.getClass());
    }

    @Override
    public  CompletableFuture> replaceDocument(String key, T value, DocumentReplaceOptions options,
                                                                          Class type) {
        return executorAsync().execute(() -> replaceDocumentRequest(key, value, options),
                constructParametricType(DocumentUpdateEntity.class, type));
    }

    @Override
    public CompletableFuture>> replaceDocuments(RawData values) {
        return executorAsync().execute(() -> replaceDocumentsRequest(values, new DocumentReplaceOptions()),
                replaceDocumentsResponseDeserializer(Void.class));
    }

    @Override
    @SuppressWarnings("unchecked")
    public CompletableFuture>> replaceDocuments(RawData values,
                                                                                                  DocumentReplaceOptions options) {
        return executorAsync().execute(() -> replaceDocumentsRequest(values, options),
                replaceDocumentsResponseDeserializer((Class) values.getClass()));
    }

    @Override
    public CompletableFuture>> replaceDocuments(final Iterable values) {
        return replaceDocuments(values, new DocumentReplaceOptions());
    }

    @Override
    public CompletableFuture>> replaceDocuments(
            final Iterable values, final DocumentReplaceOptions options) {
        return executorAsync().execute(() -> replaceDocumentsRequest(values, options),
                replaceDocumentsResponseDeserializer(Void.class));
    }

    @Override
    public  CompletableFuture>> replaceDocuments(Iterable values,
                                                                                                DocumentReplaceOptions options,
                                                                                                Class type) {
        return executorAsync().execute(() -> replaceDocumentsRequest(values, options), replaceDocumentsResponseDeserializer(type));
    }

    @Override
    public CompletableFuture> updateDocument(final String key, final Object value) {
        return updateDocument(key, value, new DocumentUpdateOptions(), Void.class);
    }

    @Override
    @SuppressWarnings("unchecked")
    public  CompletableFuture> updateDocument(
            final String key, final T value, final DocumentUpdateOptions options) {
        return updateDocument(key, value, options, (Class) value.getClass());
    }

    @Override
    public  CompletableFuture> updateDocument(
            final String key, final Object value, final DocumentUpdateOptions options, final Class returnType) {
        return executorAsync().execute(() -> updateDocumentRequest(key, value, options),
                constructParametricType(DocumentUpdateEntity.class, returnType));
    }

    @Override
    public CompletableFuture>> updateDocuments(RawData values) {
        return executorAsync()
                .execute(() -> updateDocumentsRequest(values, new DocumentUpdateOptions()),
                        updateDocumentsResponseDeserializer(Void.class));
    }

    @Override
    @SuppressWarnings("unchecked")
    public CompletableFuture>> updateDocuments(RawData values,
                                                                                                 DocumentUpdateOptions options) {
        return executorAsync()
                .execute(() -> updateDocumentsRequest(values, options),
                        updateDocumentsResponseDeserializer((Class) values.getClass()));
    }

    @Override
    public CompletableFuture>> updateDocuments(final Iterable values) {
        return updateDocuments(values, new DocumentUpdateOptions());
    }

    @Override
    public CompletableFuture>> updateDocuments(
            final Iterable values, final DocumentUpdateOptions options) {
        return updateDocuments(values, options, Void.class);
    }

    @Override
    public  CompletableFuture>> updateDocuments(
            final Iterable values, final DocumentUpdateOptions options, final Class returnType) {
        return executorAsync()
                .execute(() -> updateDocumentsRequest(values, options), updateDocumentsResponseDeserializer(returnType));
    }

    @Override
    public CompletableFuture> deleteDocument(final String key) {
        return deleteDocument(key, new DocumentDeleteOptions());
    }

    @Override
    public CompletableFuture> deleteDocument(String key, DocumentDeleteOptions options) {
        return deleteDocument(key, options, Void.class);
    }

    @Override
    public  CompletableFuture> deleteDocument(
            final String key, final DocumentDeleteOptions options, final Class type) {
        return executorAsync().execute(() -> deleteDocumentRequest(key, options),
                constructParametricType(DocumentDeleteEntity.class, type));
    }

    @Override
    public CompletableFuture>> deleteDocuments(RawData values) {
        return executorAsync().execute(() -> deleteDocumentsRequest(values, new DocumentDeleteOptions()),
                deleteDocumentsResponseDeserializer(Void.class));
    }

    @Override
    @SuppressWarnings("unchecked")
    public CompletableFuture>> deleteDocuments(RawData values,
                                                                                                 DocumentDeleteOptions options) {
        return executorAsync().execute(() -> deleteDocumentsRequest(values, options),
                deleteDocumentsResponseDeserializer((Class) values.getClass()));
    }

    @Override
    public CompletableFuture>> deleteDocuments(final Iterable values) {
        return deleteDocuments(values, new DocumentDeleteOptions());
    }

    @Override
    public CompletableFuture>> deleteDocuments(
            final Iterable values, final DocumentDeleteOptions options) {
        return deleteDocuments(values, options, Void.class);
    }

    @Override
    public  CompletableFuture>> deleteDocuments(
            final Iterable values, final DocumentDeleteOptions options, final Class type) {
        return executorAsync().execute(() -> deleteDocumentsRequest(values, options), deleteDocumentsResponseDeserializer(type));
    }

    @Override
    public CompletableFuture documentExists(final String key) {
        return documentExists(key, new DocumentExistsOptions());
    }

    @Override
    public CompletableFuture documentExists(final String key, final DocumentExistsOptions options) {
        return executorAsync().execute(() -> documentExistsRequest(key, options), Void.class)
                .thenApply(it -> true)
                .exceptionally(err -> {
                    Throwable e = err instanceof CompletionException ? err.getCause() : err;
                    if (e instanceof ArangoDBException) {
                        ArangoDBException aEx = (ArangoDBException) e;
                        if (matches(aEx, 304)
                                || matches(aEx, 404)
                                || matches(aEx, 412)
                        ) {
                            return false;
                        }
                    }
                    throw ArangoDBException.of(e);
                });
    }

    @Override
    public CompletableFuture getIndex(final String id) {
        return executorAsync().execute(() -> getIndexRequest(id), IndexEntity.class);
    }

    @Override
    public CompletableFuture getInvertedIndex(String id) {
        return executorAsync().execute(() -> getIndexRequest(id), InvertedIndexEntity.class);
    }

    @Override
    public CompletableFuture deleteIndex(final String id) {
        return executorAsync().execute(() -> deleteIndexRequest(id), deleteIndexResponseDeserializer());
    }

    @Override
    public CompletableFuture ensurePersistentIndex(final Iterable fields, final PersistentIndexOptions options) {
        return executorAsync().execute(() -> createPersistentIndexRequest(fields, options), IndexEntity.class);
    }

    @Override
    public CompletableFuture ensureInvertedIndex(final InvertedIndexOptions options) {
        return executorAsync().execute(() -> createInvertedIndexRequest(options), InvertedIndexEntity.class);
    }

    @Override
    public CompletableFuture ensureGeoIndex(final Iterable fields, final GeoIndexOptions options) {
        return executorAsync().execute(() -> createGeoIndexRequest(fields, options), IndexEntity.class);
    }

    @Deprecated
    @Override
    public CompletableFuture ensureFulltextIndex(final Iterable fields, final FulltextIndexOptions options) {
        return executorAsync().execute(() -> createFulltextIndexRequest(fields, options), IndexEntity.class);
    }

    @Override
    public CompletableFuture ensureTtlIndex(final Iterable fields, final TtlIndexOptions options) {
        return executorAsync().execute(() -> createTtlIndexRequest(fields, options), IndexEntity.class);
    }

    @Override
    public CompletableFuture ensureZKDIndex(final Iterable fields, final ZKDIndexOptions options) {
        return executorAsync().execute(() -> createZKDIndexRequest(fields, options), IndexEntity.class);
    }

    @Override
    public CompletableFuture ensureMDIndex(final Iterable fields, final MDIndexOptions options) {
        return executorAsync().execute(() -> createMDIndexRequest(fields, options), IndexEntity.class);
    }

    @Override
    public CompletableFuture ensureMDPrefixedIndex(final Iterable fields, final MDPrefixedIndexOptions options) {
        return executorAsync().execute(() -> createMDIndexRequest(fields, options), IndexEntity.class);
    }

    @Override
    public CompletableFuture> getIndexes() {
        return executorAsync().execute(this::getIndexesRequest, getIndexesResponseDeserializer());
    }

    @Override
    public CompletableFuture> getInvertedIndexes() {
        return executorAsync().execute(this::getIndexesRequest, getInvertedIndexesResponseDeserializer());
    }

    @Override
    public CompletableFuture exists() {
        return getInfo()
                .thenApply(Objects::nonNull)
                .exceptionally(err -> {
                    Throwable e = err instanceof CompletionException ? err.getCause() : err;
                    if (e instanceof ArangoDBException) {
                        ArangoDBException aEx = (ArangoDBException) e;
                        if (matches(aEx, 404, ERROR_ARANGO_DATA_SOURCE_NOT_FOUND)) {
                            return false;
                        }
                    }
                    throw ArangoDBException.of(e);
                });
    }

    @Override
    public CompletableFuture truncate() {
        return truncate(null);
    }

    @Override
    public CompletableFuture truncate(CollectionTruncateOptions options) {
        return executorAsync().execute(() -> truncateRequest(options), CollectionEntity.class);
    }

    @Override
    public CompletableFuture count() {
        return count(null);
    }

    @Override
    public CompletableFuture count(CollectionCountOptions options) {
        return executorAsync().execute(() -> countRequest(options), CollectionPropertiesEntity.class);
    }

    @Override
    public CompletableFuture create() {
        return db().createCollection(name());
    }

    @Override
    public CompletableFuture create(final CollectionCreateOptions options) {
        return db().createCollection(name(), options);
    }

    @Override
    public CompletableFuture drop() {
        return executorAsync().execute(() -> dropRequest(null), Void.class);
    }

    @Override
    public CompletableFuture drop(final boolean isSystem) {
        return executorAsync().execute(() -> dropRequest(isSystem), Void.class);
    }

    @Override
    public CompletableFuture getInfo() {
        return executorAsync().execute(this::getInfoRequest, CollectionEntity.class);
    }

    @Override
    public CompletableFuture getProperties() {
        return executorAsync().execute(this::getPropertiesRequest, CollectionPropertiesEntity.class);
    }

    @Override
    public CompletableFuture changeProperties(final CollectionPropertiesOptions options) {
        return executorAsync().execute(() -> changePropertiesRequest(options), CollectionPropertiesEntity.class);
    }

    @Override
    public CompletableFuture rename(final String newName) {
        return executorAsync().execute(() -> renameRequest(newName), CollectionEntity.class);
    }

    @Override
    public CompletableFuture getResponsibleShard(final Object value) {
        return executorAsync().execute(() -> responsibleShardRequest(value), ShardEntity.class);
    }

    @Override
    public CompletableFuture getRevision() {
        return executorAsync().execute(this::getRevisionRequest, CollectionRevisionEntity.class);
    }

    @Override
    public CompletableFuture grantAccess(final String user, final Permissions permissions) {
        return executorAsync().execute(() -> grantAccessRequest(user, permissions), Void.class);
    }

    @Override
    public CompletableFuture revokeAccess(final String user) {
        return executorAsync().execute(() -> grantAccessRequest(user, Permissions.NONE), Void.class);
    }

    @Override
    public CompletableFuture resetAccess(final String user) {
        return executorAsync().execute(() -> resetAccessRequest(user), Void.class);
    }

    @Override
    public CompletableFuture getPermissions(final String user) {
        return executorAsync().execute(() -> getPermissionsRequest(user), getPermissionsResponseDeserialzer());
    }

}