All Downloads are FREE. Search and download functionalities are using the official Maven repository.

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

There is a newer version: 7.16.0
Show newest version
/*
 * DISCLAIMER
 *
 * Copyright 2016 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.*;
import com.arangodb.entity.*;
import com.arangodb.entity.arangosearch.analyzer.SearchAnalyzer;
import com.arangodb.internal.cursor.ArangoCursorAsyncImpl;
import com.arangodb.internal.net.HostHandle;
import com.arangodb.model.*;
import com.arangodb.model.arangosearch.AnalyzerDeleteOptions;
import com.arangodb.model.arangosearch.ArangoSearchCreateOptions;
import com.arangodb.model.arangosearch.SearchAliasCreateOptions;

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

import static com.arangodb.internal.ArangoErrors.ERROR_ARANGO_DATABASE_NOT_FOUND;
import static com.arangodb.internal.ArangoErrors.matches;
import static com.arangodb.internal.serde.SerdeUtils.constructListType;

/**
 * @author Mark Vollmary
 * @author Michele Rastelli
 */
public class ArangoDatabaseAsyncImpl extends InternalArangoDatabase implements ArangoDatabaseAsync {

    private final ArangoDBAsync arangoDB;

    protected ArangoDatabaseAsyncImpl(final ArangoDBAsyncImpl arangoDB, final String name) {
        super(arangoDB, name);
        this.arangoDB = arangoDB;
    }

    @Override
    public ArangoDBAsync arango() {
        return arangoDB;
    }

    @Override
    public CompletableFuture getVersion() {
        return executorAsync().execute(this::getVersionRequest, ArangoDBVersion.class);
    }

    @Override
    public CompletableFuture getEngine() {
        return executorAsync().execute(this::getEngineRequest, ArangoDBEngine.class);
    }

    @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_DATABASE_NOT_FOUND)) {
                            return false;
                        }
                    }
                    throw ArangoDBException.of(e);
                });
    }

    @Override
    public CompletableFuture> getAccessibleDatabases() {
        return executorAsync().execute(this::getAccessibleDatabasesRequest, getDatabaseResponseDeserializer());
    }

    @Override
    public ArangoCollectionAsync collection(String name) {
        return new ArangoCollectionAsyncImpl(this, name);
    }

    @Override
    public CompletableFuture createCollection(final String name) {
        return executorAsync().execute(() -> createCollectionRequest(name, new CollectionCreateOptions()), CollectionEntity.class);
    }

    @Override
    public CompletableFuture createCollection(final String name, final CollectionCreateOptions options) {
        return executorAsync().execute(() -> createCollectionRequest(name, options), CollectionEntity.class);
    }

    @Override
    public CompletableFuture> getCollections() {
        return executorAsync()
                .execute(() -> getCollectionsRequest(new CollectionsReadOptions()), getCollectionsResponseDeserializer());
    }

    @Override
    public CompletableFuture> getCollections(final CollectionsReadOptions options) {
        return executorAsync().execute(() -> getCollectionsRequest(options), getCollectionsResponseDeserializer());
    }

    @Override
    public CompletableFuture getIndex(final String id) {
        final String[] split = id.split("/");
        return collection(split[0]).getIndex(split[1]);
    }

    @Override
    public CompletableFuture deleteIndex(final String id) {
        final String[] split = id.split("/");
        return collection(split[0]).deleteIndex(split[1]);
    }

    @Override
    public CompletableFuture create() {
        return arango().createDatabase(name());
    }

    @Override
    public CompletableFuture drop() {
        return executorAsync().execute(this::dropRequest, createDropResponseDeserializer());
    }

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

    @Override
    public CompletableFuture grantAccess(final String user) {
        return executorAsync().execute(() -> grantAccessRequest(user, Permissions.RW), 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 grantDefaultCollectionAccess(final String user, final Permissions permissions) {
        return executorAsync().execute(() -> updateUserDefaultCollectionAccessRequest(user, permissions), Void.class);
    }

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

    @Override
    public  CompletableFuture> query(
            final String query, final Class type, final Map bindVars, final AqlQueryOptions options) {
        final InternalRequest request = queryRequest(query, bindVars, options);
        final HostHandle hostHandle = new HostHandle();
        return executorAsync().execute(() -> request, cursorEntityDeserializer(type), hostHandle)
                .thenApply(res -> new ArangoCursorAsyncImpl<>(this, res, type, hostHandle, options.getAllowRetry()));
    }

    @Override
    public  CompletableFuture> query(String query, Class type, AqlQueryOptions options) {
        return query(query, type, null, options);
    }

    @Override
    public  CompletableFuture> query(String query, Class type, Map bindVars) {
        return query(query, type, bindVars, new AqlQueryOptions());
    }

    @Override
    public  CompletableFuture> query(String query, Class type) {
        return query(query, type, null, new AqlQueryOptions());
    }

    @Override
    public  CompletableFuture> cursor(final String cursorId, final Class type) {
        return cursor(cursorId, type, null, new AqlQueryOptions());
    }

    @Override
    public  CompletableFuture> cursor(String cursorId, Class type, AqlQueryOptions options) {
        return cursor(cursorId, type, null, options);
    }

    @Override
    public  CompletableFuture> cursor(final String cursorId, final Class type, final String nextBatchId) {
        return cursor(cursorId, type, nextBatchId, new AqlQueryOptions());
    }

    @Override
    public  CompletableFuture> cursor(String cursorId, Class type, String nextBatchId, AqlQueryOptions options) {
        options.allowRetry(nextBatchId != null);
        HostHandle hostHandle = new HostHandle();
        return executorAsync()
                .execute(() -> queryNextRequest(cursorId, options, nextBatchId),
                        cursorEntityDeserializer(type),
                        hostHandle)
                .thenApply(res -> new ArangoCursorAsyncImpl<>(this, res, type, hostHandle, nextBatchId != null));
    }

    @Override
    public CompletableFuture explainQuery(
            final String query, final Map bindVars, final AqlQueryExplainOptions options) {
        return executorAsync().execute(() -> explainQueryRequest(query, bindVars, options), AqlExecutionExplainEntity.class);
    }

    @Override
    public CompletableFuture explainAqlQuery(
            String query, Map bindVars, AqlQueryExplainOptions options) {
        return executorAsync().execute(() -> explainQueryRequest(query, bindVars, options), AqlQueryExplainEntity.class);
    }

    @Override
    public CompletableFuture explainAqlQuery(String query, Map bindVars, ExplainAqlQueryOptions options) {
        return executorAsync().execute(() -> explainQueryRequest(query, bindVars, options), AqlQueryExplainEntity.class);
    }

    @Override
    public CompletableFuture parseQuery(final String query) {
        return executorAsync().execute(() -> parseQueryRequest(query), AqlParseEntity.class);
    }

    @Override
    public CompletableFuture clearQueryCache() {
        return executorAsync().execute(this::clearQueryCacheRequest, Void.class);
    }

    @Override
    public CompletableFuture getQueryCacheProperties() {
        return executorAsync().execute(this::getQueryCachePropertiesRequest, QueryCachePropertiesEntity.class);
    }

    @Override
    public CompletableFuture setQueryCacheProperties(final QueryCachePropertiesEntity properties) {
        return executorAsync().execute(() -> setQueryCachePropertiesRequest(properties), QueryCachePropertiesEntity.class);
    }

    @Override
    public CompletableFuture getQueryTrackingProperties() {
        return executorAsync().execute(this::getQueryTrackingPropertiesRequest, QueryTrackingPropertiesEntity.class);
    }

    @Override
    public CompletableFuture setQueryTrackingProperties(final QueryTrackingPropertiesEntity properties) {
        return executorAsync().execute(() -> setQueryTrackingPropertiesRequest(properties), QueryTrackingPropertiesEntity.class);
    }

    @Override
    public CompletableFuture> getCurrentlyRunningQueries() {
        return executorAsync().execute(this::getCurrentlyRunningQueriesRequest,
                constructListType(QueryEntity.class));
    }

    @Override
    public CompletableFuture> getSlowQueries() {
        return executorAsync().execute(this::getSlowQueriesRequest,
                constructListType(QueryEntity.class));
    }

    @Override
    public CompletableFuture clearSlowQueries() {
        return executorAsync().execute(this::clearSlowQueriesRequest, Void.class);
    }

    @Override
    public CompletableFuture killQuery(final String id) {
        return executorAsync().execute(() -> killQueryRequest(id), Void.class);
    }

    @Override
    public CompletableFuture createAqlFunction(
            final String name, final String code, final AqlFunctionCreateOptions options) {
        return executorAsync().execute(() -> createAqlFunctionRequest(name, code, options), Void.class);
    }

    @Override
    public CompletableFuture deleteAqlFunction(final String name, final AqlFunctionDeleteOptions options) {
        return executorAsync().execute(() -> deleteAqlFunctionRequest(name, options), deleteAqlFunctionResponseDeserializer());
    }

    @Override
    public CompletableFuture> getAqlFunctions(final AqlFunctionGetOptions options) {
        return executorAsync().execute(() -> getAqlFunctionsRequest(options), getAqlFunctionsResponseDeserializer());
    }

    @Override
    public ArangoGraphAsync graph(final String name) {
        return new ArangoGraphAsyncImpl(this, name);
    }

    @Override
    public CompletableFuture createGraph(final String name, final Iterable edgeDefinitions) {
        return createGraph(name, edgeDefinitions, new GraphCreateOptions());
    }

    @Override
    public CompletableFuture createGraph(
            final String name, final Iterable edgeDefinitions, final GraphCreateOptions options) {
        return executorAsync().execute(() -> createGraphRequest(name, edgeDefinitions, options), createGraphResponseDeserializer());
    }

    @Override
    public CompletableFuture> getGraphs() {
        return executorAsync().execute(this::getGraphsRequest, getGraphsResponseDeserializer());
    }

    @Override
    public  CompletableFuture transaction(final String action, final Class type, final TransactionOptions options) {
        return executorAsync().execute(() -> transactionRequest(action, options), transactionResponseDeserializer(type));
    }

    @Override
    public CompletableFuture beginStreamTransaction(StreamTransactionOptions options) {
        return executorAsync().execute(() -> beginStreamTransactionRequest(options), streamTransactionResponseDeserializer());
    }

    @Override
    public CompletableFuture abortStreamTransaction(String id) {
        return executorAsync().execute(() -> abortStreamTransactionRequest(id), streamTransactionResponseDeserializer());
    }

    @Override
    public CompletableFuture getStreamTransaction(String id) {
        return executorAsync().execute(() -> getStreamTransactionRequest(id), streamTransactionResponseDeserializer());
    }

    @Override
    public CompletableFuture> getStreamTransactions() {
        return executorAsync().execute(this::getStreamTransactionsRequest, transactionsResponseDeserializer());
    }

    @Override
    public CompletableFuture commitStreamTransaction(String id) {
        return executorAsync().execute(() -> commitStreamTransactionRequest(id), streamTransactionResponseDeserializer());
    }

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

    @Override
    public CompletableFuture reloadRouting() {
        return executorAsync().execute(this::reloadRoutingRequest, Void.class);
    }

    @Override
    public CompletableFuture> getViews() {
        return executorAsync().execute(this::getViewsRequest, getViewsResponseDeserializer());
    }

    @Override
    public ArangoViewAsync view(final String name) {
        return new ArangoViewAsyncImpl(this, name);
    }

    @Override
    public ArangoSearchAsync arangoSearch(final String name) {
        return new ArangoSearchAsyncImpl(this, name);
    }

    @Override
    public SearchAliasAsync searchAlias(String name) {
        return new SearchAliasAsyncImpl(this, name);
    }

    @Override
    public CompletableFuture createView(final String name, final ViewType type) {
        return executorAsync().execute(() -> createViewRequest(name, type), ViewEntity.class);
    }

    @Override
    public CompletableFuture createArangoSearch(final String name, final ArangoSearchCreateOptions options) {
        return executorAsync().execute(() -> createArangoSearchRequest(name, options), ViewEntity.class);
    }

    @Override
    public CompletableFuture createSearchAlias(String name, SearchAliasCreateOptions options) {
        return executorAsync().execute(() -> createSearchAliasRequest(name, options), ViewEntity.class);
    }

    @Override
    public CompletableFuture createSearchAnalyzer(SearchAnalyzer analyzer) {
        return executorAsync().execute(() -> createAnalyzerRequest(analyzer), SearchAnalyzer.class);
    }

    @Override
    public CompletableFuture getSearchAnalyzer(String name) {
        return executorAsync().execute(() -> getAnalyzerRequest(name), SearchAnalyzer.class);
    }

    @Override
    public CompletableFuture> getSearchAnalyzers() {
        return executorAsync().execute(this::getAnalyzersRequest, getSearchAnalyzersResponseDeserializer());
    }

    @Override
    public CompletableFuture deleteSearchAnalyzer(String name) {
        return deleteSearchAnalyzer(name, null);
    }

    @Override
    public CompletableFuture deleteSearchAnalyzer(String name, AnalyzerDeleteOptions options) {
        return executorAsync().execute(() -> deleteAnalyzerRequest(name, options), Void.class);
    }

}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy