@Override
public void visit( ContainsOperand op ) throws NoFullTextIndexException {
    final String name = op.getProperty().getValue().toLowerCase();
    final String value = op.getLiteral().getValue().toString().toLowerCase();


    // or field is just a string that does need a prefix
    if ( value.indexOf( "*" ) != -1 ) {
        final WildcardQueryBuilder wildcardQuery =
                QueryBuilders.wildcardQuery( IndexingUtils.FIELD_STRING_NESTED, value );
        queryBuilders.push( fieldNameTerm( name, wildcardQuery ) );
    }
    else {
        final MatchQueryBuilder termQuery = QueryBuilders.matchQuery( IndexingUtils.FIELD_STRING_NESTED, value );

        queryBuilders.push( fieldNameTerm( name, termQuery ) );
    }


    //no op for filters, push an empty operation

    //TODO, validate this works
    filterBuilders.push( NoOpFilterBuilder.INSTANCE );
}
 

public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setWebConfigId_Wildcard(String webConfigId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("webConfigId", webConfigId);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setPermissions_Wildcard(String permissions, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("permissions", permissions);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setErrorLog_Wildcard(String errorLog, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("errorLog", errorLog);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setHitCountRelation_Wildcard(String hitCountRelation, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("hitCountRelation", hitCountRelation);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setIncludedUrls_Wildcard(String includedUrls, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("includedUrls", includedUrls);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setQueryId_Wildcard(String queryId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("queryId", queryId);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setReferer_Wildcard(String referer, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("referer", referer);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setParameterName_Wildcard(String parameterName, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("parameter_name", parameterName);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setSearchWord_Wildcard(String searchWord, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("searchWord", searchWord);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setUser_Wildcard(String user, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("user", user);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setUserAgent_Wildcard(String userAgent, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("userAgent", userAgent);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setUserInfoId_Wildcard(String userInfoId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("userInfoId", userInfoId);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setProtocolScheme_Wildcard(String protocolScheme, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("protocolScheme", protocolScheme);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setVirtualHost_Wildcard(String virtualHost, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("virtualHost", virtualHost);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setDocId_Wildcard(String docId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("docId", docId);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setTerm_Wildcard(String term, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("term", term);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setErrorName_Wildcard(String errorName, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("errorName", errorName);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setUserInfoId_Wildcard(String userInfoId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("userInfoId", userInfoId);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setUrlId_Wildcard(String urlId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("urlId", urlId);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setPassword_Wildcard(String password, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("password", password);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setTerm_Wildcard(String term, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("term", term);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

public void setUrl_Wildcard(String url, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("url", url);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

protected WildcardQueryBuilder regWildcardQ(String name, String wildcard) {
    checkEsInvalidQuery(name, wildcard);
    WildcardQueryBuilder wildcardQuery = QueryBuilders.wildcardQuery(name, wildcard);
    regQ(wildcardQuery);
    return wildcardQuery;
}
 

public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("name", name);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}
 

@Override
public void visit( Equal op ) throws NoIndexException {
    final String name = op.getProperty().getValue().toLowerCase();
    final Object value = op.getLiteral().getValue();

    //special case so we support our '*' char with wildcard, also should work for uuids
    if ( value instanceof String || value instanceof UUID ) {
        String stringValue = ((value instanceof String) ? (String)value : value.toString()).toLowerCase().trim();

        // or field is just a string that does need a prefix us a query
        if ( stringValue.contains( "*" ) ) {

            //Because of our legacy behavior, where we match CCCC*, we need to use the unanalyzed string to ensure that
            //we start
            final WildcardQueryBuilder wildcardQuery =
                    QueryBuilders.wildcardQuery( IndexingUtils.FIELD_STRING_NESTED_UNANALYZED, stringValue );
            queryBuilders.push( fieldNameTerm( name, wildcardQuery ) );
            filterBuilders.push( NoOpFilterBuilder.INSTANCE );
            return;
        }

        // Usergrid query parser allows single quotes to be escaped in values
        if ( stringValue.contains("\\'")) {
            stringValue = stringValue.replace("\\'", "'");
        }

        //it's an exact match, use a filter
        final TermFilterBuilder termFilter =
                FilterBuilders.termFilter( IndexingUtils.FIELD_STRING_NESTED_UNANALYZED, stringValue );

        queryBuilders.push( NoOpQueryBuilder.INSTANCE );
        filterBuilders.push( fieldNameTerm( name, termFilter ) );

        return;
    }

    // assume all other types need prefix

    final TermFilterBuilder termQuery =
            FilterBuilders.termFilter(getFieldNameForType(value), sanitize(value));

    filterBuilders.push( fieldNameTerm( name, termQuery ) );

    queryBuilders.push( NoOpQueryBuilder.INSTANCE );
}
 

public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
    WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
    if (opLambda != null) {
        opLambda.callback(builder);
    }
}