Query.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 org.apache.usergrid.mq;


import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

import org.antlr.runtime.ANTLRStringStream;
import org.antlr.runtime.CommonTokenStream;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.usergrid.persistence.CounterResolution;
import org.apache.usergrid.persistence.Entity;
import org.apache.usergrid.persistence.Identifier;
import org.apache.usergrid.persistence.Results;
import org.apache.usergrid.persistence.Results.Level;
import org.apache.usergrid.utils.JsonUtils;

import org.apache.commons.lang.StringUtils;

import static org.apache.commons.codec.binary.Base64.decodeBase64;
import static org.apache.commons.lang.StringUtils.isBlank;
import static org.apache.commons.lang.StringUtils.split;
import static org.apache.usergrid.persistence.Schema.PROPERTY_TYPE;
import static org.apache.usergrid.persistence.Schema.PROPERTY_UUID;
import static org.apache.usergrid.utils.ClassUtils.cast;
import static org.apache.usergrid.utils.ConversionUtils.uuid;
import static org.apache.usergrid.utils.ListUtils.first;
import static org.apache.usergrid.utils.ListUtils.firstBoolean;
import static org.apache.usergrid.utils.ListUtils.firstInteger;
import static org.apache.usergrid.utils.ListUtils.firstLong;
import static org.apache.usergrid.utils.ListUtils.firstUuid;
import static org.apache.usergrid.utils.ListUtils.isEmpty;
import static org.apache.usergrid.utils.MapUtils.toMapList;


public class Query {

    private static final Logger logger = LoggerFactory.getLogger( Query.class );

    public static final int DEFAULT_LIMIT = 10;

    protected String type;
    protected List<SortPredicate> sortPredicates = new ArrayList<SortPredicate>();
    protected List<FilterPredicate> filterPredicates = new ArrayList<FilterPredicate>();
    protected UUID startResult;
    protected String cursor;
    protected int limit = 0;
    protected boolean limitSet = false;

    protected Map<String, String> selectSubjects = new LinkedHashMap<String, String>();
    protected boolean mergeSelectResults = false;
    protected Level level = Level.ALL_PROPERTIES;
    protected String connection;
    protected List<String> permissions;
    protected boolean reversed;
    protected boolean reversedSet = false;
    protected Long startTime;
    protected Long finishTime;
    protected boolean pad;
    protected CounterResolution resolution = CounterResolution.ALL;
    protected List<Identifier> users;
    protected List<Identifier> groups;
    protected List<Identifier> identifiers;
    protected List<String> categories;
    protected List<CounterFilterPredicate> counterFilters;


    public Query() {
    }


    public Query( String type ) {
        this.type = type;
    }


    public Query( Query q ) {
        if ( q != null ) {
            type = q.type;
            sortPredicates = q.sortPredicates != null ? new ArrayList<SortPredicate>( q.sortPredicates ) : null;
            filterPredicates = q.filterPredicates != null ? new ArrayList<FilterPredicate>( q.filterPredicates ) : null;
            startResult = q.startResult;
            cursor = q.cursor;
            limit = q.limit;
            limitSet = q.limitSet;
            selectSubjects = q.selectSubjects != null ? new LinkedHashMap<String, String>( q.selectSubjects ) : null;
            mergeSelectResults = q.mergeSelectResults;
            level = q.level;
            connection = q.connection;
            permissions = q.permissions != null ? new ArrayList<String>( q.permissions ) : null;
            reversed = q.reversed;
            reversedSet = q.reversedSet;
            startTime = q.startTime;
            finishTime = q.finishTime;
            resolution = q.resolution;
            pad = q.pad;
            users = q.users != null ? new ArrayList<Identifier>( q.users ) : null;
            groups = q.groups != null ? new ArrayList<Identifier>( q.groups ) : null;
            identifiers = q.identifiers != null ? new ArrayList<Identifier>( q.identifiers ) : null;
            categories = q.categories != null ? new ArrayList<String>( q.categories ) : null;
            counterFilters =
                    q.counterFilters != null ? new ArrayList<CounterFilterPredicate>( q.counterFilters ) : null;
        }
    }


    public static Query fromQL( String ql ) {
        if ( ql == null ) {
            return null;
        }
        ql = ql.trim();

        String qlt = ql.toLowerCase();
        if ( !qlt.startsWith( "select" ) && !qlt.startsWith( "insert" ) && !qlt.startsWith( "update" ) && !qlt
                .startsWith( "delete" ) ) {
            if ( qlt.startsWith( "order by" ) ) {
                ql = "select * " + ql;
            }
            else {
                ql = "select * where " + ql;
            }
        }

        try {
            ANTLRStringStream in = new ANTLRStringStream( ql.trim() );
            QueryFilterLexer lexer = new QueryFilterLexer( in );
            CommonTokenStream tokens = new CommonTokenStream( lexer );
            QueryFilterParser parser = new QueryFilterParser( tokens );
            Query q = parser.ql();
            return q;
        }
        catch ( Exception e ) {
            logger.error( "Unable to parse \"" + ql + "\"", e );
        }
        return null;
    }


    public static Query newQueryIfNull( Query query ) {
        if ( query == null ) {
            query = new Query();
        }
        return query;
    }


    public static Query fromJsonString( String json ) {
        Object o = JsonUtils.parse( json );
        if ( o instanceof Map ) {
            @SuppressWarnings({ "unchecked", "rawtypes" }) Map<String, List<String>> params =
                    cast( toMapList( ( Map ) o ) );
            return fromQueryParams( params );
        }
        return null;
    }


    public static Query fromQueryParams( Map<String, List<String>> params ) {
        String type = null;
        Query q = null;
        String ql = null;
        String connection = null;
        UUID start = null;
        String cursor = null;
        Integer limit = null;
        List<String> permissions = null;
        Boolean reversed = null;
        Long startTime = null;
        Long finishTime = null;
        Boolean pad = null;
        CounterResolution resolution = null;
        List<Identifier> users = null;
        List<Identifier> groups = null;
        List<Identifier> identifiers = null;
        List<String> categories = null;
        List<CounterFilterPredicate> counterFilters = null;

        List<String> l = null;

        ql = first( params.get( "ql" ) );
        type = first( params.get( "type" ) );
        reversed = firstBoolean( params.get( "reversed" ) );
        connection = first( params.get( "connection" ) );
        start = firstUuid( params.get( "start" ) );
        cursor = first( params.get( "cursor" ) );
        limit = firstInteger( params.get( "limit" ) );
        permissions = params.get( "permission" );
        startTime = firstLong( params.get( "start_time" ) );
        finishTime = firstLong( params.get( "end_time" ) );

        l = params.get( "resolution" );
        if ( !isEmpty( l ) ) {
            resolution = CounterResolution.fromString( l.get( 0 ) );
        }

        users = Identifier.fromList( params.get( "user" ) );
        groups = Identifier.fromList( params.get( "group" ) );

        categories = params.get( "category" );

        l = params.get( "counter" );
        if ( !isEmpty( l ) ) {
            counterFilters = CounterFilterPredicate.fromList( l );
        }

        pad = firstBoolean( params.get( "pad" ) );

        for ( Entry<String, List<String>> param : params.entrySet() ) {
            if ( ( param.getValue() == null ) || ( param.getValue().size() == 0 ) ) {
                Identifier identifier = Identifier.from( param.getKey() );
                if ( identifier != null ) {
                    if ( identifiers == null ) {
                        identifiers = new ArrayList<Identifier>();
                    }
                    identifiers.add( identifier );
                }
            }
        }

        if ( ql != null ) {
            q = Query.fromQL( ql );
        }

        l = params.get( "filter" );
        if ( !isEmpty( l ) ) {
            q = newQueryIfNull( q );
            for ( String s : l ) {
                q.addFilter( s );
            }
        }

        l = params.get( "sort" );
        if ( !isEmpty( l ) ) {
            q = newQueryIfNull( q );
            for ( String s : l ) {
                q.addSort( s );
            }
        }

        if ( type != null ) {
            q = newQueryIfNull( q );
            q.setEntityType( type );
        }

        if ( connection != null ) {
            q = newQueryIfNull( q );
            q.setConnectionType( connection );
        }

        if ( permissions != null ) {
            q = newQueryIfNull( q );
            q.setPermissions( permissions );
        }

        if ( start != null ) {
            q = newQueryIfNull( q );
            q.setStartResult( start );
        }

        if ( cursor != null ) {
            q = newQueryIfNull( q );
            q.setCursor( cursor );
        }

        if ( limit != null ) {
            q = newQueryIfNull( q );
            q.setLimit( limit );
        }

        if ( startTime != null ) {
            q = newQueryIfNull( q );
            q.setStartTime( startTime );
        }

        if ( finishTime != null ) {
            q = newQueryIfNull( q );
            q.setFinishTime( finishTime );
        }

        if ( resolution != null ) {
            q = newQueryIfNull( q );
            q.setResolution( resolution );
        }

        if ( categories != null ) {
            q = newQueryIfNull( q );
            q.setCategories( categories );
        }

        if ( counterFilters != null ) {
            q = newQueryIfNull( q );
            q.setCounterFilters( counterFilters );
        }

        if ( pad != null ) {
            q = newQueryIfNull( q );
            q.setPad( pad );
        }

        if ( users != null ) {
            q = newQueryIfNull( q );
            q.setUsers( users );
        }

        if ( groups != null ) {
            q = newQueryIfNull( q );
            q.setGroups( groups );
        }

        if ( identifiers != null ) {
            q = newQueryIfNull( q );
            q.setIdentifiers( identifiers );
        }

        if ( reversed != null ) {
            q = newQueryIfNull( q );
            q.setReversed( reversed );
        }

        return q;
    }


    public static Query searchForProperty( String propertyName, Object propertyValue ) {
        Query q = new Query();
        q.addEqualityFilter( propertyName, propertyValue );
        return q;
    }


    public static Query findForProperty( String propertyName, Object propertyValue ) {
        Query q = new Query();
        q.addEqualityFilter( propertyName, propertyValue );
        q.setLimit( 1 );
        return q;
    }


    public static Query fromUUID( UUID uuid ) {
        Query q = new Query();
        q.addIdentifier( Identifier.fromUUID( uuid ) );
        return q;
    }


    public static Query fromName( String name ) {
        Query q = new Query();
        q.addIdentifier( Identifier.fromName( name ) );
        return q;
    }


    public static Query fromEmail( String email ) {
        Query q = new Query();
        q.addIdentifier( Identifier.fromEmail( email ) );
        return q;
    }


    public static Query fromIdentifier( Object id ) {
        Query q = new Query();
        q.addIdentifier( Identifier.from( id ) );
        return q;
    }


    public boolean isIdsOnly() {
        if ( ( selectSubjects.size() == 1 ) && selectSubjects.containsKey( PROPERTY_UUID ) ) {
            level = Level.IDS;
            return true;
        }
        return false;
    }


    public void setIdsOnly( boolean idsOnly ) {
        if ( idsOnly ) {
            selectSubjects = new LinkedHashMap<String, String>();
            selectSubjects.put( PROPERTY_UUID, PROPERTY_UUID );
            level = Level.IDS;
        }
        else if ( isIdsOnly() ) {
            selectSubjects = new LinkedHashMap<String, String>();
            level = Level.ALL_PROPERTIES;
        }
    }


    public Level getResultsLevel() {
        isIdsOnly();
        return level;
    }


    public void setResultsLevel( Level level ) {
        setIdsOnly( level == Level.IDS );
        this.level = level;
    }


    public Query withResultsLevel( Level level ) {
        setIdsOnly( level == Level.IDS );
        this.level = level;
        return this;
    }


    public String getEntityType() {
        return type;
    }


    public void setEntityType( String type ) {
        this.type = type;
    }


    public Query withEntityType( String type ) {
        this.type = type;
        return this;
    }


    public String getConnectionType() {
        return connection;
    }


    public void setConnectionType( String connection ) {
        this.connection = connection;
    }


    public Query withConnectionType( String connection ) {
        this.connection = connection;
        return this;
    }


    public List<String> getPermissions() {
        return permissions;
    }


    public void setPermissions( List<String> permissions ) {
        this.permissions = permissions;
    }


    public Query withPermissions( List<String> permissions ) {
        this.permissions = permissions;
        return this;
    }


    public Query addSelect( String select ) {

        return addSelect( select, null );
    }


    public Query addSelect( String select, String output ) {
        // be paranoid with the null checks because
        // the query parser sometimes flakes out
        if ( select == null ) {
            return this;
        }
        select = select.trim();

        if ( select.equals( "*" ) ) {
            return this;
        }

        mergeSelectResults = StringUtils.isNotEmpty(output);

        if ( output == null ) {
            output = "";
        }

        selectSubjects.put( select, output );

        return this;
    }


    public boolean hasSelectSubjects() {
        return !selectSubjects.isEmpty();
    }


    public Set<String> getSelectSubjects() {
        return selectSubjects.keySet();
    }


    public Map<String, String> getSelectAssignments() {
        return selectSubjects;
    }


    public void setMergeSelectResults( boolean mergeSelectResults ) {
        this.mergeSelectResults = mergeSelectResults;
    }


    public Query withMergeSelectResults( boolean mergeSelectResults ) {
        this.mergeSelectResults = mergeSelectResults;
        return this;
    }


    public boolean isMergeSelectResults() {
        return mergeSelectResults;
    }


    public Query addSort( String propertyName ) {
        if ( isBlank( propertyName ) ) {
            return this;
        }
        propertyName = propertyName.trim();
        if ( propertyName.indexOf( ',' ) >= 0 ) {
            String[] propertyNames = split( propertyName, ',' );
            for ( String s : propertyNames ) {
                addSort( s );
            }
            return this;
        }

        SortDirection direction = SortDirection.ASCENDING;
        if ( propertyName.indexOf( ' ' ) >= 0 ) {
            String[] parts = split( propertyName, ' ' );
            if ( parts.length > 1 ) {
                propertyName = parts[0];
                direction = SortDirection.find( parts[1] );
            }
        }
        else if ( propertyName.startsWith( "-" ) ) {
            propertyName = propertyName.substring( 1 );
            direction = SortDirection.DESCENDING;
        }
        else if ( propertyName.startsWith( "+" ) ) {
            propertyName = propertyName.substring( 1 );
            direction = SortDirection.ASCENDING;
        }

        return addSort( propertyName, direction );
    }


    public Query addSort( String propertyName, SortDirection direction ) {
        if ( isBlank( propertyName ) ) {
            return this;
        }
        propertyName = propertyName.trim();
        for ( SortPredicate s : sortPredicates ) {
            if ( s.getPropertyName().equals( propertyName ) ) {
                logger.error(
                        "Attempted to set sort order for " + s.getPropertyName() + " more than once, discardng..." );
                return this;
            }
        }
        sortPredicates.add( new SortPredicate( propertyName, direction ) );
        return this;
    }


    public Query addSort( SortPredicate sort ) {
        if ( sort == null ) {
            return this;
        }
        for ( SortPredicate s : sortPredicates ) {
            if ( s.getPropertyName().equals( sort.getPropertyName() ) ) {
                logger.error(
                        "Attempted to set sort order for " + s.getPropertyName() + " more than once, discardng..." );
                return this;
            }
        }
        sortPredicates.add( sort );
        return this;
    }


    public List<SortPredicate> getSortPredicates() {
        return sortPredicates;
    }


    public boolean hasSortPredicates() {
        return !sortPredicates.isEmpty();
    }


    public Query addEqualityFilter( String propertyName, Object value ) {
        return addFilter( propertyName, FilterOperator.EQUAL, value );
    }


    public Query addFilter( String propertyName, FilterOperator operator, Object value ) {
        if ( ( propertyName == null ) || ( operator == null ) || ( value == null ) ) {
            return this;
        }
        if ( PROPERTY_TYPE.equalsIgnoreCase( propertyName ) && ( value != null ) ) {
            if ( operator == FilterOperator.EQUAL ) {
                type = value.toString();
            }
        }
        else if ( "connection".equalsIgnoreCase( propertyName ) && ( value != null ) ) {
            if ( operator == FilterOperator.EQUAL ) {
                connection = value.toString();
            }
        }
        else {
            for ( FilterPredicate f : filterPredicates ) {
                if ( f.getPropertyName().equals( propertyName ) && f.getValue().equals( value ) && "*"
                        .equals( value ) ) {
                    logger.error( "Attempted to set wildcard wilder for " + f.getPropertyName()
                            + " more than once, discardng..." );
                    return this;
                }
            }
            filterPredicates.add( FilterPredicate.normalize( new FilterPredicate( propertyName, operator, value ) ) );
        }
        return this;
    }


    public Query addFilter( String filterStr ) {
        if ( filterStr == null ) {
            return this;
        }
        FilterPredicate filter = FilterPredicate.valueOf( filterStr );
        if ( ( filter != null ) && ( filter.propertyName != null ) && ( filter.operator != null ) && ( filter.value
                != null ) ) {

            if ( PROPERTY_TYPE.equalsIgnoreCase( filter.propertyName ) ) {
                if ( filter.operator == FilterOperator.EQUAL ) {
                    type = filter.value.toString();
                }
            }
            else if ( "connection".equalsIgnoreCase( filter.propertyName ) ) {
                if ( filter.operator == FilterOperator.EQUAL ) {
                    connection = filter.value.toString();
                }
            }
            else {
                for ( FilterPredicate f : filterPredicates ) {
                    if ( f.getPropertyName().equals( filter.getPropertyName() ) && f.getValue()
                                                                                    .equals( filter.getValue() ) && "*"
                            .equals( filter.getValue() ) ) {
                        logger.error( "Attempted to set wildcard wilder for " + f.getPropertyName()
                                + " more than once, discardng..." );
                        return this;
                    }
                }
                filterPredicates.add( filter );
            }
        }
        else {
            logger.error( "Unable to add filter to query: " + filterStr );
        }
        return this;
    }


    public Query addFilter( FilterPredicate filter ) {
        filter = FilterPredicate.normalize( filter );
        if ( ( filter != null ) && ( filter.propertyName != null ) && ( filter.operator != null ) && ( filter.value
                != null ) ) {

            if ( PROPERTY_TYPE.equalsIgnoreCase( filter.propertyName ) ) {
                if ( filter.operator == FilterOperator.EQUAL ) {
                    type = filter.value.toString();
                }
            }
            else if ( "connection".equalsIgnoreCase( filter.propertyName ) ) {
                if ( filter.operator == FilterOperator.EQUAL ) {
                    connection = filter.value.toString();
                }
            }
            else {
                filterPredicates.add( filter );
            }
        }
        return this;
    }


    public List<FilterPredicate> getFilterPredicates() {
        return filterPredicates;
    }


    public boolean hasFilterPredicates() {
        return !filterPredicates.isEmpty();
    }


    public Map<String, Object> getEqualityFilters() {
        Map<String, Object> map = new LinkedHashMap<String, Object>();

        for ( FilterPredicate f : filterPredicates ) {
            if ( f.operator == FilterOperator.EQUAL ) {
                Object val = f.getStartValue();
                if ( val != null ) {
                    map.put( f.getPropertyName(), val );
                }
            }
        }
        return map.size() > 0 ? map : null;
    }


    public boolean hasFiltersForProperty( String name ) {
        return hasFiltersForProperty( FilterOperator.EQUAL, name );
    }


    public boolean hasFiltersForProperty( FilterOperator operator, String name ) {
        return getFilterForProperty( operator, name ) != null;
    }


    public FilterPredicate getFilterForProperty( FilterOperator operator, String name ) {
        if ( name == null ) {
            return null;
        }
        ListIterator<FilterPredicate> iterator = filterPredicates.listIterator();
        while ( iterator.hasNext() ) {
            FilterPredicate f = iterator.next();
            if ( f.propertyName.equalsIgnoreCase( name ) ) {
                if ( operator != null ) {
                    if ( operator == f.operator ) {
                        return f;
                    }
                }
                else {
                    return f;
                }
            }
        }
        return null;
    }


    public void removeFiltersForProperty( String name ) {
        if ( name == null ) {
            return;
        }
        ListIterator<FilterPredicate> iterator = filterPredicates.listIterator();
        while ( iterator.hasNext() ) {
            FilterPredicate f = iterator.next();
            if ( f.propertyName.equalsIgnoreCase( name ) ) {
                iterator.remove();
            }
        }
    }


    public void setStartResult( UUID startResult ) {
        this.startResult = startResult;
    }


    public Query withStartResult( UUID startResult ) {
        this.startResult = startResult;
        return this;
    }


    public UUID getStartResult() {
        if ( ( startResult == null ) && ( cursor != null ) ) {
            byte[] cursorBytes = decodeBase64( cursor );
            if ( ( cursorBytes != null ) && ( cursorBytes.length == 16 ) ) {
                startResult = uuid( cursorBytes );
            }
        }
        return startResult;
    }


    public String getCursor() {
        return cursor;
    }


    public void setCursor( String cursor ) {
        if ( cursor != null ) {
            if ( cursor.length() == 22 ) {
                byte[] cursorBytes = decodeBase64( cursor );
                if ( ( cursorBytes != null ) && ( cursorBytes.length == 16 ) ) {
                    startResult = uuid( cursorBytes );
                    cursor = null;
                }
            }
        }
        this.cursor = cursor;
    }


    public Query withCursor( String cursor ) {
        setCursor( cursor );
        return this;
    }


    public int getLimit() {
        return getLimit( DEFAULT_LIMIT );
    }


    public int getLimit( int defaultLimit ) {
        if ( limit <= 0 ) {
            if ( defaultLimit > 0 ) {
                return defaultLimit;
            }
            else {
                return DEFAULT_LIMIT;
            }
        }
        return limit;
    }


    public void setLimit( int limit ) {
        limitSet = true;
        this.limit = limit;
    }


    public Query withLimit( int limit ) {
        limitSet = true;
        this.limit = limit;
        return this;
    }


    public boolean isLimitSet() {
        return limitSet;
    }


    public boolean isReversed() {
        return reversed;
    }


    public void setReversed( boolean reversed ) {
        reversedSet = true;
        this.reversed = reversed;
    }


    public boolean isReversedSet() {
        return reversedSet;
    }


    public Long getStartTime() {
        return startTime;
    }


    public void setStartTime( Long startTime ) {
        this.startTime = startTime;
    }


    public Long getFinishTime() {
        return finishTime;
    }


    public void setFinishTime( Long finishTime ) {
        this.finishTime = finishTime;
    }


    public boolean isPad() {
        return pad;
    }


    public void setPad( boolean pad ) {
        this.pad = pad;
    }


    public void setResolution( CounterResolution resolution ) {
        this.resolution = resolution;
    }


    public CounterResolution getResolution() {
        return resolution;
    }


    public List<Identifier> getUsers() {
        return users;
    }


    public void addUser( Identifier user ) {
        if ( users == null ) {
            users = new ArrayList<Identifier>();
        }
        users.add( user );
    }


    public void setUsers( List<Identifier> users ) {
        this.users = users;
    }


    public List<Identifier> getGroups() {
        return groups;
    }


    public void addGroup( Identifier group ) {
        if ( groups == null ) {
            groups = new ArrayList<Identifier>();
        }
        groups.add( group );
    }


    public void setGroups( List<Identifier> groups ) {
        this.groups = groups;
    }


    public List<Identifier> getIdentifiers() {
        return identifiers;
    }


    public void addIdentifier( Identifier identifier ) {
        if ( identifiers == null ) {
            identifiers = new ArrayList<Identifier>();
        }
        identifiers.add( identifier );
    }


    public void setIdentifiers( List<Identifier> identifiers ) {
        this.identifiers = identifiers;
    }


    public boolean containsUuidIdentifersOnly() {
        if ( hasFilterPredicates() ) {
            return false;
        }
        if ( ( identifiers == null ) || identifiers.isEmpty() ) {
            return false;
        }
        for ( Identifier identifier : identifiers ) {
            if ( !identifier.isUUID() ) {
                return false;
            }
        }
        return true;
    }


    public boolean containsSingleUuidIdentifier() {
        return containsUuidIdentifersOnly() && ( identifiers.size() == 1 );
    }


    public List<UUID> getUuidIdentifiers() {
        if ( ( identifiers == null ) || identifiers.isEmpty() ) {
            return null;
        }
        List<UUID> ids = new ArrayList<UUID>();
        for ( Identifier identifier : identifiers ) {
            if ( identifier.isUUID() ) {
                ids.add( identifier.getUUID() );
            }
        }
        return ids;
    }


    public UUID getSingleUuidIdentifier() {
        if ( !containsSingleUuidIdentifier() ) {
            return null;
        }
        return ( identifiers.get( 0 ).getUUID() );
    }


    public boolean containsNameIdentifiersOnly() {
        if ( hasFilterPredicates() ) {
            return false;
        }
        if ( ( identifiers == null ) || identifiers.isEmpty() ) {
            return false;
        }
        for ( Identifier identifier : identifiers ) {
            if ( !identifier.isName() ) {
                return false;
            }
        }
        return true;
    }


    public boolean containsSingleNameIdentifier() {
        return containsNameIdentifiersOnly() && ( identifiers.size() == 1 );
    }


    public List<String> getNameIdentifiers() {
        if ( ( identifiers == null ) || identifiers.isEmpty() ) {
            return null;
        }
        List<String> names = new ArrayList<String>();
        for ( Identifier identifier : identifiers ) {
            if ( identifier.isName() ) {
                names.add( identifier.getName() );
            }
        }
        return names;
    }


    public String getSingleNameIdentifier() {
        if ( !containsSingleNameIdentifier() ) {
            return null;
        }
        return ( identifiers.get( 0 ).toString() );
    }


    public boolean containsEmailIdentifiersOnly() {
        if ( hasFilterPredicates() ) {
            return false;
        }
        if ( ( identifiers == null ) || identifiers.isEmpty() ) {
            return false;
        }
        for ( Identifier identifier : identifiers ) {
            if ( identifier.isEmail() ) {
                return false;
            }
        }
        return true;
    }


    public boolean containsSingleEmailIdentifier() {
        return containsEmailIdentifiersOnly() && ( identifiers.size() == 1 );
    }


    public List<String> getEmailIdentifiers() {
        if ( ( identifiers == null ) || identifiers.isEmpty() ) {
            return null;
        }
        List<String> emails = new ArrayList<String>();
        for ( Identifier identifier : identifiers ) {
            if ( identifier.isEmail() ) {
                emails.add( identifier.getEmail() );
            }
        }
        return emails;
    }


    public String getSingleEmailIdentifier() {
        if ( !containsSingleEmailIdentifier() ) {
            return null;
        }
        return ( identifiers.get( 0 ).toString() );
    }


    public boolean containsNameOrEmailIdentifiersOnly() {
        if ( hasFilterPredicates() ) {
            return false;
        }
        if ( ( identifiers == null ) || identifiers.isEmpty() ) {
            return false;
        }
        for ( Identifier identifier : identifiers ) {
            if ( !identifier.isEmail() && !identifier.isName() ) {
                return false;
            }
        }
        return true;
    }


    public boolean containsSingleNameOrEmailIdentifier() {
        return containsNameOrEmailIdentifiersOnly() && ( identifiers.size() == 1 );
    }


    public List<String> getNameAndEmailIdentifiers() {
        if ( ( identifiers == null ) || identifiers.isEmpty() ) {
            return null;
        }
        List<String> ids = new ArrayList<String>();
        for ( Identifier identifier : identifiers ) {
            if ( identifier.isEmail() ) {
                ids.add( identifier.getEmail() );
            }
            else if ( identifier.isName() ) {
                ids.add( identifier.getName() );
            }
        }
        return ids;
    }


    public String getSingleNameOrEmailIdentifier() {
        if ( !containsSingleNameOrEmailIdentifier() ) {
            return null;
        }
        return ( identifiers.get( 0 ).toString() );
    }


    public List<String> getCategories() {
        return categories;
    }


    public void addCategory( String category ) {
        if ( categories == null ) {
            categories = new ArrayList<String>();
        }
        categories.add( category );
    }


    public void setCategories( List<String> categories ) {
        this.categories = categories;
    }


    public List<CounterFilterPredicate> getCounterFilters() {
        return counterFilters;
    }


    public void addCounterFilter( String counter ) {
        CounterFilterPredicate p = CounterFilterPredicate.fromString( counter );
        if ( p == null ) {
            return;
        }
        if ( counterFilters == null ) {
            counterFilters = new ArrayList<CounterFilterPredicate>();
        }
        counterFilters.add( p );
    }


    public void setCounterFilters( List<CounterFilterPredicate> counterFilters ) {
        this.counterFilters = counterFilters;
    }


    @Override
    public String toString() {
        if ( selectSubjects.isEmpty() && filterPredicates.isEmpty() ) {
            return "";
        }

        StringBuilder s = new StringBuilder( "select " );
        if ( type == null ) {
            if ( selectSubjects.isEmpty() ) {
                s.append( "*" );
            }
            else {
                if ( mergeSelectResults ) {
                    s.append( "{ " );
                    boolean first = true;
                    for ( Map.Entry<String, String> select : selectSubjects.entrySet() ) {
                        if ( !first ) {
                            s.append( ", " );
                        }
                        s.append( select.getValue() + " : " + select.getKey() );
                        first = false;
                    }
                    s.append( " }" );
                }
                else {
                    boolean first = true;
                    for ( String select : selectSubjects.keySet() ) {
                        if ( !first ) {
                            s.append( ", " );
                        }
                        s.append( select );
                        first = false;
                    }
                }
            }
        }
        else {
            s.append( type );
        }
        if ( !filterPredicates.isEmpty() ) {
            s.append( " where " );
            boolean first = true;
            for ( FilterPredicate f : filterPredicates ) {
                if ( !first ) {
                    s.append( " and " );
                }
                s.append( f.toString() );
                first = false;
            }
        }
        return s.toString();
    }


    public static enum FilterOperator {
        LESS_THAN( "<", "lt" ), LESS_THAN_OR_EQUAL( "<=", "lte" ), GREATER_THAN( ">", "gt" ),
        GREATER_THAN_OR_EQUAL( ">=", "gte" ), EQUAL( "=", "eq" ), NOT_EQUAL( "!=", "ne" ), IN( "in", null ),
        CONTAINS( "contains", null ), WITHIN( "within", null );

        private final String shortName;
        private final String textName;


        FilterOperator( String shortName, String textName ) {
            this.shortName = shortName;
            this.textName = textName;
        }


        static Map<String, FilterOperator> nameMap = new ConcurrentHashMap<String, FilterOperator>();


        static {
            for ( FilterOperator op : EnumSet.allOf( FilterOperator.class ) ) {
                if ( op.shortName != null ) {
                    nameMap.put( op.shortName, op );
                }
                if ( op.textName != null ) {
                    nameMap.put( op.textName, op );
                }
            }
        }


        public static FilterOperator find( String s ) {
            if ( s == null ) {
                return null;
            }
            return nameMap.get( s );
        }


        @Override
        public String toString() {
            return shortName;
        }
    }


    public static enum SortDirection {
        ASCENDING, DESCENDING;


        public static SortDirection find( String s ) {
            if ( s == null ) {
                return ASCENDING;
            }
            s = s.toLowerCase();
            if ( s.startsWith( "asc" ) ) {
                return ASCENDING;
            }
            if ( s.startsWith( "des" ) ) {
                return DESCENDING;
            }
            if ( s.equals( "+" ) ) {
                return ASCENDING;
            }
            if ( s.equals( "-" ) ) {
                return DESCENDING;
            }
            return ASCENDING;
        }
    }


    public static final class SortPredicate implements Serializable {
        private static final long serialVersionUID = 1L;
        private final String propertyName;
        private final Query.SortDirection direction;


        public SortPredicate( String propertyName, Query.SortDirection direction ) {
            if ( propertyName == null ) {
                throw new NullPointerException( "Property name was null" );
            }

            if ( direction == null ) {
                direction = SortDirection.ASCENDING;
            }

            this.propertyName = propertyName.trim();
            this.direction = direction;
        }


        public SortPredicate( String propertyName, String direction ) {
            this( propertyName, SortDirection.find( direction ) );
        }


        public String getPropertyName() {
            return propertyName;
        }


        public Query.SortDirection getDirection() {
            return direction;
        }


        public FilterPredicate toFilter() {
            return new FilterPredicate( propertyName, FilterOperator.EQUAL, "*" );
        }


        @Override
        public boolean equals( Object o ) {
            if ( this == o ) {
                return true;
            }
            if ( ( o == null ) || ( super.getClass() != o.getClass() ) ) {
                return false;
            }

            SortPredicate that = ( SortPredicate ) o;

            if ( direction != that.direction ) {
                return false;
            }

            return ( propertyName.equals( that.propertyName ) );
        }


        @Override
        public int hashCode() {
            int result = propertyName.hashCode();
            result = ( 31 * result ) + direction.hashCode();
            return result;
        }


        @Override
        public String toString() {
            return propertyName + ( ( direction == Query.SortDirection.DESCENDING ) ? " DESC" : "" );
        }
    }


    public static final class FilterPredicate implements Serializable {
        private static final long serialVersionUID = 1L;
        private final String propertyName;
        private final Query.FilterOperator operator;
        private final Object value;
        private String cursor;


        @SuppressWarnings({ "rawtypes", "unchecked" })
        public FilterPredicate( String propertyName, Query.FilterOperator operator, Object value ) {
            if ( propertyName == null ) {
                throw new NullPointerException( "Property name was null" );
            }
            if ( operator == null ) {
                throw new NullPointerException( "Operator was null" );
            }
            if ( ( operator == Query.FilterOperator.IN ) || ( operator == Query.FilterOperator.WITHIN ) ) {
                if ( ( !( value instanceof Collection ) ) && ( value instanceof Iterable ) ) {
                    List newValue = new ArrayList();
                    for ( Iterator i$ = ( ( Iterable ) value ).iterator(); i$.hasNext(); ) {
                        Object val = i$.next();
                        newValue.add( val );
                    }
                    value = newValue;
                }
                // DataTypeUtils.checkSupportedValue(propertyName, value, true,
                // true);
            }
            else {
                // DataTypeUtils.checkSupportedValue(propertyName, value, false,
                // false);
            }
            this.propertyName = propertyName;
            this.operator = operator;
            this.value = value;
        }


        public FilterPredicate( String propertyName, String operator, String value, String secondValue,
                                String thirdValue ) {
            this.propertyName = propertyName;
            this.operator = FilterOperator.find( operator );
            Object first_obj = parseValue( value, 0 );
            Object second_obj = parseValue( secondValue, 0 );
            Object third_obj = parseValue( thirdValue, 0 );
            if ( second_obj != null ) {
                if ( third_obj != null ) {
                    this.value = Arrays.asList( first_obj, second_obj, third_obj );
                }
                else {
                    this.value = Arrays.asList( first_obj, second_obj );
                }
            }
            else {
                this.value = first_obj;
            }
        }


        public FilterPredicate( String propertyName, String operator, String value, int valueType, String secondValue,
                                int secondValueType, String thirdValue, int thirdValueType ) {
            this.propertyName = propertyName;
            this.operator = FilterOperator.find( operator );
            Object first_obj = parseValue( value, valueType );
            Object second_obj = parseValue( secondValue, secondValueType );
            Object third_obj = parseValue( thirdValue, thirdValueType );
            if ( second_obj != null ) {
                if ( third_obj != null ) {
                    this.value = Arrays.asList( first_obj, second_obj, third_obj );
                }
                else {
                    this.value = Arrays.asList( first_obj, second_obj );
                }
            }
            else {
                this.value = first_obj;
            }
        }


        private static Object parseValue( String val, int valueType ) {
            if ( val == null ) {
                return null;
            }

            if ( val.startsWith( "'" ) && ( val.length() > 1 ) ) {
                return val.substring( 1, val.length() - 1 );
            }

            if ( val.equalsIgnoreCase( "true" ) || val.equalsIgnoreCase( "false" ) ) {
                return Boolean.valueOf( val );
            }

            if ( val.length() == 36 ) {
                try {
                    return UUID.fromString( val );
                }
                catch ( IllegalArgumentException e ) {
                }
            }

            try {
                return Long.valueOf( val );
            }
            catch ( NumberFormatException e ) {
            }

            try {
                return Float.valueOf( val );
            }
            catch ( NumberFormatException e ) {

            }

            return null;
        }


        public static FilterPredicate valueOf( String str ) {
            if ( str == null ) {
                return null;
            }
            try {
                ANTLRStringStream in = new ANTLRStringStream( str.trim() );
                QueryFilterLexer lexer = new QueryFilterLexer( in );
                CommonTokenStream tokens = new CommonTokenStream( lexer );
                QueryFilterParser parser = new QueryFilterParser( tokens );
                FilterPredicate filter = parser.filter();
                return normalize( filter );
            }
            catch ( Exception e ) {
                logger.error( "Unable to parse \"" + str + "\"", e );
            }
            return null;
        }


        public static FilterPredicate normalize( FilterPredicate p ) {
            if ( p == null ) {
                return null;
            }
            if ( p.operator == FilterOperator.CONTAINS ) {
                String propertyName = appendSuffix( p.propertyName, "keywords" );
                return new FilterPredicate( propertyName, FilterOperator.EQUAL, p.value );
            }
            else if ( p.operator == FilterOperator.WITHIN ) {
                String propertyName = appendSuffix( p.propertyName, "coordinates" );
                return new FilterPredicate( propertyName, FilterOperator.WITHIN, p.value );
            }

            return p;
        }


        private static String appendSuffix( String str, String suffix ) {
            if ( StringUtils.isNotEmpty( str ) ) {
                if ( !str.endsWith( "." + suffix ) ) {
                    str += "." + suffix;
                }
            }
            else {
                str = suffix;
            }
            return str;
        }


        public String getPropertyName() {
            return propertyName;
        }


        public Query.FilterOperator getOperator() {
            return operator;
        }


        public Object getValue() {
            return value;
        }


        @SuppressWarnings("unchecked")
        public Object getStartValue() {
            if ( value instanceof List ) {
                List<Object> l = ( List<Object> ) value;
                return l.get( 0 );
            }
            if ( ( operator == FilterOperator.GREATER_THAN ) || ( operator == FilterOperator.GREATER_THAN_OR_EQUAL )
                    || ( operator == FilterOperator.EQUAL ) ) {
                return value;
            }
            else {
                return null;
            }
        }


        @SuppressWarnings("unchecked")
        public Object getFinishValue() {
            if ( value instanceof List ) {
                List<Object> l = ( List<Object> ) value;
                if ( l.size() > 1 ) {
                    return l.get( 1 );
                }
                return null;
            }
            if ( ( operator == FilterOperator.LESS_THAN ) || ( operator == FilterOperator.LESS_THAN_OR_EQUAL ) || (
                    operator == FilterOperator.EQUAL ) ) {
                return value;
            }
            else {
                return null;
            }
        }


        public void setCursor( String cursor ) {
            this.cursor = cursor;
        }


        public String getCursor() {
            return cursor;
        }


        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = ( prime * result ) + ( ( operator == null ) ? 0 : operator.hashCode() );
            result = ( prime * result ) + ( ( propertyName == null ) ? 0 : propertyName.hashCode() );
            result = ( prime * result ) + ( ( value == null ) ? 0 : value.hashCode() );
            return result;
        }


        @Override
        public boolean equals( Object obj ) {
            if ( this == obj ) {
                return true;
            }
            if ( obj == null ) {
                return false;
            }
            if ( getClass() != obj.getClass() ) {
                return false;
            }
            FilterPredicate other = ( FilterPredicate ) obj;
            if ( operator != other.operator ) {
                return false;
            }
            if ( propertyName == null ) {
                if ( other.propertyName != null ) {
                    return false;
                }
            }
            else if ( !propertyName.equals( other.propertyName ) ) {
                return false;
            }
            if ( value == null ) {
                if ( other.value != null ) {
                    return false;
                }
            }
            else if ( !value.equals( other.value ) ) {
                return false;
            }
            return true;
        }


        @Override
        public String toString() {
            String valueStr = "\'\'";
            if ( value != null ) {
                if ( value instanceof String ) {
                    valueStr = "\'" + value + "\'";
                }
                else {
                    valueStr = value.toString();
                }
            }
            return propertyName + " " + operator.toString() + " " + valueStr;
        }
    }


    public static final class CounterFilterPredicate implements Serializable {

        private static final long serialVersionUID = 1L;
        private final String name;
        private final Identifier user;
        private final Identifier group;
        private final String queue;
        private final String category;


        public CounterFilterPredicate( String name, Identifier user, Identifier group, String queue, String category ) {
            this.name = name;
            this.user = user;
            this.group = group;
            this.queue = queue;
            this.category = category;
        }


        public Identifier getUser() {
            return user;
        }


        public Identifier getGroup() {
            return group;
        }


        public String getQueue() {
            return queue;
        }


        public String getCategory() {
            return category;
        }


        public String getName() {
            return name;
        }


        public static CounterFilterPredicate fromString( String s ) {
            Identifier user = null;
            Identifier group = null;
            String category = null;
            String name = null;
            String[] l = split( s, ':' );

            if ( l.length > 0 ) {
                if ( !"*".equals( l[0] ) ) {
                    name = l[0];
                }
            }

            if ( l.length > 1 ) {
                if ( !"*".equals( l[1] ) ) {
                    user = Identifier.from( l[1] );
                }
            }

            if ( l.length > 2 ) {
                if ( !"*".equals( l[2] ) ) {
                    group = Identifier.from( l[3] );
                }
            }

            if ( l.length > 3 ) {
                if ( !"*".equals( l[3] ) ) {
                    category = l[3];
                }
            }

            if ( ( user == null ) && ( group == null ) && ( category == null ) && ( name == null ) ) {
                return null;
            }

            return new CounterFilterPredicate( name, user, group, null, category );
        }


        public static List<CounterFilterPredicate> fromList( List<String> l ) {
            if ( ( l == null ) || ( l.size() == 0 ) ) {
                return null;
            }
            List<CounterFilterPredicate> counterFilters = new ArrayList<CounterFilterPredicate>();
            for ( String s : l ) {
                CounterFilterPredicate filter = CounterFilterPredicate.fromString( s );
                if ( filter != null ) {
                    counterFilters.add( filter );
                }
            }
            if ( counterFilters.size() == 0 ) {
                return null;
            }
            return counterFilters;
        }
    }


    public List<Object> getSelectionResults( Results rs ) {

        List<Entity> entities = rs.getEntities();
        if ( entities == null ) {
            return null;
        }

        if ( !hasSelectSubjects() ) {
            return cast( entities );
        }

        List<Object> results = new ArrayList<Object>();

        for ( Entity entity : entities ) {
            if ( isMergeSelectResults() ) {
                boolean include = false;
                Map<String, Object> result = new LinkedHashMap<String, Object>();
                Map<String, String> selects = getSelectAssignments();
                for ( Map.Entry<String, String> select : selects.entrySet() ) {
                    Object obj = JsonUtils.select( entity, select.getKey(), false );
                    if ( obj == null ) {
                        obj = "";
                    }
                    else {
                        include = true;
                    }
                    result.put( select.getValue(), obj );
                }
                if ( include ) {
                    results.add( result );
                }
            }
            else {
                boolean include = false;
                List<Object> result = new ArrayList<Object>();
                Set<String> selects = getSelectSubjects();
                for ( String select : selects ) {
                    Object obj = JsonUtils.select( entity, select );
                    if ( obj == null ) {
                        obj = "";
                    }
                    else {
                        include = true;
                    }
                    result.add( obj );
                }
                if ( include ) {
                    results.add( result );
                }
            }
        }

        if ( results.size() == 0 ) {
            return null;
        }

        return results;
    }


    public Object getSelectionResult( Results rs ) {
        List<Object> r = getSelectionResults( rs );
        if ( ( r != null ) && ( r.size() > 0 ) ) {
            return r.get( 0 );
        }
        return null;
    }
}