io.vertx.up.uca.jooq.ActionFetch Maven / Gradle / Ivy

Go to download
package io.vertx.up.uca.jooq;

import io.vertx.core.Future;
import io.vertx.core.json.JsonObject;
import io.vertx.tp.plugin.jooq.condition.JooqCond;
import org.jooq.*;

import java.util.List;

/**
 * @author Lang
 */
@SuppressWarnings("all")
class ActionFetch extends AbstractAction {

    private transient final ActionQr qr;

    ActionFetch(final JqAnalyzer analyzer) {
        super(analyzer);
        // Qr
        this.qr = new ActionQr(analyzer);
    }

    /* Future> */
     Future> fetchAllAsync() {
        return ((Future>) this.dao().findAll()).compose(list -> {
            this.logging("[ Jq ] fetchAllAsync() queried rows: {0}", String.valueOf(list.size()));
            return Future.succeededFuture(list);
        });
    }

    /* List */
     List fetchAll() {
        final SelectWhereStep selectStep = this.context().selectFrom(this.analyzer.table());
        final List list = ((ResultQuery) selectStep).fetchInto(this.analyzer.type());
        this.logging("[ Jq ] fetchAll() queried rows: {0}", String.valueOf(list.size()));
        return list;
    }

    /* Future */
     Future fetchByIdAsync(final ID id) {
        return ((Future) this.dao().findOneById(id)).compose(queried -> {
            this.logging("[ Jq ] fetchByIdAsync(ID) by id: {1}, queried record: {0}", queried, id);
            return Future.succeededFuture(queried);
        });
    }

    /* T */
     T fetchById(final ID id) {
        final SelectConditionStep selectStep = this.context().selectFrom(this.analyzer.table())
            .where(this.analyzer.conditionId(id));
        final T queried = (T) ((ResultQuery) selectStep).fetchOneInto(this.analyzer.type());
        this.logging("[ Jq ] fetchByIdAsync(ID) by id: {1}, queried record: {0}", queried, id);
        return queried;
    }

    /* Future> */
     Future> fetchAsync(final String field, final Object value) {
        final Condition condition = this.analyzer.conditionField(field, value);
        return ((Future>) this.dao().findManyByCondition(condition)).compose(list -> {
            this.logging("[ Jq ] fetchAsync(String, Object) condition: \"{1}\", queried rows: {0}",
                String.valueOf(list.size()), condition);
            return Future.succeededFuture(list);
        });
    }

    /* List */
     List fetch(final String field, final Object value) {
        final Condition condition = this.analyzer.conditionField(field, value);
        final SelectConditionStep selectStep = this.context().selectFrom(this.analyzer.table())
            .where(condition);
        final List list = (List) ((ResultQuery) selectStep).fetchInto(this.analyzer.type());
        this.logging("[ Jq ] fetch(String, Object) condition: \"{1}\", queried rows: {0}",
            String.valueOf(list.size()), condition);
        return list;
    }

    /* Future> */
     Future> fetchAsync(final JsonObject criteria) {
        return this.qr.searchAsync(criteria).compose(list -> {
            this.logging("[ Jq ] fetchAsync(JsonObject) condition json: \"{1}\", queried rows: {0}",
                String.valueOf(list.size()), criteria);
            return Future.succeededFuture(list);
        });
    }

    /* List */
     List fetch(final JsonObject criteria) {
        final List list = this.qr.search(criteria);
        this.logging("[ Jq ] fetch(JsonObject) condition json: \"{1}\", queried rows: {0}",
            String.valueOf(list.size()), criteria);
        return list;
    }


    /* Future */
     Future fetchOneAsync(final String field, final Object value) {
        final Condition condition = this.analyzer.conditionField(field, value);
        return ((Future) this.dao().findOneByCondition(condition)).compose(queried -> {
            this.logging("[ Jq ] fetchOneAsync(String, Object) condition: \"{1}\", queried record: {0}", queried, condition);
            return Future.succeededFuture(queried);
        });
    }

    /* T */
     T fetchOne(final String field, final Object value) {
        final Condition condition = this.analyzer.conditionField(field, value);
        final SelectConditionStep selectStep = this.context().selectFrom(this.analyzer.table())
            .where(condition);
        final T queried = (T) ((ResultQuery) selectStep).fetchOneInto(this.analyzer.type());
        this.logging("[ Jq ] fetchOne(String, Object) condition: \"{1}\", queried record: {0}", queried, condition);
        return queried;
    }

    /* Future */
     Future fetchOneAsync(final JsonObject criteria) {
        final Condition condition = JooqCond.transform(criteria, Operator.AND, this.analyzer::column);
        return ((Future) this.dao().findOneByCondition(condition)).compose(queried -> {
            this.logging("[ Jq ] fetchOneAsync(JsonObject) condition: \"{1}\", queried record: {0}", queried, condition);
            return Future.succeededFuture(queried);
        });
    }

    /* T */
     T fetchOne(final JsonObject criteria) {
        final Condition condition = JooqCond.transform(criteria, Operator.AND, this.analyzer::column);
        final SelectConditionStep selectStep = this.context().selectFrom(this.analyzer.table())
            .where(condition);
        final T queried = (T) ((ResultQuery) selectStep).fetchOneInto(this.analyzer.type());
        this.logging("[ Jq ] fetchOne(JsonObject) condition: \"{1}\", queried record: {0}", queried, condition);
        return queried;
    }
}