Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.factual.driver;
  
  import java.util.List;
  
Represents a top level Factual query. Knows how to represent the query as URL encoded key value pairs, ready for the query string in a GET request. (See toUrlQuery())

Author(s):
aaron
 
 public class Query {
   private String fullTextSearch;
   private String[] selectFields;
   private long limit;
   private long offset;
   private boolean includeRowCount;
   private Circle circle;

  
Holds all row filters for this Query. Implicit top-level AND.
 
   private final List<FilterrowFilters = Lists.newArrayList();

  
Holds all results sorts for this Query. Example contents: "$distance:desc","name:asc","locality:asc"
 
   private final List<Stringsorts = Lists.newArrayList();


  
Sets a full text search query. Factual will use this value to perform a full text search against various attributes of the underlying table, such as entity name, address, etc.

Parameters:
term the text for which to perform a full text search.
Returns:
this Query
 
   public Query search(String term) {
     this. = term;
     return this;
   }

  
Sets the maximum amount of records to return from this Query.

Parameters:
limit the maximum amount of records to return from this Query.
Returns:
this Query
 
   public Query limit(long limit) {
     this. = limit;
     return this;
   }

  
Sets the fields to select. This is optional; default behaviour is generally to select all fields in the schema.

Parameters:
fields the fields to select.
Returns:
this Query
 
   public Query only(String... fields) {
     this. = fields;
     return this;
   }

  

Returns:
array of select fields set by only(), null if none.
 
   public String[] getSelectFields() {
     return ;
   }

  
Sets this Query to sort field in ascending order.

Parameters:
field the field to sort in ascending order.
Returns:
this Query
 
   public Query sortAsc(String field) {
     .add(field + ":asc");
     return this;
   }

  
Sets this Query to sort field in descending order.

Parameters:
field the field to sort in descending order.
Returns:
this Query
  public Query sortDesc(String field) {
    .add(field + ":desc");
    return this;
  }

  
Sets how many records in to start getting results (i.e., the page offset) for this Query.

Parameters:
offset the page offset for this Query.
Returns:
this Query
  public Query offset(long offset) {
    this. = offset;
    return this;
  }

  
The response will include a count of the total number of rows in the table that conform to the request based on included filters. This will increase the time required to return a response. The default behavior is to NOT include a row count.

Returns:
this Query, marked to return total row count when run.
  public Query includeRowCount() {
    return includeRowCount(true);
  }

  
When true, the response will include a count of the total number of rows in the table that conform to the request based on included filters. Requesting the row count will increase the time required to return a response. The default behavior is to NOT include a row count.

Parameters:
includeRowCount true if you want the results to include a count of the total number of rows in the table that conform to the request based on included filters.
Returns:
this Query.
  public Query includeRowCount(boolean includeRowCount) {
    this. = includeRowCount;
    return this;
  }

  
Begins construction of a new row filter.

Deprecated:
use field(java.lang.String)
Parameters:
field the name of the field on which to filter.
Returns:
A partial representation of the new row filter.
  public QueryBuilder criteria(String field) {
    return new QueryBuilder(thisfield);
  }

  
Begins construction of a new row filter for this Query.

Parameters:
field the name of the field on which to filter.
Returns:
A partial representation of the new row filter.
  public QueryBuilder field(String field) {
    return new QueryBuilder(thisfield);
  }
  public Query near(String textint meters) {
    Coord coord = new DataScienceToolkit().streetToCoord(text);
    if(coord != null) {
      return within(new Circle(coordmeters));
    } else {
      throw new FactualApiException("Could not locate place based on text: '" + text + "'");
    }
  }

  
Adds a filter so that results can only be (roughly) within the specified geographic circle.

Parameters:
circle The circle within which to bound the results.
Returns:
this Query.
  public Query within(Circle circle) {
    this. = circle;
    return this;
  }

  
Used to nest AND'ed predicates.
  public Query and(Query... queries) {
    return popFilters("$and"queries);
  }

  
Used to nest OR'ed predicates.
  public Query or(Query... queries) {
    return popFilters("$or"queries);
  }

  
Adds filter to this Query.
  public void add(Filter filter) {
    .add(filter);
  }

  
Builds and returns the query string to represent this Query when talking to Factual's API. Provides proper URL encoding and escaping.

Example output:

 filters=%7B%22%24and%22%3A%5B%7B%22region%22%3A%7B%22%24in%22%3A%22MA%2CVT%2CNH%22%7D%7D%2C%7B%22%24or%22%3A%5B%7B%22first_name%22%3A%7B%22%24eq%22%3A%22Chun%22%7D%7D%2C%7B%22last_name%22%3A%7B%22%24eq%22%3A%22Kok%22%7D%7D%5D%7D%5D%7D
 

(After decoding, the above example would be used by the server as:)

 filters={"$and":[{"region":{"$in":"MA,VT,NH"}},{"$or":[{"first_name":{"$eq":"Chun"}},{"last_name":{"$eq":"Kok"}}]}]}
 

Returns:
the query string to represent this Query when talking to Factual's API.
  protected String toUrlQuery() {
    return Joiner.on("&").skipNulls().join(
        urlPair("select"fieldsJsonOrNull()),
        urlPair("q"),
        urlPair("sort"sortsJsonOrNull()),
        ( > 0 ? urlPair("limit") : null),
        ( > 0 ? urlPair("offset") : null),
        ( ? urlPair("include_count"true) : null),
        urlPair("filters"rowFiltersJsonOrNull()),
        urlPair("geo"geoBoundsJsonOrNull()));
  }
  public String toString() {
    try {
      return URLDecoder.decode(toUrlQuery(), "UTF-8");
    } catch (UnsupportedEncodingException e) {
      throw new RuntimeException(e);
    }
  }
  private String urlPair(String nameObject val) {
    if(val != null) {
      try {
        return name + "=" + (val instanceof String ? URLEncoder.encode(val.toString(), "UTF-8") : val);
      } catch (UnsupportedEncodingException e) {
        throw new RuntimeException(e);
      }
    } else {
      return null;
    }
  }
  private String fieldsJsonOrNull() {
    if( != null) {
      return Joiner.on(",").join();
    } else {
      return null;
    }
  }
  private String sortsJsonOrNull() {
    if(!.isEmpty()) {
      return Joiner.on(",").join();
    } else {
      return null;
    }
  }
  private String geoBoundsJsonOrNull() {
    if( != null) {
      return .toJsonStr();
    } else {
      return null;
    }
  }
  private String rowFiltersJsonOrNull() {
    if(.isEmpty()) {
      return null;
    } else if(.size() == 1) {
      return .get(0).toJsonStr();
    } else {
      return new FilterGroup().toJsonStr();
    }
  }

  
Pops the newest Filter from each of queries, grouping each popped Filter into one new FilterGroup. Adds that new FilterGroup as the newest Filter in this Query.

The FilterGroup's logic will be determined by op.

  private Query popFilters(String opQuery... queries) {
    FilterGroup group = new FilterGroup().op(op);
    for(Query q : queries) {
      group.add(pop(q.rowFilters));
    }
    add(group);
    return this;
  }
  private Filter pop(List<Filterlist) {
    return list.remove(list.size()-1);
  }
New to GrepCode? Check out our FAQ X