org.jnosql.artemis.column.ColumnTemplateAsync Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of artemis-column Show documentation
Show all versions of artemis-column Show documentation
Eclipse JNoSQL Mapping, Artemis API, to column NoSQL databases
/*
* Copyright (c) 2017 Otávio Santana and others
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Apache License v2.0 which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php.
*
* You may elect to redistribute this code under either of these licenses.
*
* Contributors:
*
* Otavio Santana
*/
package org.jnosql.artemis.column;
import org.jnosql.artemis.IdNotFoundException;
import org.jnosql.diana.api.ExecuteAsyncQueryException;
import org.jnosql.diana.api.NonUniqueResultException;
import org.jnosql.diana.api.column.ColumnDeleteQuery;
import org.jnosql.diana.api.column.ColumnQuery;
import java.time.Duration;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.stream.StreamSupport;
import static java.util.Objects.requireNonNull;
/**
* This interface that represents the common operation between an entity
* and {@link org.jnosql.diana.api.column.ColumnEntity} to do async operations
*
* @see org.jnosql.diana.api.column.ColumnFamilyManagerAsync
*/
public interface ColumnTemplateAsync {
/**
* Inserts an entity asynchronously
*
* @param entity entity to be saved
* @param the instance type
* @throws ExecuteAsyncQueryException when there is a async error
* @throws UnsupportedOperationException when the database does not have support to insert asynchronous
* @throws NullPointerException when entity is null
*/
void insert(T entity) throws ExecuteAsyncQueryException, UnsupportedOperationException, NullPointerException;
/**
* Inserts an entity asynchronously with time to live
*
* @param entity entity to be saved
* @param ttl the time to live
* @param the instance type
* @throws ExecuteAsyncQueryException when there is a async error
* @throws UnsupportedOperationException when the database does not have support to insert asynchronous
* @throws NullPointerException when either entity or ttl are null
*/
void insert(T entity, Duration ttl) throws ExecuteAsyncQueryException, UnsupportedOperationException, NullPointerException;
/**
* Inserts entities asynchronously, by default it's just run for each saving using
* {@link ColumnTemplate#insert(Object)},
* each NoSQL vendor might replace to a more appropriate one.
*
* @param entities entities to be saved
* @param the instance type
* @throws ExecuteAsyncQueryException when there is a async error
* @throws UnsupportedOperationException when the database does not have support to insert asynchronous
* @throws NullPointerException when entities is null
*/
default void insert(Iterable entities) throws ExecuteAsyncQueryException, UnsupportedOperationException, NullPointerException {
Objects.requireNonNull(entities, "entities is required");
StreamSupport.stream(entities.spliterator(), false).forEach(this::insert);
}
/**
* Inserts entities asynchronously with time to live, by default it's just run for each saving using
* {@link ColumnTemplate#insert(Object, Duration)},
* each NoSQL vendor might replace to a more appropriate one.
*
* @param entities entities to be saved
* @param ttl time to live
* @param the instance type
* @throws ExecuteAsyncQueryException when there is a async error
* @throws UnsupportedOperationException when the database does not have support to insert asynchronous
* @throws NullPointerException when either entities or ttl are null
*/
default void insert(Iterable entities, Duration ttl) throws NullPointerException {
Objects.requireNonNull(entities, "entities is required");
Objects.requireNonNull(ttl, "ttl is required");
StreamSupport.stream(entities.spliterator(), false).forEach(d -> insert(d, ttl));
}
/**
* Inserts an entity asynchronously
*
* @param entity entity to be saved
* @param callBack the callback, when the process is finished will call this instance returning
* the saved entity within parameters
* @param the instance type
* @throws ExecuteAsyncQueryException when there is a async error
* @throws UnsupportedOperationException when the database does not have support to insert asynchronous
* @throws NullPointerException when either entity or callback are null
*/
void insert(T entity, Consumer callBack) throws
ExecuteAsyncQueryException, UnsupportedOperationException, NullPointerException;
/**
* Inserts an entity asynchronously with time to live
*
* @param entity entity to be saved
* @param ttl time to live
* @param callBack the callback, when the process is finished will call this instance returning
* the saved entity within parameters
* @param the instance type
* @throws ExecuteAsyncQueryException when there is a async error
* @throws UnsupportedOperationException when the database does not have support to insert asynchronous
* @throws NullPointerException when either entity or ttl or callback are null
*/
void insert(T entity, Duration ttl, Consumer callBack) throws
ExecuteAsyncQueryException, UnsupportedOperationException, NullPointerException;
/**
* Inserts an entity asynchronously
*
* @param entity entity to be updated
* @param the instance type
* @throws ExecuteAsyncQueryException when there is a async error
* @throws UnsupportedOperationException when the database does not have support to insert asynchronous
* @throws NullPointerException when entity is null
*/
void update(T entity) throws ExecuteAsyncQueryException, UnsupportedOperationException, NullPointerException;
/**
* Inserts entities asynchronously, by default it's just run for each saving using
* {@link ColumnTemplate#update(Object)},
* each NoSQL vendor might replace to a more appropriate one.
*
* @param entities entities to be saved
* @param the instance type
* @throws ExecuteAsyncQueryException when there is a async error
* @throws UnsupportedOperationException when the database does not have support to insert asynchronous
* @throws NullPointerException when entities is null
*/
default void update(Iterable entities) throws ExecuteAsyncQueryException, UnsupportedOperationException, NullPointerException {
Objects.requireNonNull(entities, "entities is required");
StreamSupport.stream(entities.spliterator(), false).forEach(this::update);
}
/**
* Inserts an entity asynchronously
*
* @param entity entity to be updated
* @param callBack the callback, when the process is finished will call this instance returning
* the updated entity within parametersa
* @param the instance type
* @throws ExecuteAsyncQueryException when there is a async error
* @throws UnsupportedOperationException when the database does not have support to insert asynchronous
* @throws NullPointerException when either entity or callback are null
*/
void update(T entity, Consumer callBack) throws
ExecuteAsyncQueryException, UnsupportedOperationException, NullPointerException;
/**
* Deletes an entity asynchronously
*
* @param query query to delete an entity
* @throws ExecuteAsyncQueryException when there is a async error
* @throws UnsupportedOperationException when the database does not have support to insert asynchronous
* @throws NullPointerException when query are null
*/
void delete(ColumnDeleteQuery query) throws ExecuteAsyncQueryException, UnsupportedOperationException, NullPointerException;
/**
* Deletes an entity asynchronously
*
* @param query query to delete an entity
* @param callBack the callback, when the process is finished will call this instance returning
* the null within parameters
* @throws ExecuteAsyncQueryException when there is a async error
* @throws UnsupportedOperationException when the database does not have support to delete asynchronous
* @throws NullPointerException when either query or callback are null
*/
void delete(ColumnDeleteQuery query, Consumer callBack) throws ExecuteAsyncQueryException,
UnsupportedOperationException, NullPointerException;
/**
* Finds entities from query asynchronously
*
* @param query query to select entities
* @param the instance type
* @param callBack the callback, when the process is finished will call this instance returning
* the result of query within parameters
* @throws ExecuteAsyncQueryException when there is a async error
* @throws UnsupportedOperationException when the database does not have support to insert asynchronous
* @throws NullPointerException when either query or callback are null
*/
void select(ColumnQuery query, Consumer> callBack) throws
ExecuteAsyncQueryException, UnsupportedOperationException, NullPointerException;
/**
* Finds by Id.
*
* @param entityClass the entity class
* @param id the id value
* @param the entity class type
* @param the id type
* @param callBack the callBack
* @throws NullPointerException when either the entityClass or id are null
* @throws IdNotFoundException when the entityClass does not have the Id annotation
*/
void find(Class entityClass, ID id, Consumer> callBack) throws
NullPointerException, IdNotFoundException;
/**
* Deletes by Id.
*
* @param entityClass the entity class
* @param id the id value
* @param the entity class type
* @param the id type
* @param callBack the callBack
* @throws NullPointerException when either the entityClass or id are null
* @throws IdNotFoundException when the entityClass does not have the Id annotation
*/
void delete(Class entityClass, ID id, Consumer callBack) throws
NullPointerException, IdNotFoundException;
/**
* Deletes by Id.
*
* @param entityClass the entity class
* @param id the id value
* @param the entity class type
* @param the id type
* @throws NullPointerException when either the entityClass or id are null
* @throws IdNotFoundException when the entityClass does not have the Id annotation
*/
void delete(Class entityClass, ID id) throws
NullPointerException, IdNotFoundException;
/**
* Execute a query to consume an unique result
*
* @param query the query
* @param callBack the callback
* @param the type
* @throws ExecuteAsyncQueryException when there is a async error
* @throws UnsupportedOperationException when the database does not have support to insert asynchronous
* @throws NullPointerException when either query or callback are null
* @throws NonUniqueResultException when it returns more than one result
*/
default void singleResult(ColumnQuery query, Consumer> callBack) throws
ExecuteAsyncQueryException, UnsupportedOperationException, NullPointerException, NonUniqueResultException {
requireNonNull(callBack, "callBack is required");
Consumer> singleCallBack = entities -> {
if (entities.isEmpty()) {
callBack.accept(Optional.empty());
} else if (entities.size() == 1) {
callBack.accept(Optional.of(entities.get(0)));
} else {
throw new NonUniqueResultException("The query returns more than one entity, query: " + query);
}
};
select(query, singleCallBack);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy