org.jnosql.artemis.column.query.DefaultColumnMapperSelectBuilder Maven / Gradle / Ivy

Go to download
/*
 *  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.query;

import org.jnosql.artemis.Converters;
import org.jnosql.artemis.column.ColumnTemplate;
import org.jnosql.artemis.column.ColumnTemplateAsync;
import org.jnosql.artemis.reflection.ClassMapping;
import org.jnosql.diana.api.Sort;
import org.jnosql.diana.api.column.ColumnQuery;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;

import static java.util.Objects.requireNonNull;

class DefaultColumnMapperSelectBuilder extends AbstractMapperQuery implements ColumnMapperFrom, ColumnMapperLimit, ColumnMapperSkip,
        ColumnMapperOrder, ColumnMapperNameCondition, ColumnMapperNotCondition, ColumnMapperNameOrder, ColumnMapperWhere {


    private final List sorts = new ArrayList<>();


    DefaultColumnMapperSelectBuilder(ClassMapping mapping, Converters converters) {
        super(mapping, converters);
    }


    @Override
    public ColumnMapperNameCondition and(String name) {
        requireNonNull(name, "name is required");
        this.name = name;
        this.and = true;
        return this;
    }

    @Override
    public ColumnMapperNameCondition or(String name) {
        requireNonNull(name, "name is required");
        this.name = name;
        this.and = false;
        return this;
    }

    @Override
    public ColumnMapperNameCondition where(String name) {
        requireNonNull(name, "name is required");
        this.name = name;
        return this;
    }

    @Override
    public ColumnMapperSkip skip(long skip) {
        this.start = skip;
        return this;
    }

    @Override
    public ColumnMapperLimit limit(long limit) {
        this.limit = limit;
        return this;
    }

    @Override
    public ColumnMapperOrder orderBy(String name) {
        requireNonNull(name, "name is required");
        this.name = name;
        return this;
    }


    @Override
    public ColumnMapperNotCondition not() {
        this.negate = true;
        return this;
    }

    @Override
    public  ColumnMapperWhere eq(T value) {
        eqImpl(value);
        return this;
    }


    @Override
    public ColumnMapperWhere like(String value) {
        likeImpl(value);
        return this;
    }


    @Override
    public  ColumnMapperWhere gt(T value) {
        gtImpl(value);
        return this;
    }


    @Override
    public  ColumnMapperWhere gte(T value) {
        gteImpl(value);
        return this;
    }

    @Override
    public  ColumnMapperWhere lt(T value) {
        ltImpl(value);
        return this;
    }


    @Override
    public  ColumnMapperWhere lte(T value) {
        lteImpl(value);
        return this;
    }


    @Override
    public  ColumnMapperWhere between(T valueA, T valueB) {
        betweenImpl(valueA, valueB);
        return this;
    }

    @Override
    public  ColumnMapperWhere in(Iterable values) {
        inImpl(values);
        return this;
    }

    @Override
    public ColumnMapperNameOrder asc() {
        this.sorts.add(Sort.of(mapping.getColumnField(name), Sort.SortType.ASC));
        return this;
    }

    @Override
    public ColumnMapperNameOrder desc() {
        this.sorts.add(Sort.of(mapping.getColumnField(name), Sort.SortType.DESC));
        return this;
    }


    @Override
    public ColumnQuery build() {
        return new ArtemisColumnQuery(sorts, limit, start, condition, columnFamily);
    }

    @Override
    public  List execute(ColumnTemplate template) {
        requireNonNull(template, "template is required");
        return template.select(this.build());
    }

    @Override
    public  Optional executeSingle(ColumnTemplate template) {
        requireNonNull(template, "template is required");
        return template.singleResult(this.build());
    }

    @Override
    public  void execute(ColumnTemplateAsync template, Consumer> callback) {
        requireNonNull(template, "template is required");
        requireNonNull(callback, "callback is required");
        template.select(this.build(), callback);
    }

    @Override
    public  void executeSingle(ColumnTemplateAsync template, Consumer> callback) {
        requireNonNull(template, "template is required");
        requireNonNull(callback, "callback is required");
        template.singleResult(this.build(), callback);
    }

}