/*
* 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.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.Entity;
import org.apache.usergrid.persistence.Results;
import org.apache.usergrid.utils.JsonUtils;
import org.springframework.util.Assert;
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 org.apache.usergrid.persistence.index.query.CounterResolution;
import org.apache.usergrid.persistence.index.query.Identifier;
import org.apache.usergrid.persistence.Query.Level;
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 {} more than once, discarding...", s.getPropertyName() );
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 {} more than once, discarding...", s.getPropertyName() );
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 {} more than once, discarding...", f.getPropertyName());
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 {} more than once, discarding...", f.getPropertyName());
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 ) {
Assert.notNull(propertyName, "Property name was null");
Assert.notNull(operator, "Operator was null");
if ( ( operator == Query.FilterOperator.IN ) || ( operator == Query.FilterOperator.WITHIN ) ) {
if ( ( !( value instanceof Collection ) ) && ( value instanceof Iterable ) ) {
List newValue = new ArrayList();
for (Object val : ((Iterable) value)) {
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;
}
}