All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • info.archinnov.achilles.query.slice.SelectPartitionRoot Maven / Gradle / Ivy

    There is a newer version: 6.1.0
    Show newest version
    /*
 * Copyright (C) 2012-2014 DuyHai DOAN
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package info.archinnov.achilles.query.slice;

import static info.archinnov.achilles.query.slice.BoundingMode.EXCLUSIVE_BOUNDS;
import static info.archinnov.achilles.query.slice.BoundingMode.INCLUSIVE_BOUNDS;
import static info.archinnov.achilles.query.slice.BoundingMode.INCLUSIVE_END_BOUND_ONLY;
import static info.archinnov.achilles.query.slice.BoundingMode.INCLUSIVE_START_BOUND_ONLY;
import static info.archinnov.achilles.query.slice.OrderingMode.ASCENDING;
import static info.archinnov.achilles.query.slice.OrderingMode.DESCENDING;
import static info.archinnov.achilles.query.slice.SliceQueryProperties.SliceType;

import java.util.List;
import com.google.common.collect.FluentIterable;
import com.google.common.util.concurrent.FutureCallback;
import info.archinnov.achilles.internal.metadata.holder.EntityMeta;
import info.archinnov.achilles.internal.persistence.operations.SliceQueryExecutor;
import info.archinnov.achilles.type.ConsistencyLevel;

public abstract class SelectPartitionRoot> extends SliceQueryRootExtended {

    protected SelectPartitionRoot(SliceQueryExecutor sliceQueryExecutor, Class entityClass, EntityMeta meta, SliceType sliceType) {
        super(sliceQueryExecutor, entityClass, meta, sliceType);
    }

    /**
     *
     * Get selected entities without filtering clustering keys. If no limit has been set, the default LIMIT 100 applies
     *
     * 
    
     *
     *  manager.sliceQuery(ArticleRating.class)
     *      .forSelect()
     *      .withPartitionComponents(articleId)
     *      .get();
     *
     * 
    
     *
     * Generated CQL  query:
     *
     * 
    
     *  SELECT * FROM article_rating WHERE article_id=... ORDER BY rating ASC LIMIT 100
     *
     * @return slice DSL
     */
    public List get() {
        return super.getInternal();
    }

    /**
     *
     * Get selected entities without filtering clustering keys using provided limit
     *
     * 
    
     *
     *  manager.sliceQuery(ArticleRating.class)
     *      .forSelect()
     *      .withPartitionComponents(articleId)
     *      .get(23);
     *
     * 
    
     *
     * Generated CQL  query:
     *
     * 
    
     *  SELECT * FROM article_rating WHERE article_id=... ORDER BY rating ASC LIMIT 23
     *
     * @return slice DSL
     */
    public List get(int limit) {
        super.properties.limit(limit);
        return super.getInternal();
    }

    /**
     *
     * Get first entity without filtering clustering keys
     * To get the last entity, just use getOne() with orderByDescending()
     *
     * 
    
     *
     *  manager.sliceQuery(ArticleRating.class)
     *      .forSelect()
     *      .withPartitionComponents(articleId)
     *      .getOne();
     *
     * 
    
     *
     * Generated CQL  query:
     *
     * 
    
     *  SELECT * FROM article_rating WHERE article_id=... ORDER BY rating ASC LIMIT 1
     *
     * @return slice DSL
     */
    public TYPE getOne() {
        super.properties.limit(1);
        return FluentIterable.from(super.getInternal()).first().orNull();
    }

    /**
     *
     * Get entities with matching clustering keys
     *
     * 
    
     *
     *  manager.sliceQuery(ArticleRating.class)
     *      .forSelect()
     *      .withPartitionComponents(articleId)
     *      .getMatching(2);
     *
     * 
    
     *
     * Generated CQL  query:
     *
     * 
    
     *  SELECT * FROM article_rating WHERE article_id=... AND rating=2 ORDER BY rating ASC LIMIT 100
     *
     * @return slice DSL
     */
    public List getMatching(Object... matchedClusteringKeys) {
        super.withClusteringsInternal(matchedClusteringKeys);
        return super.getInternal();
    }

    /**
     *
     * Get first entity with matching clustering keys
     *
     * 
    
     *
     *  manager.sliceQuery(ArticleRating.class)
     *      .forSelect()
     *      .withPartitionComponents(articleId)
     *      .getOneMatching(2);
     *
     * 
    
     *
     * Generated CQL  query:
     *
     * 
    
     *  SELECT * FROM article_rating WHERE article_id=... AND rating=2 ORDER BY rating ASC LIMIT 1
     *
     * @return slice DSL
     */
    public TYPE getOneMatching(Object... matchedClusteringKeys) {
        return FluentIterable.from(this.getMatching(matchedClusteringKeys)).first().orNull();
    }

    /**
     *
     * Get first entities with matching clustering keys
     *
     * 
    
     *
     *  manager.sliceQuery(ArticleRating.class)
     *      .forSelect()
     *      .withPartitionComponents(articleId)
     *      .getFirstMatching(10,2);
     *
     * 
    
     *
     * Generated CQL  query:
     *
     * 
    
     *  SELECT * FROM article_rating WHERE article_id=... AND rating=2 ORDER BY rating ASC LIMIT 10
     *
     * @return slice DSL
     */
    public List getFirstMatching(int limit, Object... matchingClusteringKeys) {
        super.properties.ordering(ASCENDING);
        super.properties.limit(limit);
        super.withClusteringsInternal(matchingClusteringKeys);
        return super.getInternal();
    }

    /**
     *
     * Get last entities with matching clustering keys. It is similar to calling
     * getFirstMatching(...) combined with orderByDescending()
     *
     * 
    
     *
     *  manager.sliceQuery(ArticleRating.class)
     *      .forSelect()
     *      .withPartitionComponents(articleId)
     *      .getLastMatching(10,2);
     *
     * 
    
     *
     * Generated CQL  query:
     *
     * 
    
     *  SELECT * FROM article_rating WHERE article_id=... AND rating=2 ORDER BY rating DESC LIMIT 10
     *
     * @return slice DSL
     */
    public List getLastMatching(int limit, Object... matchingClusteringKeys) {
        super.properties.ordering(DESCENDING);
        super.withClusteringsInternal(matchingClusteringKeys);
        super.properties.limit(limit);
        return super.getInternal();
    }

    /**
     *
     * Filter with lower bound clustering key(s)
     *
     * 
    
     *
     *  manager.sliceQuery(ArticleRating.class)
     *      .forSelect()
     *      .withPartitionComponents(articleId)
     *      .fromClusterings(2,now)
     *      .get();
     *
     * 
    
     *
     * Generated CQL  query:
     *
     * 
    
     *  SELECT * FROM article_rating WHERE article_id=... AND (rating,date)>=(2,now) ORDER BY rating ASC LIMIT 100
     * 
    
     * 
    
     * Remark: the generated CQL  query will take into account the defined clustering order of the table. For example if the clustering order is descending,
     * 
    
     *     fromClustering("col1","col2)
     * 
    
     * will generate
     * 
    
     *     WHERE (col1,col2)<=(:col1,:col2)
     * 
    
     *
     * @return slice DSL
     */
    public SelectFromClusterings fromClusterings(Object... fromClusteringKeys) {
        super.fromClusteringsInternal(fromClusteringKeys);
        return new SelectFromClusterings<>();
    }

    /**
     *
     * Filter with upper bound clustering key(s)
     *
     * 
    
     *
     *  manager.sliceQuery(ArticleRating.class)
     *      .forSelect()
     *      .withPartitionComponents(articleId)
     *      .toClusterings(3)
     *      .get();
     *
     * 
    
     *
     * Generated CQL  query:
     *
     * 
    
     *  SELECT * FROM article_rating WHERE article_id=... AND rating<=3 ORDER BY rating ASC LIMIT 100
     * 
    
     * 
    
     * Remark: the generated CQL  query will take into account the defined clustering order of the table. For example if the clustering order is descending,
     * 
    
     *     toClustering("col1","col2)
     * 
    
     * will generate
     * 
    
     *     WHERE (col1,col2)>=(:col1,:col2)
     * 
    
     *
     * @return slice DSL
     */
    public SelectEnd toClusterings(Object... toClusteringKeys) {
        super.toClusteringsInternal(toClusteringKeys);
        return new SelectEnd<>();
    }

    /**
     *
     * Filter with matching clustering key(s)
     *
     * 
    
     *
     *  manager.sliceQuery(ArticleRating.class)
     *      .forSelect()
     *      .withPartitionComponents(articleId)
     *      .withClusterings(3)
     *      .get();
     *
     * 
    
     *
     * Generated CQL  query:
     *
     * 
    
     *  SELECT * FROM article_rating WHERE article_id=... AND rating=3 ORDER BY rating ASC LIMIT 100
     *
     * @return slice DSL
     */
    public SelectWithClusterings withClusterings(Object... clusteringKeys) {
        super.withClusteringsInternal(clusteringKeys);
        return new SelectWithClusterings<>();
    }

    public abstract class SelectClusteringsRootWithLimitation> {


        /**
         *
         * Use ascending order for the first clustering key. This is the default ordering
         *
         * 
    
         *
         *  manager.sliceQuery(ArticleRating.class)
         *      .forSelect()
         *      .withPartitionComponents(articleId)
         *      .fromClusterings(2, now)
         *      .toClusterings(4)
         *      .orderByAscending()
         *      .get(20);
         *
         * 
    
         *
         * Generated CQL  query:
         *
         * 
    
         *  SELECT * FROM article_rating WHERE article_id=... AND (rating,date)>=(2,now) AND (rating)<=4 ORDER BY rating ASC LIMIT 20
         * @return Slice DSL
         */
        public T orderByAscending() {
            SelectPartitionRoot.super.properties.ordering(ASCENDING);
            return getThis();
        }

        /**
         *
         * Use descending order for the first clustering key
         *
         * 
    
         *
         *  manager.sliceQuery(ArticleRating.class)
         *      .forSelect()
         *      .withPartitionComponents(articleId)
         *      .fromClusterings(2, now)
         *      .toClusterings(4)
         *      .orderByDescending()
         *      .get(20);
         *
         * 
    
         *
         * Generated CQL  query:
         *
         * 
    
         *  SELECT * FROM article_rating WHERE article_id=... AND (rating,date)>=(2,now) AND (rating)<=4 ORDER BY rating DESC LIMIT 20
         * @return Slice DSL
         */
        public T orderByDescending() {
            SelectPartitionRoot.super.properties.ordering(DESCENDING);
            return getThis();
        }

        /**
         *
         * Set a limit to the query. A default limit of 100 is always set to avoid OutOfMemoryException
         * You can remove it at your own risk using noLimit()
         *
         * 
    
         *
         *  manager.sliceQuery(ArticleRating.class)
         *      .forSelect()
         *      .withPartitionComponents(articleId)
         *      .fromClusterings(2, now)
         *      .toClusterings(4)
         *      .limit(5)
         *      .get();
         *
         * 
    
         *
         * Generated CQL  query:
         *
         * 
    
         *  SELECT * FROM article_rating WHERE article_id=... AND (rating,date)>=(2,now) AND (rating)<=4 ORDER BY rating ASC LIMIT 5
         * @return Slice DSL
         */
        public T limit(int limit) {
            SelectPartitionRoot.super.properties.limit(limit);
            return getThis();
        }

        /**
         *
         * Provide a consistency level for SELECT statement
         *
         * @param consistencyLevel
         * @return Slice DSL
         */
        public T withConsistency(ConsistencyLevel consistencyLevel) {
            SelectPartitionRoot.super.properties.readConsistency(consistencyLevel);
            return getThis();
        }

        public T withAsyncListeners(FutureCallback...asyncListeners) {
            SelectPartitionRoot.this.properties.asyncListeners(asyncListeners);
            return getThis();
        }

        protected abstract T getThis();

        /**
         *
         * Get first entity with filtering clustering keys
         * To get the last entity, just use getOne() with orderByDescending()
         *
         * 
    
         *
         *  manager.sliceQuery(ArticleRating.class)
         *      .forSelect()
         *      .withPartitionComponents(articleId)
         *      .fromClusterings(2)
         *      .getOne();
         *
         * 
    
         *
         * Generated CQL  query:
         *
         * 
    
         *  SELECT * FROM article_rating WHERE article_id=... AND rating>=2 ORDER BY rating ASC LIMIT 1
         *
         * @return slice DSL
         */
        public TYPE getOne() {
            SelectPartitionRoot.super.properties.limit(1);
            return FluentIterable.from(SelectPartitionRoot.super.getInternal()).first().orNull();
        }

        /**
         *
         * Get first entity with filtering clustering keys
         * To get the last entity, just use getOne() with orderByDescending()
         *
         * 
    
         *
         *  manager.sliceQuery(ArticleRating.class)
         *      .forSelect()
         *      .withPartitionComponents(articleId)
         *      .fromClusterings(2)
         *      .get();
         *
         * 
    
         *
         * Generated CQL  query:
         *
         * 
    
         *  SELECT * FROM article_rating WHERE article_id=... AND rating>=2 ORDER BY rating ASC LIMIT 100
         *
         * @return slice DSL
         */
        public List get() {
            return SelectPartitionRoot.super.getInternal();
        }

        /**
         *
         * Get first entity with filtering clustering keys with provided limit
         * To get the last entity, just use getOne() with orderByDescending()
         *
         * 
    
         *
         *  manager.sliceQuery(ArticleRating.class)
         *      .forSelect()
         *      .withPartitionComponents(articleId)
         *      .fromClusterings(2)
         *      .get(23);
         *
         * 
    
         *
         * Generated CQL  query:
         *
         * 
    
         *  SELECT * FROM article_rating WHERE article_id=... AND rating>=2 ORDER BY rating ASC LIMIT 23
         *
         * @return slice DSL
         */
        public List get(int limit) {
            SelectPartitionRoot.super.properties.limit(limit);
            return SelectPartitionRoot.super.getInternal();
        }
    }

    public abstract class SelectClusteringsRoot> extends SelectClusteringsRootWithLimitation {

        /**
         *
         * Use inclusive upper & lower bounds
         *
         * 
    
         *
         *  manager.sliceQuery(ArticleRating.class)
         *      .forSelect()
         *      .withPartitionComponents(articleId)
         *      .fromClusterings(2, now)
         *      .toClusterings(4)
         *      .withInclusiveBounds()
         *      .get(20);
         *
         *
         * 
    
         *
         * Generated CQL  query:
         *
         * 
    
         *  SELECT * FROM article_rating WHERE article_id=... AND (rating,date)>=(2,now) AND (rating)<=4 ORDER BY rating ASC LIMIT 20
         * @return Slice DSL
         */
        public T withInclusiveBounds() {
            SelectPartitionRoot.super.properties.bounding(INCLUSIVE_BOUNDS);
            return getThis();
        }

        /**
         *
         * Use exclusive upper & lower bounds
         *
         * 
    
         *
         *  manager.sliceQuery(ArticleRating.class)
         *      .forSelect()
         *      .withPartitionComponents(articleId)
         *      .fromClusterings(2, now)
         *      .toClusterings(4)
         *      .withExclusiveBounds()
         *      .get(20);
         *
         * 
    
         *
         * Generated CQL  query:
         *
         * 
    
         *  SELECT * FROM article_rating WHERE article_id=... AND (rating,date)>(2,now) AND (rating)<4 ORDER BY rating ASC LIMIT 20
         * @return Slice DSL
         */
        public T withExclusiveBounds() {
            SelectPartitionRoot.super.properties.bounding(EXCLUSIVE_BOUNDS);
            return getThis();
        }

        /**
         *
         * Use inclusive lower bound and exclusive upper bounds
         *
         * 
    
         *
         *  manager.sliceQuery(ArticleRating.class)
         *      .forSelect()
         *      .withPartitionComponents(articleId)
         *      .fromClusterings(2, now)
         *      .toClusterings(4)
         *      .withExclusiveBounds()
         *      .get(20);
         *
         * 
    
         *
         * Generated CQL  query:
         *
         * 
    
         *  SELECT * FROM article_rating WHERE article_id=... AND (rating,date)>=(2,now) AND (rating)<4 ORDER BY rating ASC LIMIT 20
         * @return Slice DSL
         */
        public T fromInclusiveToExclusiveBounds() {
            SelectPartitionRoot.super.properties.bounding(INCLUSIVE_START_BOUND_ONLY);
            return getThis();
        }

        /**
         *
         * Use exclusive lower bound and inclusive upper bounds
         *
         * 
    
         *
         *  manager.sliceQuery(ArticleRating.class)
         *      .forSelect()
         *      .withPartitionComponents(articleId)
         *      .fromClusterings(2, now)
         *      .toClusterings(4)
         *      .withExclusiveBounds()
         *      .get(20);
         *
         * 
    
         *
         * Generated CQL  query:
         *
         * 
    
         *  SELECT * FROM article_rating WHERE article_id=... AND (rating,date)>(2,now) AND (rating)<=4 ORDER BY rating ASC LIMIT 20
         * @return Slice DSL
         */
        public T fromExclusiveToInclusiveBounds() {
            SelectPartitionRoot.super.properties.bounding(INCLUSIVE_END_BOUND_ONLY);
            return getThis();
        }


    }

    public class SelectFromClusterings extends SelectClusteringsRoot> {

        /**
         *
         * Filter with upper bound clustering key(s)
         *
         * 
    
         *
         *  manager.sliceQuery(ArticleRating.class)
         *      .forSelect()
         *      .withPartitionComponents(articleId)
         *      .toClusterings(3)
         *      .get();
         *
         * 
    
         *
         * Generated CQL  query:
         *
         * 
    
         *  SELECT * FROM article_rating WHERE article_id=... AND rating<=3 ORDER BY rating ASC LIMIT 100
         * 
    
         * 
    
         * Remark: the generated CQL  query will take into account the defined clustering order of the table. For example if the clustering order is descending,
         * 
    
         *     toClustering("col1","col2)
         * 
    
         * will generate
         * 
    
         *     WHERE (col1,col2)>=(:col1,:col2)
         * 
    
         *
         * @return slice DSL
         */
        public SelectEnd toClusterings(Object... clusteringKeys) {
            SelectPartitionRoot.super.toClusteringsInternal(clusteringKeys);
            return new SelectEnd<>();
        }

        @Override
        protected SelectFromClusterings getThis() {
            return SelectFromClusterings.this;
        }
    }

    public class SelectWithClusterings extends SelectClusteringsRootWithLimitation> {

        /**
         *
         * Filter with clustering key(s) IN a list of provided values
         *
         * 
    
         *
         *  manager.sliceQuery(ArticleRating.class)
         *      .forSelect()
         *      .withPartitionComponents(articleId)
         *      .withClusterings(3)
         *      .andClusteringsIN(now,tomorrow,yesterday)
         *      .get();
         *
         * 
    
         *
         * Generated CQL  query:
         *
         * 
    
         *  SELECT * FROM article_rating WHERE article_id=... AND rating=3 AND date IN (now,tomorrow,yesterday) ORDER BY rating ASC LIMIT 100
         *
         * @return slice DSL
         */
        public SelectEndWithLimitation andClusteringsIN(Object... clusteringKeys) {
            SelectPartitionRoot.super.andClusteringsInInternal(clusteringKeys);
            return new SelectEndWithLimitation<>();
        }

        @Override
        protected SelectWithClusterings getThis() {
            return SelectWithClusterings.this;
        }
    }

    public class SelectEnd extends SelectClusteringsRoot> {

        @Override
        protected SelectEnd getThis() {
            return SelectEnd.this;
        }
    }

    public class SelectEndWithLimitation extends SelectClusteringsRootWithLimitation> {

        @Override
        protected SelectEndWithLimitation getThis() {
            return SelectEndWithLimitation.this;
        }
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy