java.lang.Object
- io.vertx.up.uca.jooq.UxJooq

public final class UxJooq
extends Object

Constructor Summary

Constructors
Constructor Description

UxJooq(Class<T> clazz, JooqDsl dsl)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`JqAnalyzer`	`analyzer()`
`BigDecimal`	`avg(String field)`
`BigDecimal`	`avg(String field, io.vertx.core.json.JsonObject criteria)`
`BigDecimal`	`avg(String field, io.vertx.core.json.JsonObject criteria, String pojo)`
`io.vertx.core.Future<BigDecimal>`	`avgAsync(String field)`
`io.vertx.core.Future<BigDecimal>`	`avgAsync(String field, io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.Future<BigDecimal>`	`avgAsync(String field, io.vertx.core.json.JsonObject criteria, String pojo)`
`ConcurrentMap<String,BigDecimal>`	`avgBy(String field, io.vertx.core.json.JsonObject criteria, String groupField)`
`io.vertx.core.json.JsonArray`	`avgBy(String field, io.vertx.core.json.JsonObject criteria, String... groupFields)`
`ConcurrentMap<String,BigDecimal>`	`avgBy(String field, String groupField)`
`io.vertx.core.json.JsonArray`	`avgBy(String field, String... groupFields)`
`io.vertx.core.Future<ConcurrentMap<String,BigDecimal>>`	`avgByAsync(String field, io.vertx.core.json.JsonObject criteria, String groupField)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`avgByAsync(String field, io.vertx.core.json.JsonObject criteria, String... groupFields)`
`io.vertx.core.Future<ConcurrentMap<String,BigDecimal>>`	`avgByAsync(String field, String groupField)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`avgByAsync(String field, String... groupFields)`
`Set<String>`	`columns()`
`Long`	`count(io.vertx.core.json.JsonObject criteria)`
`Long`	`count(io.vertx.core.json.JsonObject criteria, String pojo)`
`Long`	`countAll()`
`io.vertx.core.Future<Long>`	`countAllAsync()`
`io.vertx.core.Future<Long>`	`countAsync(io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.Future<Long>`	`countAsync(io.vertx.core.json.JsonObject criteria, String pojo)`
`ConcurrentMap<String,Integer>`	`countBy(io.vertx.core.json.JsonObject criteria, String groupField)`
`io.vertx.core.json.JsonArray`	`countBy(io.vertx.core.json.JsonObject criteria, String... groupFields)`
`ConcurrentMap<String,Integer>`	`countBy(String groupField)`
`io.vertx.core.json.JsonArray`	`countBy(String... groupFields)`
`io.vertx.core.Future<ConcurrentMap<String,Integer>>`	`countByAsync(io.vertx.core.json.JsonObject criteria, String groupField)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`countByAsync(io.vertx.core.json.JsonObject criteria, String... groupFields)`
`io.vertx.core.Future<ConcurrentMap<String,Integer>>`	`countByAsync(String groupField)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`countByAsync(String... groupFields)`
`<T> List<T>`	`delete(io.vertx.core.json.JsonArray data)`
`<T> List<T>`	`delete(io.vertx.core.json.JsonArray data, String pojo)`
`<T> T`	`delete(io.vertx.core.json.JsonObject data)`
`<T> T`	`delete(io.vertx.core.json.JsonObject data, String pojo)`
`<T> List<T>`	`delete(List<T> entity)`
`<T> T`	`delete(T entity)`
`<T> io.vertx.core.Future<List<T>>`	`deleteAsync(io.vertx.core.json.JsonArray data)`
`<T> io.vertx.core.Future<List<T>>`	`deleteAsync(io.vertx.core.json.JsonArray data, String pojo)`
`<T,ID> io.vertx.core.Future<T>`	`deleteAsync(io.vertx.core.json.JsonObject data)`
`<T,ID> io.vertx.core.Future<T>`	`deleteAsync(io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.Future<List<T>>`	`deleteAsync(List<T> entity)`
`<T,ID> io.vertx.core.Future<T>`	`deleteAsync(T entity)`
`Boolean`	`deleteBy(io.vertx.core.json.JsonObject criteria)`
`Boolean`	`deleteBy(io.vertx.core.json.JsonObject criteria, String pojo)`
`io.vertx.core.Future<Boolean>`	`deleteByAsync(io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.Future<Boolean>`	`deleteByAsync(io.vertx.core.json.JsonObject criteria, String pojo)`
`Boolean`	`deleteById(Object id)`
`Boolean`	`deleteById(Collection<Object> ids)`
`io.vertx.core.Future<Boolean>`	`deleteByIdAsync(Object id)`
`io.vertx.core.Future<Boolean>`	`deleteByIdAsync(Collection<Object> ids)`
`<T> io.vertx.core.json.JsonArray`	`deleteJ(io.vertx.core.json.JsonArray data)`
`<T> io.vertx.core.json.JsonArray`	`deleteJ(io.vertx.core.json.JsonArray data, String pojo)`
`<T> io.vertx.core.json.JsonObject`	`deleteJ(io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.json.JsonObject`	`deleteJ(io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.json.JsonArray`	`deleteJ(List<T> entity)`
`<T> io.vertx.core.json.JsonObject`	`deleteJ(T entity)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`deleteJAsync(io.vertx.core.json.JsonArray data)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`deleteJAsync(io.vertx.core.json.JsonArray data, String pojo)`
`<T,ID> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`deleteJAsync(io.vertx.core.json.JsonObject data)`
`<T,ID> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`deleteJAsync(io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`deleteJAsync(List<T> entity)`
`<T,ID> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`deleteJAsync(T entity)`
`Boolean`	`exist(io.vertx.core.json.JsonObject criteria)`
`Boolean`	`exist(io.vertx.core.json.JsonObject criteria, String pojo)`
`io.vertx.core.Future<Boolean>`	`existAsync(io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.Future<Boolean>`	`existAsync(io.vertx.core.json.JsonObject criteria, String pojo)`
`Boolean`	`existById(Object id)`
`io.vertx.core.Future<Boolean>`	`existByIdAsync(Object id)`
`<T> List<T>`	`fetch(io.vertx.core.json.JsonObject criteria)`
`<T> List<T>`	`fetch(io.vertx.core.json.JsonObject criteria, String pojo)`
`<T> List<T>`	`fetch(String field, Object value)`
`<T> List<T>`	`fetchAll()`
`<T> io.vertx.core.Future<List<T>>`	`fetchAllAsync()`
`<T> List<T>`	`fetchAnd(io.vertx.core.json.JsonObject criteria)`
`<T> List<T>`	`fetchAnd(io.vertx.core.json.JsonObject criteria, String pojo)`
`<T> io.vertx.core.Future<List<T>>`	`fetchAndAsync(io.vertx.core.json.JsonObject criteria)`
`<T> io.vertx.core.Future<List<T>>`	`fetchAndAsync(io.vertx.core.json.JsonObject criteria, String pojo)`
`<T> io.vertx.core.Future<List<T>>`	`fetchAsync(io.vertx.core.json.JsonObject criteria)`
`<T> io.vertx.core.Future<List<T>>`	`fetchAsync(io.vertx.core.json.JsonObject criteria, String pojo)`
`<T> io.vertx.core.Future<List<T>>`	`fetchAsync(String field, Object value)`
`<T> T`	`fetchById(Object id)`
`<T> io.vertx.core.Future<T>`	`fetchByIdAsync(Object id)`
`<T> List<T>`	`fetchIn(String field, io.vertx.core.json.JsonArray values)`
`<T> List<T>`	`fetchIn(String field, Object... values)`
`<T,K> List<T>`	`fetchIn(String field, Collection<K> collection)`
`<T> io.vertx.core.Future<List<T>>`	`fetchInAsync(String field, io.vertx.core.json.JsonArray values)`
`<T> io.vertx.core.Future<List<T>>`	`fetchInAsync(String field, Object... value)`
`<T,K> io.vertx.core.Future<List<T>>`	`fetchInAsync(String field, Collection<K> collection)`
`io.vertx.core.json.JsonArray`	`fetchJ(io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.json.JsonArray`	`fetchJ(io.vertx.core.json.JsonObject criteria, String pojo)`
`io.vertx.core.json.JsonArray`	`fetchJ(String field, Object value)`
`io.vertx.core.json.JsonArray`	`fetchJAll()`
`io.vertx.core.json.JsonArray`	`fetchJAll(String pojo)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`fetchJAllAsync()`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`fetchJAllAsync(String pojo)`
`io.vertx.core.json.JsonArray`	`fetchJAnd(io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.json.JsonArray`	`fetchJAnd(io.vertx.core.json.JsonObject criteria, String pojo)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`fetchJAndAsync(io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`fetchJAndAsync(io.vertx.core.json.JsonObject criteria, String pojo)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`fetchJAsync(io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`fetchJAsync(io.vertx.core.json.JsonObject criteria, String pojo)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`fetchJAsync(String field, Object value)`
`<T> io.vertx.core.json.JsonObject`	`fetchJById(Object id)`
`io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`fetchJByIdAsync(Object id)`
`io.vertx.core.json.JsonArray`	`fetchJIn(String field, io.vertx.core.json.JsonArray values)`
`io.vertx.core.json.JsonArray`	`fetchJIn(String field, Object... values)`
`<K> io.vertx.core.json.JsonArray`	`fetchJIn(String field, Collection<K> collection)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`fetchJInAsync(String field, io.vertx.core.json.JsonArray values)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`fetchJInAsync(String field, Object... value)`
`<K> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`fetchJInAsync(String field, Collection<K> collection)`
`<T> io.vertx.core.json.JsonObject`	`fetchJOne(io.vertx.core.json.JsonObject criteria)`
`<T> io.vertx.core.json.JsonObject`	`fetchJOne(io.vertx.core.json.JsonObject criteria, String pojo)`
`<T> io.vertx.core.json.JsonObject`	`fetchJOne(String field, Object value)`
`io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`fetchJOneAsync(io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`fetchJOneAsync(io.vertx.core.json.JsonObject criteria, String pojo)`
`io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`fetchJOneAsync(String field, Object value)`
`io.vertx.core.json.JsonArray`	`fetchJOr(io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.json.JsonArray`	`fetchJOr(io.vertx.core.json.JsonObject criteria, String pojo)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`fetchJOrAsync(io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`fetchJOrAsync(io.vertx.core.json.JsonObject criteria, String pojo)`
`<T> T`	`fetchOne(io.vertx.core.json.JsonObject criteria)`
`<T> T`	`fetchOne(io.vertx.core.json.JsonObject criteria, String pojo)`
`<T> T`	`fetchOne(String field, Object value)`
`<T> io.vertx.core.Future<T>`	`fetchOneAsync(io.vertx.core.json.JsonObject criteria)`
`<T> io.vertx.core.Future<T>`	`fetchOneAsync(io.vertx.core.json.JsonObject criteria, String pojo)`
`<T> io.vertx.core.Future<T>`	`fetchOneAsync(String field, Object value)`
`<T> List<T>`	`fetchOr(io.vertx.core.json.JsonObject criteria)`
`<T> List<T>`	`fetchOr(io.vertx.core.json.JsonObject criteria, String pojo)`
`<T> io.vertx.core.Future<List<T>>`	`fetchOrAsync(io.vertx.core.json.JsonObject criteria)`
`<T> io.vertx.core.Future<List<T>>`	`fetchOrAsync(io.vertx.core.json.JsonObject criteria, String pojo)`
`<T> ConcurrentMap<String,List<T>>`	`group(io.vertx.core.json.JsonObject criteria, String field)`
`<T> ConcurrentMap<String,List<T>>`	`group(String field)`
`<T> io.vertx.core.Future<ConcurrentMap<String,List<T>>>`	`groupAsync(io.vertx.core.json.JsonObject criteria, String field)`
`<T> io.vertx.core.Future<ConcurrentMap<String,List<T>>>`	`groupAsync(String field)`
`<T> ConcurrentMap<String,io.vertx.core.json.JsonArray>`	`groupJ(io.vertx.core.json.JsonObject criteria, String field)`
`<T> ConcurrentMap<String,io.vertx.core.json.JsonArray>`	`groupJ(String field)`
`<T> io.vertx.core.Future<ConcurrentMap<String,io.vertx.core.json.JsonArray>>`	`groupJAsync(io.vertx.core.json.JsonObject criteria, String field)`
`<T> io.vertx.core.Future<ConcurrentMap<String,io.vertx.core.json.JsonArray>>`	`groupJAsync(String field)`
`<T> List<T>`	`insert(io.vertx.core.json.JsonArray data)`
`<T> List<T>`	`insert(io.vertx.core.json.JsonArray data, String pojo)`
`<T> T`	`insert(io.vertx.core.json.JsonObject data)`
`<T> T`	`insert(io.vertx.core.json.JsonObject data, String pojo)`
`<T> List<T>`	`insert(List<T> entities)`
`<T> T`	`insert(T entity)`
`<T> io.vertx.core.Future<List<T>>`	`insertAsync(io.vertx.core.json.JsonArray input)`
`<T> io.vertx.core.Future<List<T>>`	`insertAsync(io.vertx.core.json.JsonArray input, String pojo)`
`<T> io.vertx.core.Future<T>`	`insertAsync(io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.Future<T>`	`insertAsync(io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.Future<List<T>>`	`insertAsync(List<T> entities)`
`<T> io.vertx.core.Future<T>`	`insertAsync(T entity)`
`io.vertx.core.json.JsonArray`	`insertJ(io.vertx.core.json.JsonArray data)`
`<T> io.vertx.core.json.JsonArray`	`insertJ(io.vertx.core.json.JsonArray data, String pojo)`
`<T> io.vertx.core.json.JsonObject`	`insertJ(io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.json.JsonObject`	`insertJ(io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.json.JsonArray`	`insertJ(List<T> list)`
`<T> io.vertx.core.json.JsonObject`	`insertJ(T entity)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`insertJAsync(io.vertx.core.json.JsonArray input)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`insertJAsync(io.vertx.core.json.JsonArray input, String pojo)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`insertJAsync(io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`insertJAsync(io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`insertJAsync(List<T> list)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`insertJAsync(T entity)`
`BigDecimal`	`max(String field)`
`BigDecimal`	`max(String field, io.vertx.core.json.JsonObject criteria)`
`BigDecimal`	`max(String field, io.vertx.core.json.JsonObject criteria, String pojo)`
`io.vertx.core.Future<BigDecimal>`	`maxAsync(String field)`
`io.vertx.core.Future<BigDecimal>`	`maxAsync(String field, io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.Future<BigDecimal>`	`maxAsync(String field, io.vertx.core.json.JsonObject criteria, String pojo)`
`ConcurrentMap<String,BigDecimal>`	`maxBy(String field, io.vertx.core.json.JsonObject criteria, String groupField)`
`io.vertx.core.json.JsonArray`	`maxBy(String field, io.vertx.core.json.JsonObject criteria, String... groupFields)`
`ConcurrentMap<String,BigDecimal>`	`maxBy(String field, String groupField)`
`io.vertx.core.json.JsonArray`	`maxBy(String field, String... groupFields)`
`io.vertx.core.Future<ConcurrentMap<String,BigDecimal>>`	`maxByAsync(String field, io.vertx.core.json.JsonObject criteria, String groupField)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`maxByAsync(String field, io.vertx.core.json.JsonObject criteria, String... groupFields)`
`io.vertx.core.Future<ConcurrentMap<String,BigDecimal>>`	`maxByAsync(String field, String groupField)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`maxByAsync(String field, String... groupFields)`
`BigDecimal`	`min(String field)`
`BigDecimal`	`min(String field, io.vertx.core.json.JsonObject criteria)`
`BigDecimal`	`min(String field, io.vertx.core.json.JsonObject criteria, String pojo)`
`io.vertx.core.Future<BigDecimal>`	`minAsync(String field)`
`io.vertx.core.Future<BigDecimal>`	`minAsync(String field, io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.Future<BigDecimal>`	`minAsync(String field, io.vertx.core.json.JsonObject criteria, String pojo)`
`ConcurrentMap<String,BigDecimal>`	`minBy(String field, io.vertx.core.json.JsonObject criteria, String groupField)`
`io.vertx.core.json.JsonArray`	`minBy(String field, io.vertx.core.json.JsonObject criteria, String... groupFields)`
`ConcurrentMap<String,BigDecimal>`	`minBy(String field, String groupField)`
`io.vertx.core.json.JsonArray`	`minBy(String field, String... groupFields)`
`io.vertx.core.Future<ConcurrentMap<String,BigDecimal>>`	`minByAsync(String field, io.vertx.core.json.JsonObject criteria, String groupField)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`minByAsync(String field, io.vertx.core.json.JsonObject criteria, String... groupFields)`
`io.vertx.core.Future<ConcurrentMap<String,BigDecimal>>`	`minByAsync(String field, String groupField)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`minByAsync(String field, String... groupFields)`
`Boolean`	`miss(io.vertx.core.json.JsonObject criteria)`
`Boolean`	`miss(io.vertx.core.json.JsonObject criteria, String pojo)`
`io.vertx.core.Future<Boolean>`	`missAsync(io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.Future<Boolean>`	`missAsync(io.vertx.core.json.JsonObject criteria, String pojo)`
`Boolean`	`missById(Object id)`
`io.vertx.core.Future<Boolean>`	`missByIdAsync(Object id)`
`UxJooq`	`on(Format format)`
`UxJooq`	`on(String pojo)`
`io.vertx.core.json.JsonObject`	`search(io.vertx.core.json.JsonObject params)`
`io.vertx.core.json.JsonObject`	`search(io.vertx.core.json.JsonObject params, String pojo)`
`io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`searchAsync(io.vertx.core.json.JsonObject params)`
`io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`searchAsync(io.vertx.core.json.JsonObject params, String pojo)`
`BigDecimal`	`sum(String field)`
`BigDecimal`	`sum(String field, io.vertx.core.json.JsonObject criteria)`
`BigDecimal`	`sum(String field, io.vertx.core.json.JsonObject criteria, String pojo)`
`io.vertx.core.Future<BigDecimal>`	`sumAsync(String field)`
`io.vertx.core.Future<BigDecimal>`	`sumAsync(String field, io.vertx.core.json.JsonObject criteria)`
`io.vertx.core.Future<BigDecimal>`	`sumAsync(String field, io.vertx.core.json.JsonObject criteria, String pojo)`
`ConcurrentMap<String,BigDecimal>`	`sumBy(String field, io.vertx.core.json.JsonObject criteria, String groupField)`
`io.vertx.core.json.JsonArray`	`sumBy(String field, io.vertx.core.json.JsonObject criteria, String... groupFields)`
`ConcurrentMap<String,BigDecimal>`	`sumBy(String field, String groupField)`
`io.vertx.core.json.JsonArray`	`sumBy(String field, String... groupFields)`
`io.vertx.core.Future<ConcurrentMap<String,BigDecimal>>`	`sumByAsync(String field, io.vertx.core.json.JsonObject criteria, String groupField)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`sumByAsync(String field, io.vertx.core.json.JsonObject criteria, String... groupFields)`
`io.vertx.core.Future<ConcurrentMap<String,BigDecimal>>`	`sumByAsync(String field, String groupField)`
`io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`sumByAsync(String field, String... groupFields)`
`String`	`table()`
`<T> List<T>`	`update(io.vertx.core.json.JsonArray data)`
`<T> List<T>`	`update(io.vertx.core.json.JsonArray data, String pojo)`
`<T> T`	`update(io.vertx.core.json.JsonObject data)`
`<T> T`	`update(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data)`
`<T> T`	`update(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data, String pojo)`
`<T> T`	`update(io.vertx.core.json.JsonObject data, String pojo)`
`<T> T`	`update(io.vertx.core.json.JsonObject criteria, T updated)`
`<T> T`	`update(io.vertx.core.json.JsonObject criteria, T updated, String pojo)`
`<T> T`	`update(Object id, io.vertx.core.json.JsonObject data)`
`<T> T`	`update(Object id, io.vertx.core.json.JsonObject data, String pojo)`
`<T> T`	`update(Object id, T updated)`
`<T> List<T>`	`update(List<T> entities)`
`<T> T`	`update(T entity)`
`<T,ID> io.vertx.core.Future<T>`	`updateAsync(ID id, io.vertx.core.json.JsonObject data)`
`<T,ID> io.vertx.core.Future<T>`	`updateAsync(ID id, io.vertx.core.json.JsonObject data, String pojo)`
`<T,ID> io.vertx.core.Future<T>`	`updateAsync(ID id, T updated)`
`<T> io.vertx.core.Future<List<T>>`	`updateAsync(io.vertx.core.json.JsonArray data)`
`<T> io.vertx.core.Future<List<T>>`	`updateAsync(io.vertx.core.json.JsonArray data, String pojo)`
`<T> io.vertx.core.Future<T>`	`updateAsync(io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.Future<T>`	`updateAsync(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.Future<T>`	`updateAsync(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.Future<T>`	`updateAsync(io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.Future<T>`	`updateAsync(io.vertx.core.json.JsonObject criteria, T updated)`
`<T> io.vertx.core.Future<T>`	`updateAsync(io.vertx.core.json.JsonObject criteria, T updated, String pojo)`
`<T> io.vertx.core.Future<List<T>>`	`updateAsync(List<T> entities)`
`<T> io.vertx.core.Future<T>`	`updateAsync(T entity)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`updateAsyncJ(io.vertx.core.json.JsonArray input)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`updateAsyncJ(io.vertx.core.json.JsonArray input, String pojo)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`updateAsyncJ(io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`updateAsyncJ(io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`updateAsyncJ(List<T> entities)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`updateAsyncJ(T entity)`
`io.vertx.core.json.JsonArray`	`updateJ(io.vertx.core.json.JsonArray data)`
`<T> io.vertx.core.json.JsonArray`	`updateJ(io.vertx.core.json.JsonArray data, String pojo)`
`<T> io.vertx.core.json.JsonObject`	`updateJ(io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.json.JsonObject`	`updateJ(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.json.JsonObject`	`updateJ(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.json.JsonObject`	`updateJ(io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.json.JsonObject`	`updateJ(io.vertx.core.json.JsonObject criteria, T updated)`
`<T> io.vertx.core.json.JsonObject`	`updateJ(io.vertx.core.json.JsonObject criteria, T updated, String pojo)`
`<T> io.vertx.core.json.JsonObject`	`updateJ(Object id, io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.json.JsonObject`	`updateJ(Object id, io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.json.JsonObject`	`updateJ(Object id, T updated)`
`<T> io.vertx.core.json.JsonArray`	`updateJ(List<T> entities)`
`<T> io.vertx.core.json.JsonObject`	`updateJ(T entity)`
`<T,ID> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`updateJAsync(ID id, io.vertx.core.json.JsonObject data)`
`<T,ID> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`updateJAsync(ID id, io.vertx.core.json.JsonObject data, String pojo)`
`<T,ID> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`updateJAsync(ID id, T updated)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`updateJAsync(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`updateJAsync(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`updateJAsync(io.vertx.core.json.JsonObject criteria, T updated)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`updateJAsync(io.vertx.core.json.JsonObject criteria, T updated, String pojo)`
`<T> List<T>`	`upsert(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonArray data, BiPredicate<T,T> finder)`
`<T> List<T>`	`upsert(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonArray data, BiPredicate<T,T> finder, String pojo)`
`<T> T`	`upsert(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data)`
`<T> T`	`upsert(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data, String pojo)`
`<T> List<T>`	`upsert(io.vertx.core.json.JsonObject criteria, List<T> list, BiPredicate<T,T> finder)`
`<T> List<T>`	`upsert(io.vertx.core.json.JsonObject criteria, List<T> list, BiPredicate<T,T> finder, String pojo)`
`<T> T`	`upsert(io.vertx.core.json.JsonObject criteria, T updated)`
`<T> T`	`upsert(io.vertx.core.json.JsonObject criteria, T updated, String pojo)`
`<T> T`	`upsert(Object id, io.vertx.core.json.JsonObject data)`
`<T> T`	`upsert(Object id, io.vertx.core.json.JsonObject data, String pojo)`
`<T> T`	`upsert(Object id, T updated)`
`<T> io.vertx.core.Future<List<T>>`	`upsertAsync(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonArray data, BiPredicate<T,T> finder)`
`<T> io.vertx.core.Future<List<T>>`	`upsertAsync(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonArray data, BiPredicate<T,T> finder, String pojo)`
`<T> io.vertx.core.Future<T>`	`upsertAsync(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.Future<T>`	`upsertAsync(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.Future<List<T>>`	`upsertAsync(io.vertx.core.json.JsonObject criteria, List<T> list, BiPredicate<T,T> finder)`
`<T> io.vertx.core.Future<List<T>>`	`upsertAsync(io.vertx.core.json.JsonObject criteria, List<T> list, BiPredicate<T,T> finder, String pojo)`
`<T> io.vertx.core.Future<T>`	`upsertAsync(io.vertx.core.json.JsonObject criteria, T updated)`
`<T> io.vertx.core.Future<T>`	`upsertAsync(io.vertx.core.json.JsonObject criteria, T updated, String pojo)`
`<T> io.vertx.core.Future<T>`	`upsertAsync(Object id, io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.Future<T>`	`upsertAsync(Object id, io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.Future<T>`	`upsertAsync(Object id, T updated)`
`<T> io.vertx.core.json.JsonArray`	`upsertJ(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonArray data, BiPredicate<T,T> finder)`
`<T> io.vertx.core.json.JsonArray`	`upsertJ(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonArray data, BiPredicate<T,T> finder, String pojo)`
`<T> io.vertx.core.json.JsonObject`	`upsertJ(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.json.JsonObject`	`upsertJ(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.json.JsonArray`	`upsertJ(io.vertx.core.json.JsonObject criteria, List<T> list, BiPredicate<T,T> finder)`
`<T> io.vertx.core.json.JsonArray`	`upsertJ(io.vertx.core.json.JsonObject criteria, List<T> list, BiPredicate<T,T> finder, String pojo)`
`<T> io.vertx.core.json.JsonObject`	`upsertJ(io.vertx.core.json.JsonObject criteria, T updated)`
`<T> io.vertx.core.json.JsonObject`	`upsertJ(io.vertx.core.json.JsonObject criteria, T updated, String pojo)`
`<T> io.vertx.core.json.JsonObject`	`upsertJ(Object id, io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.json.JsonObject`	`upsertJ(Object id, io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.json.JsonObject`	`upsertJ(Object id, T updated)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`upsertJAsync(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonArray data, BiPredicate<T,T> finder)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`upsertJAsync(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonArray data, BiPredicate<T,T> finder, String pojo)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`upsertJAsync(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`upsertJAsync(io.vertx.core.json.JsonObject criteria, io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`upsertJAsync(io.vertx.core.json.JsonObject criteria, List<T> list, BiPredicate<T,T> finder)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonArray>`	`upsertJAsync(io.vertx.core.json.JsonObject criteria, List<T> list, BiPredicate<T,T> finder, String pojo)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`upsertJAsync(io.vertx.core.json.JsonObject criteria, T updated)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`upsertJAsync(io.vertx.core.json.JsonObject criteria, T updated, String pojo)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`upsertJAsync(Object id, io.vertx.core.json.JsonObject data)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`upsertJAsync(Object id, io.vertx.core.json.JsonObject data, String pojo)`
`<T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`upsertJAsync(Object id, T updated)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

UxJooq

public UxJooq(Class<T> clazz,
              JooqDsl dsl)

Method Detail

on
```
public UxJooq on(String pojo)
```

on
```
public UxJooq on(Format format)
```

analyzer
```
public JqAnalyzer analyzer()
```

columns
```
public Set<String> columns()
```

table
```
public String table()
```

insertAsync

public <T> io.vertx.core.Future<T> insertAsync(T entity)

insertAsync

public <T> io.vertx.core.Future<T> insertAsync(io.vertx.core.json.JsonObject data)

insertAsync

public <T> io.vertx.core.Future<T> insertAsync(io.vertx.core.json.JsonObject data,
                                               String pojo)

insertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> insertJAsync(T entity)

insertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> insertJAsync(io.vertx.core.json.JsonObject data)

insertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> insertJAsync(io.vertx.core.json.JsonObject data,
                                                                            String pojo)

insert
```
public <T> T insert(T entity)
```

insert

public <T> T insert(io.vertx.core.json.JsonObject data)

insert

public <T> T insert(io.vertx.core.json.JsonObject data,
                    String pojo)

insertJ

public <T> io.vertx.core.json.JsonObject insertJ(T entity)

insertJ

public <T> io.vertx.core.json.JsonObject insertJ(io.vertx.core.json.JsonObject data)

insertJ

public <T> io.vertx.core.json.JsonObject insertJ(io.vertx.core.json.JsonObject data,
                                                 String pojo)

insertAsync

public <T> io.vertx.core.Future<List<T>> insertAsync(List<T> entities)

insertAsync

public <T> io.vertx.core.Future<List<T>> insertAsync(io.vertx.core.json.JsonArray input)

insertAsync

public <T> io.vertx.core.Future<List<T>> insertAsync(io.vertx.core.json.JsonArray input,
                                                     String pojo)

insertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> insertJAsync(List<T> list)

insertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> insertJAsync(io.vertx.core.json.JsonArray input)

insertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> insertJAsync(io.vertx.core.json.JsonArray input,
                                                                           String pojo)

insert

public <T> List<T> insert(List<T> entities)

insert

public <T> List<T> insert(io.vertx.core.json.JsonArray data)

insert

public <T> List<T> insert(io.vertx.core.json.JsonArray data,
                          String pojo)

insertJ

public <T> io.vertx.core.json.JsonArray insertJ(List<T> list)

insertJ

public io.vertx.core.json.JsonArray insertJ(io.vertx.core.json.JsonArray data)

insertJ

public <T> io.vertx.core.json.JsonArray insertJ(io.vertx.core.json.JsonArray data,
                                                String pojo)

searchAsync

public io.vertx.core.Future<io.vertx.core.json.JsonObject> searchAsync(io.vertx.core.json.JsonObject params,
                                                                       String pojo)

searchAsync

public io.vertx.core.Future<io.vertx.core.json.JsonObject> searchAsync(io.vertx.core.json.JsonObject params)

search

public io.vertx.core.json.JsonObject search(io.vertx.core.json.JsonObject params,
                                            String pojo)

search

public io.vertx.core.json.JsonObject search(io.vertx.core.json.JsonObject params)

fetchAllAsync

public <T> io.vertx.core.Future<List<T>> fetchAllAsync()

fetchJAllAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> fetchJAllAsync()

fetchJAllAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> fetchJAllAsync(String pojo)

fetchAll
```
public <T> List<T> fetchAll()
```

fetchJAll

public io.vertx.core.json.JsonArray fetchJAll()

fetchJAll

public io.vertx.core.json.JsonArray fetchJAll(String pojo)

fetchAsync

public <T> io.vertx.core.Future<List<T>> fetchAsync(String field,
                                                    Object value)

fetchInAsync

public <T> io.vertx.core.Future<List<T>> fetchInAsync(String field,
                                                      Object... value)

fetchInAsync

public <T> io.vertx.core.Future<List<T>> fetchInAsync(String field,
                                                      io.vertx.core.json.JsonArray values)

fetchInAsync

public <T,K> io.vertx.core.Future<List<T>> fetchInAsync(String field,
                                                              Collection<K> collection)

fetchJAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> fetchJAsync(String field,
                                                                      Object value)

fetchJInAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> fetchJInAsync(String field,
                                                                        Object... value)

fetchJInAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> fetchJInAsync(String field,
                                                                        io.vertx.core.json.JsonArray values)

fetchJInAsync

public <K> io.vertx.core.Future<io.vertx.core.json.JsonArray> fetchJInAsync(String field,
                                                                            Collection<K> collection)

fetch

public <T> List<T> fetch(String field,
                         Object value)

fetchIn

public <T> List<T> fetchIn(String field,
                           Object... values)

fetchIn

public <T> List<T> fetchIn(String field,
                           io.vertx.core.json.JsonArray values)

fetchIn

public <T,K> List<T> fetchIn(String field,
                                   Collection<K> collection)

fetchJ

public io.vertx.core.json.JsonArray fetchJ(String field,
                                           Object value)

fetchJIn

public io.vertx.core.json.JsonArray fetchJIn(String field,
                                             Object... values)

fetchJIn

public io.vertx.core.json.JsonArray fetchJIn(String field,
                                             io.vertx.core.json.JsonArray values)

fetchJIn

public <K> io.vertx.core.json.JsonArray fetchJIn(String field,
                                                 Collection<K> collection)

fetchAsync

public <T> io.vertx.core.Future<List<T>> fetchAsync(io.vertx.core.json.JsonObject criteria)

fetchAndAsync

public <T> io.vertx.core.Future<List<T>> fetchAndAsync(io.vertx.core.json.JsonObject criteria)

fetchOrAsync

public <T> io.vertx.core.Future<List<T>> fetchOrAsync(io.vertx.core.json.JsonObject criteria)

fetchJAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> fetchJAsync(io.vertx.core.json.JsonObject criteria)

fetchJAndAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> fetchJAndAsync(io.vertx.core.json.JsonObject criteria)

fetchJOrAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> fetchJOrAsync(io.vertx.core.json.JsonObject criteria)

fetch

public <T> List<T> fetch(io.vertx.core.json.JsonObject criteria)

fetchAnd

public <T> List<T> fetchAnd(io.vertx.core.json.JsonObject criteria)

fetchOr

public <T> List<T> fetchOr(io.vertx.core.json.JsonObject criteria)

fetchJ

public io.vertx.core.json.JsonArray fetchJ(io.vertx.core.json.JsonObject criteria)

fetchJAnd

public io.vertx.core.json.JsonArray fetchJAnd(io.vertx.core.json.JsonObject criteria)

fetchJOr

public io.vertx.core.json.JsonArray fetchJOr(io.vertx.core.json.JsonObject criteria)

fetchAsync

public <T> io.vertx.core.Future<List<T>> fetchAsync(io.vertx.core.json.JsonObject criteria,
                                                    String pojo)

fetchAndAsync

public <T> io.vertx.core.Future<List<T>> fetchAndAsync(io.vertx.core.json.JsonObject criteria,
                                                       String pojo)

fetchOrAsync

public <T> io.vertx.core.Future<List<T>> fetchOrAsync(io.vertx.core.json.JsonObject criteria,
                                                      String pojo)

fetchJAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> fetchJAsync(io.vertx.core.json.JsonObject criteria,
                                                                      String pojo)

fetchJAndAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> fetchJAndAsync(io.vertx.core.json.JsonObject criteria,
                                                                         String pojo)

fetchJOrAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> fetchJOrAsync(io.vertx.core.json.JsonObject criteria,
                                                                        String pojo)

fetch

public <T> List<T> fetch(io.vertx.core.json.JsonObject criteria,
                         String pojo)

fetchAnd

public <T> List<T> fetchAnd(io.vertx.core.json.JsonObject criteria,
                            String pojo)

fetchOr

public <T> List<T> fetchOr(io.vertx.core.json.JsonObject criteria,
                           String pojo)

fetchJ

public io.vertx.core.json.JsonArray fetchJ(io.vertx.core.json.JsonObject criteria,
                                           String pojo)

fetchJAnd

public io.vertx.core.json.JsonArray fetchJAnd(io.vertx.core.json.JsonObject criteria,
                                              String pojo)

fetchJOr

public io.vertx.core.json.JsonArray fetchJOr(io.vertx.core.json.JsonObject criteria,
                                             String pojo)

fetchByIdAsync

public <T> io.vertx.core.Future<T> fetchByIdAsync(Object id)

fetchJByIdAsync

public io.vertx.core.Future<io.vertx.core.json.JsonObject> fetchJByIdAsync(Object id)

fetchById

public <T> T fetchById(Object id)

fetchJById

public <T> io.vertx.core.json.JsonObject fetchJById(Object id)

fetchOneAsync

public <T> io.vertx.core.Future<T> fetchOneAsync(String field,
                                                 Object value)

fetchJOneAsync

public io.vertx.core.Future<io.vertx.core.json.JsonObject> fetchJOneAsync(String field,
                                                                          Object value)

fetchOne

public <T> T fetchOne(String field,
                      Object value)

fetchJOne

public <T> io.vertx.core.json.JsonObject fetchJOne(String field,
                                                   Object value)

fetchOneAsync

public <T> io.vertx.core.Future<T> fetchOneAsync(io.vertx.core.json.JsonObject criteria)

fetchJOneAsync

public io.vertx.core.Future<io.vertx.core.json.JsonObject> fetchJOneAsync(io.vertx.core.json.JsonObject criteria)

fetchOne

public <T> T fetchOne(io.vertx.core.json.JsonObject criteria)

fetchJOne

public <T> io.vertx.core.json.JsonObject fetchJOne(io.vertx.core.json.JsonObject criteria)

fetchOneAsync

public <T> io.vertx.core.Future<T> fetchOneAsync(io.vertx.core.json.JsonObject criteria,
                                                 String pojo)

fetchJOneAsync

public io.vertx.core.Future<io.vertx.core.json.JsonObject> fetchJOneAsync(io.vertx.core.json.JsonObject criteria,
                                                                          String pojo)

fetchOne

public <T> T fetchOne(io.vertx.core.json.JsonObject criteria,
                      String pojo)

fetchJOne

public <T> io.vertx.core.json.JsonObject fetchJOne(io.vertx.core.json.JsonObject criteria,
                                                   String pojo)

update
```
public <T> T update(T entity)
```

update

public <T> T update(io.vertx.core.json.JsonObject data)

update

public <T> T update(io.vertx.core.json.JsonObject data,
                    String pojo)

updateJ

public <T> io.vertx.core.json.JsonObject updateJ(T entity)

updateJ

public <T> io.vertx.core.json.JsonObject updateJ(io.vertx.core.json.JsonObject data)

updateJ

public <T> io.vertx.core.json.JsonObject updateJ(io.vertx.core.json.JsonObject data,
                                                 String pojo)

updateAsync

public <T> io.vertx.core.Future<T> updateAsync(T entity)

updateAsync

public <T> io.vertx.core.Future<T> updateAsync(io.vertx.core.json.JsonObject data)

updateAsync

public <T> io.vertx.core.Future<T> updateAsync(io.vertx.core.json.JsonObject data,
                                               String pojo)

updateAsyncJ

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> updateAsyncJ(T entity)

updateAsyncJ

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> updateAsyncJ(io.vertx.core.json.JsonObject data)

updateAsyncJ

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> updateAsyncJ(io.vertx.core.json.JsonObject data,
                                                                            String pojo)

update

public <T> List<T> update(List<T> entities)

update

public <T> List<T> update(io.vertx.core.json.JsonArray data)

update

public <T> List<T> update(io.vertx.core.json.JsonArray data,
                          String pojo)

updateJ

public <T> io.vertx.core.json.JsonArray updateJ(List<T> entities)

updateJ

public io.vertx.core.json.JsonArray updateJ(io.vertx.core.json.JsonArray data)

updateJ

public <T> io.vertx.core.json.JsonArray updateJ(io.vertx.core.json.JsonArray data,
                                                String pojo)

updateAsync

public <T> io.vertx.core.Future<List<T>> updateAsync(List<T> entities)

updateAsync

public <T> io.vertx.core.Future<List<T>> updateAsync(io.vertx.core.json.JsonArray data)

updateAsync

public <T> io.vertx.core.Future<List<T>> updateAsync(io.vertx.core.json.JsonArray data,
                                                     String pojo)

updateAsyncJ

public <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> updateAsyncJ(List<T> entities)

updateAsyncJ

public <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> updateAsyncJ(io.vertx.core.json.JsonArray input)

updateAsyncJ

public <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> updateAsyncJ(io.vertx.core.json.JsonArray input,
                                                                           String pojo)

update

public <T> T update(Object id,
                    T updated)

update

public <T> T update(Object id,
                    io.vertx.core.json.JsonObject data)

update

public <T> T update(Object id,
                    io.vertx.core.json.JsonObject data,
                    String pojo)

updateJ

public <T> io.vertx.core.json.JsonObject updateJ(Object id,
                                                 T updated)

updateJ

public <T> io.vertx.core.json.JsonObject updateJ(Object id,
                                                 io.vertx.core.json.JsonObject data)

updateJ

public <T> io.vertx.core.json.JsonObject updateJ(Object id,
                                                 io.vertx.core.json.JsonObject data,
                                                 String pojo)

updateAsync

public <T,ID> io.vertx.core.Future<T> updateAsync(ID id,
                                                        T updated)

updateAsync

public <T,ID> io.vertx.core.Future<T> updateAsync(ID id,
                                                        io.vertx.core.json.JsonObject data)

updateAsync

public <T,ID> io.vertx.core.Future<T> updateAsync(ID id,
                                                        io.vertx.core.json.JsonObject data,
                                                        String pojo)

updateJAsync

public <T,ID> io.vertx.core.Future<io.vertx.core.json.JsonObject> updateJAsync(ID id,
                                                                                     T updated)

updateJAsync

public <T,ID> io.vertx.core.Future<io.vertx.core.json.JsonObject> updateJAsync(ID id,
                                                                                     io.vertx.core.json.JsonObject data)

updateJAsync

public <T,ID> io.vertx.core.Future<io.vertx.core.json.JsonObject> updateJAsync(ID id,
                                                                                     io.vertx.core.json.JsonObject data,
                                                                                     String pojo)

update

public <T> T update(io.vertx.core.json.JsonObject criteria,
                    T updated)

update

public <T> T update(io.vertx.core.json.JsonObject criteria,
                    io.vertx.core.json.JsonObject data)

updateJ

public <T> io.vertx.core.json.JsonObject updateJ(io.vertx.core.json.JsonObject criteria,
                                                 T updated)

updateJ

public <T> io.vertx.core.json.JsonObject updateJ(io.vertx.core.json.JsonObject criteria,
                                                 io.vertx.core.json.JsonObject data)

update

public <T> T update(io.vertx.core.json.JsonObject criteria,
                    T updated,
                    String pojo)

update

public <T> T update(io.vertx.core.json.JsonObject criteria,
                    io.vertx.core.json.JsonObject data,
                    String pojo)

updateJ

public <T> io.vertx.core.json.JsonObject updateJ(io.vertx.core.json.JsonObject criteria,
                                                 T updated,
                                                 String pojo)

updateJ

public <T> io.vertx.core.json.JsonObject updateJ(io.vertx.core.json.JsonObject criteria,
                                                 io.vertx.core.json.JsonObject data,
                                                 String pojo)

updateAsync

public <T> io.vertx.core.Future<T> updateAsync(io.vertx.core.json.JsonObject criteria,
                                               T updated)

updateAsync

public <T> io.vertx.core.Future<T> updateAsync(io.vertx.core.json.JsonObject criteria,
                                               io.vertx.core.json.JsonObject data)

updateJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> updateJAsync(io.vertx.core.json.JsonObject criteria,
                                                                            T updated)

updateJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> updateJAsync(io.vertx.core.json.JsonObject criteria,
                                                                            io.vertx.core.json.JsonObject data)

updateAsync

public <T> io.vertx.core.Future<T> updateAsync(io.vertx.core.json.JsonObject criteria,
                                               T updated,
                                               String pojo)

updateAsync

public <T> io.vertx.core.Future<T> updateAsync(io.vertx.core.json.JsonObject criteria,
                                               io.vertx.core.json.JsonObject data,
                                               String pojo)

updateJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> updateJAsync(io.vertx.core.json.JsonObject criteria,
                                                                            T updated,
                                                                            String pojo)

updateJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> updateJAsync(io.vertx.core.json.JsonObject criteria,
                                                                            io.vertx.core.json.JsonObject data,
                                                                            String pojo)

upsert

public <T> T upsert(Object id,
                    T updated)

upsert

public <T> T upsert(Object id,
                    io.vertx.core.json.JsonObject data)

upsert

public <T> T upsert(Object id,
                    io.vertx.core.json.JsonObject data,
                    String pojo)

upsertJ

public <T> io.vertx.core.json.JsonObject upsertJ(Object id,
                                                 T updated)

upsertJ

public <T> io.vertx.core.json.JsonObject upsertJ(Object id,
                                                 io.vertx.core.json.JsonObject data)

upsertJ

public <T> io.vertx.core.json.JsonObject upsertJ(Object id,
                                                 io.vertx.core.json.JsonObject data,
                                                 String pojo)

upsertAsync

public <T> io.vertx.core.Future<T> upsertAsync(Object id,
                                               T updated)

upsertAsync

public <T> io.vertx.core.Future<T> upsertAsync(Object id,
                                               io.vertx.core.json.JsonObject data)

upsertAsync

public <T> io.vertx.core.Future<T> upsertAsync(Object id,
                                               io.vertx.core.json.JsonObject data,
                                               String pojo)

upsertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> upsertJAsync(Object id,
                                                                            T updated)

upsertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> upsertJAsync(Object id,
                                                                            io.vertx.core.json.JsonObject data)

upsertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> upsertJAsync(Object id,
                                                                            io.vertx.core.json.JsonObject data,
                                                                            String pojo)

upsert

public <T> T upsert(io.vertx.core.json.JsonObject criteria,
                    T updated)

upsert

public <T> T upsert(io.vertx.core.json.JsonObject criteria,
                    io.vertx.core.json.JsonObject data)

upsertJ

public <T> io.vertx.core.json.JsonObject upsertJ(io.vertx.core.json.JsonObject criteria,
                                                 T updated)

upsertJ

public <T> io.vertx.core.json.JsonObject upsertJ(io.vertx.core.json.JsonObject criteria,
                                                 io.vertx.core.json.JsonObject data)

upsert

public <T> T upsert(io.vertx.core.json.JsonObject criteria,
                    T updated,
                    String pojo)

upsert

public <T> T upsert(io.vertx.core.json.JsonObject criteria,
                    io.vertx.core.json.JsonObject data,
                    String pojo)

upsertJ

public <T> io.vertx.core.json.JsonObject upsertJ(io.vertx.core.json.JsonObject criteria,
                                                 T updated,
                                                 String pojo)

upsertJ

public <T> io.vertx.core.json.JsonObject upsertJ(io.vertx.core.json.JsonObject criteria,
                                                 io.vertx.core.json.JsonObject data,
                                                 String pojo)

upsertAsync

public <T> io.vertx.core.Future<T> upsertAsync(io.vertx.core.json.JsonObject criteria,
                                               T updated)

upsertAsync

public <T> io.vertx.core.Future<T> upsertAsync(io.vertx.core.json.JsonObject criteria,
                                               io.vertx.core.json.JsonObject data)

upsertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> upsertJAsync(io.vertx.core.json.JsonObject criteria,
                                                                            T updated)

upsertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> upsertJAsync(io.vertx.core.json.JsonObject criteria,
                                                                            io.vertx.core.json.JsonObject data)

upsertAsync

public <T> io.vertx.core.Future<T> upsertAsync(io.vertx.core.json.JsonObject criteria,
                                               T updated,
                                               String pojo)

upsertAsync

public <T> io.vertx.core.Future<T> upsertAsync(io.vertx.core.json.JsonObject criteria,
                                               io.vertx.core.json.JsonObject data,
                                               String pojo)

upsertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> upsertJAsync(io.vertx.core.json.JsonObject criteria,
                                                                            T updated,
                                                                            String pojo)

upsertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> upsertJAsync(io.vertx.core.json.JsonObject criteria,
                                                                            io.vertx.core.json.JsonObject data,
                                                                            String pojo)

upsert

public <T> List<T> upsert(io.vertx.core.json.JsonObject criteria,
                          List<T> list,
                          BiPredicate<T,T> finder)

upsert

public <T> List<T> upsert(io.vertx.core.json.JsonObject criteria,
                          io.vertx.core.json.JsonArray data,
                          BiPredicate<T,T> finder)

upsertJ

public <T> io.vertx.core.json.JsonArray upsertJ(io.vertx.core.json.JsonObject criteria,
                                                List<T> list,
                                                BiPredicate<T,T> finder)

upsertJ

public <T> io.vertx.core.json.JsonArray upsertJ(io.vertx.core.json.JsonObject criteria,
                                                io.vertx.core.json.JsonArray data,
                                                BiPredicate<T,T> finder)

upsert

public <T> List<T> upsert(io.vertx.core.json.JsonObject criteria,
                          List<T> list,
                          BiPredicate<T,T> finder,
                          String pojo)

upsert

public <T> List<T> upsert(io.vertx.core.json.JsonObject criteria,
                          io.vertx.core.json.JsonArray data,
                          BiPredicate<T,T> finder,
                          String pojo)

upsertJ

public <T> io.vertx.core.json.JsonArray upsertJ(io.vertx.core.json.JsonObject criteria,
                                                List<T> list,
                                                BiPredicate<T,T> finder,
                                                String pojo)

upsertJ

public <T> io.vertx.core.json.JsonArray upsertJ(io.vertx.core.json.JsonObject criteria,
                                                io.vertx.core.json.JsonArray data,
                                                BiPredicate<T,T> finder,
                                                String pojo)

upsertAsync

public <T> io.vertx.core.Future<List<T>> upsertAsync(io.vertx.core.json.JsonObject criteria,
                                                     List<T> list,
                                                     BiPredicate<T,T> finder)

upsertAsync

public <T> io.vertx.core.Future<List<T>> upsertAsync(io.vertx.core.json.JsonObject criteria,
                                                     io.vertx.core.json.JsonArray data,
                                                     BiPredicate<T,T> finder)

upsertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> upsertJAsync(io.vertx.core.json.JsonObject criteria,
                                                                           List<T> list,
                                                                           BiPredicate<T,T> finder)

upsertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> upsertJAsync(io.vertx.core.json.JsonObject criteria,
                                                                           io.vertx.core.json.JsonArray data,
                                                                           BiPredicate<T,T> finder)

upsertAsync

public <T> io.vertx.core.Future<List<T>> upsertAsync(io.vertx.core.json.JsonObject criteria,
                                                     List<T> list,
                                                     BiPredicate<T,T> finder,
                                                     String pojo)

upsertAsync

public <T> io.vertx.core.Future<List<T>> upsertAsync(io.vertx.core.json.JsonObject criteria,
                                                     io.vertx.core.json.JsonArray data,
                                                     BiPredicate<T,T> finder,
                                                     String pojo)

upsertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> upsertJAsync(io.vertx.core.json.JsonObject criteria,
                                                                           List<T> list,
                                                                           BiPredicate<T,T> finder,
                                                                           String pojo)

upsertJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> upsertJAsync(io.vertx.core.json.JsonObject criteria,
                                                                           io.vertx.core.json.JsonArray data,
                                                                           BiPredicate<T,T> finder,
                                                                           String pojo)

delete
```
public <T> T delete(T entity)
```

delete

public <T> T delete(io.vertx.core.json.JsonObject data)

delete

public <T> T delete(io.vertx.core.json.JsonObject data,
                    String pojo)

deleteJ

public <T> io.vertx.core.json.JsonObject deleteJ(T entity)

deleteJ

public <T> io.vertx.core.json.JsonObject deleteJ(io.vertx.core.json.JsonObject data)

deleteJ

public <T> io.vertx.core.json.JsonObject deleteJ(io.vertx.core.json.JsonObject data,
                                                 String pojo)

deleteAsync

public <T,ID> io.vertx.core.Future<T> deleteAsync(T entity)

deleteAsync

public <T,ID> io.vertx.core.Future<T> deleteAsync(io.vertx.core.json.JsonObject data)

deleteAsync

public <T,ID> io.vertx.core.Future<T> deleteAsync(io.vertx.core.json.JsonObject data,
                                                        String pojo)

deleteJAsync

public <T,ID> io.vertx.core.Future<io.vertx.core.json.JsonObject> deleteJAsync(T entity)

deleteJAsync

public <T,ID> io.vertx.core.Future<io.vertx.core.json.JsonObject> deleteJAsync(io.vertx.core.json.JsonObject data)

deleteJAsync

public <T,ID> io.vertx.core.Future<io.vertx.core.json.JsonObject> deleteJAsync(io.vertx.core.json.JsonObject data,
                                                                                     String pojo)

delete

public <T> List<T> delete(List<T> entity)

delete

public <T> List<T> delete(io.vertx.core.json.JsonArray data)

delete

public <T> List<T> delete(io.vertx.core.json.JsonArray data,
                          String pojo)

deleteJ

public <T> io.vertx.core.json.JsonArray deleteJ(List<T> entity)

deleteJ

public <T> io.vertx.core.json.JsonArray deleteJ(io.vertx.core.json.JsonArray data)

deleteJ

public <T> io.vertx.core.json.JsonArray deleteJ(io.vertx.core.json.JsonArray data,
                                                String pojo)

deleteAsync

public <T> io.vertx.core.Future<List<T>> deleteAsync(List<T> entity)

deleteAsync

public <T> io.vertx.core.Future<List<T>> deleteAsync(io.vertx.core.json.JsonArray data)

deleteAsync

public <T> io.vertx.core.Future<List<T>> deleteAsync(io.vertx.core.json.JsonArray data,
                                                     String pojo)

deleteJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> deleteJAsync(List<T> entity)

deleteJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> deleteJAsync(io.vertx.core.json.JsonArray data)

deleteJAsync

public <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> deleteJAsync(io.vertx.core.json.JsonArray data,
                                                                           String pojo)

deleteById

public final Boolean deleteById(Object id)

deleteById

public Boolean deleteById(Collection<Object> ids)

deleteByIdAsync

public final io.vertx.core.Future<Boolean> deleteByIdAsync(Object id)

deleteByIdAsync

public io.vertx.core.Future<Boolean> deleteByIdAsync(Collection<Object> ids)

deleteByAsync

public io.vertx.core.Future<Boolean> deleteByAsync(io.vertx.core.json.JsonObject criteria)

deleteByAsync

public io.vertx.core.Future<Boolean> deleteByAsync(io.vertx.core.json.JsonObject criteria,
                                                   String pojo)

deleteBy

public Boolean deleteBy(io.vertx.core.json.JsonObject criteria)

deleteBy

public Boolean deleteBy(io.vertx.core.json.JsonObject criteria,
                        String pojo)

existById

public Boolean existById(Object id)

existByIdAsync

public io.vertx.core.Future<Boolean> existByIdAsync(Object id)

missById

public Boolean missById(Object id)

missByIdAsync

public io.vertx.core.Future<Boolean> missByIdAsync(Object id)

exist

public Boolean exist(io.vertx.core.json.JsonObject criteria)

exist

public Boolean exist(io.vertx.core.json.JsonObject criteria,
                     String pojo)

existAsync

public io.vertx.core.Future<Boolean> existAsync(io.vertx.core.json.JsonObject criteria)

existAsync

public io.vertx.core.Future<Boolean> existAsync(io.vertx.core.json.JsonObject criteria,
                                                String pojo)

miss

public Boolean miss(io.vertx.core.json.JsonObject criteria)

miss

public Boolean miss(io.vertx.core.json.JsonObject criteria,
                    String pojo)

missAsync

public io.vertx.core.Future<Boolean> missAsync(io.vertx.core.json.JsonObject criteria)

missAsync

public io.vertx.core.Future<Boolean> missAsync(io.vertx.core.json.JsonObject criteria,
                                               String pojo)

group

public <T> ConcurrentMap<String,List<T>> group(String field)

groupJ

public <T> ConcurrentMap<String,io.vertx.core.json.JsonArray> groupJ(String field)

groupAsync

public <T> io.vertx.core.Future<ConcurrentMap<String,List<T>>> groupAsync(String field)

groupJAsync

public <T> io.vertx.core.Future<ConcurrentMap<String,io.vertx.core.json.JsonArray>> groupJAsync(String field)

group

public <T> ConcurrentMap<String,List<T>> group(io.vertx.core.json.JsonObject criteria,
                                                     String field)

groupJ

public <T> ConcurrentMap<String,io.vertx.core.json.JsonArray> groupJ(io.vertx.core.json.JsonObject criteria,
                                                                           String field)

groupAsync

public <T> io.vertx.core.Future<ConcurrentMap<String,List<T>>> groupAsync(io.vertx.core.json.JsonObject criteria,
                                                                                String field)

groupJAsync

public <T> io.vertx.core.Future<ConcurrentMap<String,io.vertx.core.json.JsonArray>> groupJAsync(io.vertx.core.json.JsonObject criteria,
                                                                                                      String field)

countAll
```
public Long countAll()
```

countAllAsync

public io.vertx.core.Future<Long> countAllAsync()

count

public Long count(io.vertx.core.json.JsonObject criteria)

count

public Long count(io.vertx.core.json.JsonObject criteria,
                  String pojo)

countAsync

public io.vertx.core.Future<Long> countAsync(io.vertx.core.json.JsonObject criteria)

countAsync

public io.vertx.core.Future<Long> countAsync(io.vertx.core.json.JsonObject criteria,
                                             String pojo)

countBy

public ConcurrentMap<String,Integer> countBy(io.vertx.core.json.JsonObject criteria,
                                                   String groupField)

countBy

public ConcurrentMap<String,Integer> countBy(String groupField)

countByAsync

public io.vertx.core.Future<ConcurrentMap<String,Integer>> countByAsync(io.vertx.core.json.JsonObject criteria,
                                                                              String groupField)

countByAsync

public io.vertx.core.Future<ConcurrentMap<String,Integer>> countByAsync(String groupField)

countBy

public io.vertx.core.json.JsonArray countBy(io.vertx.core.json.JsonObject criteria,
                                            String... groupFields)

countBy

public io.vertx.core.json.JsonArray countBy(String... groupFields)

countByAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> countByAsync(String... groupFields)

countByAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> countByAsync(io.vertx.core.json.JsonObject criteria,
                                                                       String... groupFields)

sum

public BigDecimal sum(String field)

sumAsync

public io.vertx.core.Future<BigDecimal> sumAsync(String field)

sum

public BigDecimal sum(String field,
                      io.vertx.core.json.JsonObject criteria)

sumAsync

public io.vertx.core.Future<BigDecimal> sumAsync(String field,
                                                 io.vertx.core.json.JsonObject criteria)

sum

public BigDecimal sum(String field,
                      io.vertx.core.json.JsonObject criteria,
                      String pojo)

sumAsync

public io.vertx.core.Future<BigDecimal> sumAsync(String field,
                                                 io.vertx.core.json.JsonObject criteria,
                                                 String pojo)

sumBy

public ConcurrentMap<String,BigDecimal> sumBy(String field,
                                                    io.vertx.core.json.JsonObject criteria,
                                                    String groupField)

sumBy

public ConcurrentMap<String,BigDecimal> sumBy(String field,
                                                    String groupField)

sumByAsync

public io.vertx.core.Future<ConcurrentMap<String,BigDecimal>> sumByAsync(String field,
                                                                               String groupField)

sumByAsync

public io.vertx.core.Future<ConcurrentMap<String,BigDecimal>> sumByAsync(String field,
                                                                               io.vertx.core.json.JsonObject criteria,
                                                                               String groupField)

sumBy

public io.vertx.core.json.JsonArray sumBy(String field,
                                          io.vertx.core.json.JsonObject criteria,
                                          String... groupFields)

sumBy

public io.vertx.core.json.JsonArray sumBy(String field,
                                          String... groupFields)

sumByAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> sumByAsync(String field,
                                                                     io.vertx.core.json.JsonObject criteria,
                                                                     String... groupFields)

sumByAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> sumByAsync(String field,
                                                                     String... groupFields)

max

public BigDecimal max(String field)

maxAsync

public io.vertx.core.Future<BigDecimal> maxAsync(String field)

max

public BigDecimal max(String field,
                      io.vertx.core.json.JsonObject criteria)

maxAsync

public io.vertx.core.Future<BigDecimal> maxAsync(String field,
                                                 io.vertx.core.json.JsonObject criteria)

max

public BigDecimal max(String field,
                      io.vertx.core.json.JsonObject criteria,
                      String pojo)

maxAsync

public io.vertx.core.Future<BigDecimal> maxAsync(String field,
                                                 io.vertx.core.json.JsonObject criteria,
                                                 String pojo)

maxBy

public ConcurrentMap<String,BigDecimal> maxBy(String field,
                                                    io.vertx.core.json.JsonObject criteria,
                                                    String groupField)

maxBy

public ConcurrentMap<String,BigDecimal> maxBy(String field,
                                                    String groupField)

maxByAsync

public io.vertx.core.Future<ConcurrentMap<String,BigDecimal>> maxByAsync(String field,
                                                                               String groupField)

maxByAsync

public io.vertx.core.Future<ConcurrentMap<String,BigDecimal>> maxByAsync(String field,
                                                                               io.vertx.core.json.JsonObject criteria,
                                                                               String groupField)

maxBy

public io.vertx.core.json.JsonArray maxBy(String field,
                                          io.vertx.core.json.JsonObject criteria,
                                          String... groupFields)

maxBy

public io.vertx.core.json.JsonArray maxBy(String field,
                                          String... groupFields)

maxByAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> maxByAsync(String field,
                                                                     io.vertx.core.json.JsonObject criteria,
                                                                     String... groupFields)

maxByAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> maxByAsync(String field,
                                                                     String... groupFields)

min

public BigDecimal min(String field)

minAsync

public io.vertx.core.Future<BigDecimal> minAsync(String field)

min

public BigDecimal min(String field,
                      io.vertx.core.json.JsonObject criteria)

minAsync

public io.vertx.core.Future<BigDecimal> minAsync(String field,
                                                 io.vertx.core.json.JsonObject criteria)

min

public BigDecimal min(String field,
                      io.vertx.core.json.JsonObject criteria,
                      String pojo)

minAsync

public io.vertx.core.Future<BigDecimal> minAsync(String field,
                                                 io.vertx.core.json.JsonObject criteria,
                                                 String pojo)

minBy

public ConcurrentMap<String,BigDecimal> minBy(String field,
                                                    io.vertx.core.json.JsonObject criteria,
                                                    String groupField)

minBy

public ConcurrentMap<String,BigDecimal> minBy(String field,
                                                    String groupField)

minByAsync

public io.vertx.core.Future<ConcurrentMap<String,BigDecimal>> minByAsync(String field,
                                                                               String groupField)

minByAsync

public io.vertx.core.Future<ConcurrentMap<String,BigDecimal>> minByAsync(String field,
                                                                               io.vertx.core.json.JsonObject criteria,
                                                                               String groupField)

minBy

public io.vertx.core.json.JsonArray minBy(String field,
                                          io.vertx.core.json.JsonObject criteria,
                                          String... groupFields)

minBy

public io.vertx.core.json.JsonArray minBy(String field,
                                          String... groupFields)

minByAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> minByAsync(String field,
                                                                     io.vertx.core.json.JsonObject criteria,
                                                                     String... groupFields)

minByAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> minByAsync(String field,
                                                                     String... groupFields)

avg

public BigDecimal avg(String field)

avgAsync

public io.vertx.core.Future<BigDecimal> avgAsync(String field)

avg

public BigDecimal avg(String field,
                      io.vertx.core.json.JsonObject criteria)

avgAsync

public io.vertx.core.Future<BigDecimal> avgAsync(String field,
                                                 io.vertx.core.json.JsonObject criteria)

avg

public BigDecimal avg(String field,
                      io.vertx.core.json.JsonObject criteria,
                      String pojo)

avgAsync

public io.vertx.core.Future<BigDecimal> avgAsync(String field,
                                                 io.vertx.core.json.JsonObject criteria,
                                                 String pojo)

avgBy

public ConcurrentMap<String,BigDecimal> avgBy(String field,
                                                    io.vertx.core.json.JsonObject criteria,
                                                    String groupField)

avgBy

public ConcurrentMap<String,BigDecimal> avgBy(String field,
                                                    String groupField)

avgByAsync

public io.vertx.core.Future<ConcurrentMap<String,BigDecimal>> avgByAsync(String field,
                                                                               String groupField)

avgByAsync

public io.vertx.core.Future<ConcurrentMap<String,BigDecimal>> avgByAsync(String field,
                                                                               io.vertx.core.json.JsonObject criteria,
                                                                               String groupField)

avgBy

public io.vertx.core.json.JsonArray avgBy(String field,
                                          io.vertx.core.json.JsonObject criteria,
                                          String... groupFields)

avgBy

public io.vertx.core.json.JsonArray avgBy(String field,
                                          String... groupFields)

avgByAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> avgByAsync(String field,
                                                                     io.vertx.core.json.JsonObject criteria,
                                                                     String... groupFields)

avgByAsync

public io.vertx.core.Future<io.vertx.core.json.JsonArray> avgByAsync(String field,
                                                                     String... groupFields)

Class UxJooq

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

UxJooq

Method Detail

on

on

analyzer

columns

table

insertAsync

insertAsync

insertAsync

insertJAsync

insertJAsync

insertJAsync

insert

insert

insert

insertJ

insertJ

insertJ

insertAsync

insertAsync

insertAsync

insertJAsync

insertJAsync

insertJAsync

insert

insert

insert

insertJ

insertJ

insertJ

searchAsync

searchAsync

search

search

fetchAllAsync

fetchJAllAsync

fetchJAllAsync

fetchAll

fetchJAll

fetchJAll

fetchAsync

fetchInAsync

fetchInAsync

fetchInAsync

fetchJAsync

fetchJInAsync

fetchJInAsync

fetchJInAsync

fetch

fetchIn

fetchIn

fetchIn

fetchJ

fetchJIn

fetchJIn

fetchJIn

fetchAsync

fetchAndAsync

fetchOrAsync

fetchJAsync

fetchJAndAsync

fetchJOrAsync

fetch

fetchAnd

fetchOr

fetchJ

fetchJAnd

fetchJOr

fetchAsync

fetchAndAsync

fetchOrAsync

fetchJAsync

fetchJAndAsync

fetchJOrAsync