Class FeatureTableIndex


public class FeatureTableIndex extends FeatureTableCoreIndex
Feature Table Index NGA Extension implementation. This extension is used to index Geometries within a feature table by their minimum bounding box for bounding box queries. This extension is required to provide an index implementation when a SQLite version is used before SpatialLite support (Android).

http://ngageoint.github.io/GeoPackage/docs/extensions/geometry-index.html

Since:
1.1.0
  • Constructor Details

    • FeatureTableIndex

      public FeatureTableIndex(GeoPackage geoPackage, FeatureDao featureDao)
      Constructor
      Parameters:
      geoPackage - GeoPackage
      featureDao - feature dao
    • FeatureTableIndex

      public FeatureTableIndex(GeoPackage geoPackage, FeatureDao featureDao, boolean geodesic)
      Constructor
      Parameters:
      geoPackage - GeoPackage
      featureDao - feature dao
      geodesic - index using geodesic bounds
      Since:
      6.7.4
  • Method Details

    • getProjection

      public Projection getProjection()
      Specified by:
      getProjection in class FeatureTableCoreIndex
    • getPkColumnName

      public String getPkColumnName()
      Get the primary key column name
      Returns:
      primary key column name
      Since:
      6.2.0
    • close

      public void close()
      Close the table index
    • index

      public boolean index(FeatureRow row)
      Index the feature row. This method assumes that indexing has been completed and maintained as the last indexed time is updated.
      Parameters:
      row - feature row
      Returns:
      true if indexed
    • indexTable

      protected int indexTable(TableIndex tableIndex)
      Specified by:
      indexTable in class FeatureTableCoreIndex
    • deleteIndex

      public int deleteIndex(FeatureRow row)
      Delete the index for the feature row
      Parameters:
      row - feature row
      Returns:
      deleted rows, should be 0 or 1
    • getFeatureRow

      public FeatureRow getFeatureRow(GeometryIndex geometryIndex)
      Get the feature row for the Geometry Index
      Parameters:
      geometryIndex - geometry index
      Returns:
      feature row
    • queryFeatures

      public FeatureCursor queryFeatures()
      Query for all Features
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct)
      Query for all Features
      Parameters:
      distinct - distinct rows
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns)
      Query for all Features
      Parameters:
      columns - columns
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns)
      Query for all Features
      Parameters:
      distinct - distinct rows
      columns - columns
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures()
      Count features
      Returns:
      count
      Since:
      4.0.0
    • countColumnFeatures

      public int countColumnFeatures(String column)
      Count features
      Parameters:
      column - count column name
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column)
      Count features
      Parameters:
      distinct - distinct column values
      column - count column name
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(Map<String,Object> fieldValues)
      Query for features
      Parameters:
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, Map<String,Object> fieldValues)
      Query for features
      Parameters:
      distinct - distinct rows
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, Map<String,Object> fieldValues)
      Query for features
      Parameters:
      columns - columns
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, Map<String,Object> fieldValues)
      Query for features
      Parameters:
      distinct - distinct rows
      columns - columns
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(Map<String,Object> fieldValues)
      Count features
      Parameters:
      fieldValues - field values
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, Map<String,Object> fieldValues)
      Count features
      Parameters:
      column - count column name
      fieldValues - field values
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, Map<String,Object> fieldValues)
      Count features
      Parameters:
      distinct - distinct column values
      column - count column name
      fieldValues - field values
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String where)
      Query for features
      Parameters:
      where - where clause
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String where)
      Query for features
      Parameters:
      distinct - distinct rows
      where - where clause
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, String where)
      Query for features
      Parameters:
      columns - columns
      where - where clause
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, String where)
      Query for features
      Parameters:
      distinct - distinct rows
      columns - columns
      where - where clause
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(String where)
      Count features
      Parameters:
      where - where clause
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, String where)
      Count features
      Parameters:
      column - count column name
      where - where clause
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, String where)
      Count features
      Parameters:
      column - count column name
      distinct - distinct column values
      where - where clause
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String where, String[] whereArgs)
      Query for features
      Parameters:
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String where, String[] whereArgs)
      Query for features
      Parameters:
      distinct - distinct rows
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, String where, String[] whereArgs)
      Query for features
      Parameters:
      columns - columns
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, String where, String[] whereArgs)
      Query for features
      Parameters:
      distinct - distinct rows
      columns - columns
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(String where, String[] whereArgs)
      Count features
      Parameters:
      where - where clause
      whereArgs - where arguments
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, String where, String[] whereArgs)
      Count features
      Parameters:
      column - count column name
      where - where clause
      whereArgs - where arguments
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, String where, String[] whereArgs)
      Count features
      Parameters:
      distinct - distinct column values
      column - count column name
      where - where clause
      whereArgs - where arguments
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(BoundingBox boundingBox)
      Query for Features within the bounding box, projected correctly
      Parameters:
      boundingBox - bounding box
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, BoundingBox boundingBox)
      Query for Features within the bounding box, projected correctly
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, BoundingBox boundingBox)
      Query for Features within the bounding box, projected correctly
      Parameters:
      columns - columns
      boundingBox - bounding box
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, BoundingBox boundingBox)
      Query for Features within the bounding box, projected correctly
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(BoundingBox boundingBox)
      Count the Features within the bounding box, projected correctly
      Parameters:
      boundingBox - bounding box
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, BoundingBox boundingBox)
      Count the Features within the bounding box, projected correctly
      Parameters:
      column - count column name
      boundingBox - bounding box
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, BoundingBox boundingBox)
      Count the Features within the bounding box, projected correctly
      Parameters:
      distinct - distinct column values
      column - count column name
      boundingBox - bounding box
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(BoundingBox boundingBox, Map<String,Object> fieldValues)
      Query for Features within the bounding box, projected correctly
      Parameters:
      boundingBox - bounding box
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, BoundingBox boundingBox, Map<String,Object> fieldValues)
      Query for Features within the bounding box, projected correctly
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, BoundingBox boundingBox, Map<String,Object> fieldValues)
      Query for Features within the bounding box, projected correctly
      Parameters:
      columns - columns
      boundingBox - bounding box
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, BoundingBox boundingBox, Map<String,Object> fieldValues)
      Query for Features within the bounding box, projected correctly
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(BoundingBox boundingBox, Map<String,Object> fieldValues)
      Count the Features within the bounding box, projected correctly
      Parameters:
      boundingBox - bounding box
      fieldValues - field values
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, BoundingBox boundingBox, Map<String,Object> fieldValues)
      Count the Features within the bounding box, projected correctly
      Parameters:
      column - count column
      boundingBox - bounding box
      fieldValues - field values
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, BoundingBox boundingBox, Map<String,Object> fieldValues)
      Count the Features within the bounding box, projected correctly
      Parameters:
      distinct - distinct column values
      column - count column
      boundingBox - bounding box
      fieldValues - field values
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(BoundingBox boundingBox, String where)
      Query for Features within the bounding box, projected correctly
      Parameters:
      boundingBox - bounding box
      where - where clause
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, BoundingBox boundingBox, String where)
      Query for Features within the bounding box, projected correctly
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      where - where clause
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, BoundingBox boundingBox, String where)
      Query for Features within the bounding box, projected correctly
      Parameters:
      columns - columns
      boundingBox - bounding box
      where - where clause
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, BoundingBox boundingBox, String where)
      Query for Features within the bounding box, projected correctly
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      where - where clause
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(BoundingBox boundingBox, String where)
      Count the Features within the bounding box, projected correctly
      Parameters:
      boundingBox - bounding box
      where - where clause
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, BoundingBox boundingBox, String where)
      Count the Features within the bounding box, projected correctly
      Parameters:
      column - count column name
      boundingBox - bounding box
      where - where clause
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, BoundingBox boundingBox, String where)
      Count the Features within the bounding box, projected correctly
      Parameters:
      distinct - distinct column values
      column - count column name
      boundingBox - bounding box
      where - where clause
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(BoundingBox boundingBox, String where, String[] whereArgs)
      Query for Features within the bounding box, projected correctly
      Parameters:
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, BoundingBox boundingBox, String where, String[] whereArgs)
      Query for Features within the bounding box, projected correctly
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, BoundingBox boundingBox, String where, String[] whereArgs)
      Query for Features within the bounding box, projected correctly
      Parameters:
      columns - columns
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, BoundingBox boundingBox, String where, String[] whereArgs)
      Query for Features within the bounding box, projected correctly
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(BoundingBox boundingBox, String where, String[] whereArgs)
      Count the Features within the bounding box, projected correctly
      Parameters:
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, BoundingBox boundingBox, String where, String[] whereArgs)
      Count the Features within the bounding box, projected correctly
      Parameters:
      column - count column name
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, BoundingBox boundingBox, String where, String[] whereArgs)
      Count the Features within the bounding box, projected correctly
      Parameters:
      distinct - distinct column values
      column - count column name
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(BoundingBox boundingBox, Projection projection)
      Query for Features within the bounding box in the provided projection
      Parameters:
      boundingBox - bounding box
      projection - projection of the provided bounding box
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, BoundingBox boundingBox, Projection projection)
      Query for Features within the bounding box in the provided projection
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection of the provided bounding box
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, BoundingBox boundingBox, Projection projection)
      Query for Features within the bounding box in the provided projection
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection of the provided bounding box
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection)
      Query for Features within the bounding box in the provided projection
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection of the provided bounding box
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(BoundingBox boundingBox, Projection projection)
      Count the Features within the bounding box in the provided projection
      Parameters:
      boundingBox - bounding box
      projection - projection of the provided bounding box
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, BoundingBox boundingBox, Projection projection)
      Count the Features within the bounding box in the provided projection
      Parameters:
      column - count column name
      boundingBox - bounding box
      projection - projection of the provided bounding box
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, BoundingBox boundingBox, Projection projection)
      Count the Features within the bounding box in the provided projection
      Parameters:
      distinct - distinct column values
      column - count column name
      boundingBox - bounding box
      projection - projection of the provided bounding box
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues)
      Query for Features within the bounding box in the provided projection
      Parameters:
      boundingBox - bounding box
      projection - projection of the provided bounding box
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues)
      Query for Features within the bounding box in the provided projection
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection of the provided bounding box
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues)
      Query for Features within the bounding box in the provided projection
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection of the provided bounding box
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues)
      Query for Features within the bounding box in the provided projection
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection of the provided bounding box
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues)
      Count the Features within the bounding box in the provided projection
      Parameters:
      boundingBox - bounding box
      projection - projection of the provided bounding box
      fieldValues - field values
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues)
      Count the Features within the bounding box in the provided projection
      Parameters:
      column - count column name
      boundingBox - bounding box
      projection - projection of the provided bounding box
      fieldValues - field values
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues)
      Count the Features within the bounding box in the provided projection
      Parameters:
      distinct - distinct column values
      column - count column name
      boundingBox - bounding box
      projection - projection of the provided bounding box
      fieldValues - field values
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(BoundingBox boundingBox, Projection projection, String where)
      Query for Features within the bounding box in the provided projection
      Parameters:
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, BoundingBox boundingBox, Projection projection, String where)
      Query for Features within the bounding box in the provided projection
      Parameters:
      distinct - distinct row
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, BoundingBox boundingBox, Projection projection, String where)
      Query for Features within the bounding box in the provided projection
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, String where)
      Query for Features within the bounding box in the provided projection
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(BoundingBox boundingBox, Projection projection, String where)
      Count the Features within the bounding box in the provided projection
      Parameters:
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, BoundingBox boundingBox, Projection projection, String where)
      Count the Features within the bounding box in the provided projection
      Parameters:
      column - count column name
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, BoundingBox boundingBox, Projection projection, String where)
      Count the Features within the bounding box in the provided projection
      Parameters:
      distinct - distinct column values
      column - count column name
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(BoundingBox boundingBox, Projection projection, String where, String[] whereArgs)
      Query for Features within the bounding box in the provided projection
      Parameters:
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs)
      Query for Features within the bounding box in the provided projection
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs)
      Query for Features within the bounding box in the provided projection
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs)
      Query for Features within the bounding box in the provided projection
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(BoundingBox boundingBox, Projection projection, String where, String[] whereArgs)
      Count the Features within the bounding box in the provided projection
      Parameters:
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs)
      Count the Features within the bounding box in the provided projection
      Parameters:
      column - count column name
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs)
      Count the Features within the bounding box in the provided projection
      Parameters:
      distinct - distinct column values
      column - count column name
      boundingBox - bounding box
      projection - projection of the provided bounding box
      where - where clause
      whereArgs - where arguments
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(GeometryEnvelope envelope)
      Query for Features within the Geometry Envelope
      Parameters:
      envelope - geometry envelope
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, GeometryEnvelope envelope)
      Query for Features within the Geometry Envelope
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, GeometryEnvelope envelope)
      Query for Features within the Geometry Envelope
      Parameters:
      columns - columns
      envelope - geometry envelope
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, GeometryEnvelope envelope)
      Query for Features within the Geometry Envelope
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(GeometryEnvelope envelope)
      Count the Features within the Geometry Envelope
      Parameters:
      envelope - geometry envelope
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, GeometryEnvelope envelope)
      Count the Features within the Geometry Envelope
      Parameters:
      column - count column name
      envelope - geometry envelope
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, GeometryEnvelope envelope)
      Count the Features within the Geometry Envelope
      Parameters:
      distinct - distinct column values
      column - count column name
      envelope - geometry envelope
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(GeometryEnvelope envelope, Map<String,Object> fieldValues)
      Query for Features within the Geometry Envelope
      Parameters:
      envelope - geometry envelope
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, GeometryEnvelope envelope, Map<String,Object> fieldValues)
      Query for Features within the Geometry Envelope
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, GeometryEnvelope envelope, Map<String,Object> fieldValues)
      Query for Features within the Geometry Envelope
      Parameters:
      columns - columns
      envelope - geometry envelope
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, GeometryEnvelope envelope, Map<String,Object> fieldValues)
      Query for Features within the Geometry Envelope
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      fieldValues - field values
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(GeometryEnvelope envelope, Map<String,Object> fieldValues)
      Count the Features within the Geometry Envelope
      Parameters:
      envelope - geometry envelope
      fieldValues - field values
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, GeometryEnvelope envelope, Map<String,Object> fieldValues)
      Count the Features within the Geometry Envelope
      Parameters:
      column - count column names
      envelope - geometry envelope
      fieldValues - field values
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, GeometryEnvelope envelope, Map<String,Object> fieldValues)
      Count the Features within the Geometry Envelope
      Parameters:
      distinct - distinct column values
      column - count column names
      envelope - geometry envelope
      fieldValues - field values
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(GeometryEnvelope envelope, String where)
      Query for Features within the Geometry Envelope
      Parameters:
      envelope - geometry envelope
      where - where clause
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, GeometryEnvelope envelope, String where)
      Query for Features within the Geometry Envelope
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      where - where clause
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, GeometryEnvelope envelope, String where)
      Query for Features within the Geometry Envelope
      Parameters:
      columns - columns
      envelope - geometry envelope
      where - where clause
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, GeometryEnvelope envelope, String where)
      Query for Features within the Geometry Envelope
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      where - where clause
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(GeometryEnvelope envelope, String where)
      Count the Features within the Geometry Envelope
      Parameters:
      envelope - geometry envelope
      where - where clause
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, GeometryEnvelope envelope, String where)
      Count the Features within the Geometry Envelope
      Parameters:
      column - count column name
      envelope - geometry envelope
      where - where clause
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, GeometryEnvelope envelope, String where)
      Count the Features within the Geometry Envelope
      Parameters:
      distinct - distinct column values
      column - count column name
      envelope - geometry envelope
      where - where clause
      Returns:
      count
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(GeometryEnvelope envelope, String where, String[] whereArgs)
      Query for Features within the Geometry Envelope
      Parameters:
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      3.4.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, GeometryEnvelope envelope, String where, String[] whereArgs)
      Query for Features within the Geometry Envelope
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      4.0.0
    • queryFeatures

      public FeatureCursor queryFeatures(String[] columns, GeometryEnvelope envelope, String where, String[] whereArgs)
      Query for Features within the Geometry Envelope
      Parameters:
      columns - columns
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      3.5.0
    • queryFeatures

      public FeatureCursor queryFeatures(boolean distinct, String[] columns, GeometryEnvelope envelope, String where, String[] whereArgs)
      Query for Features within the Geometry Envelope
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      Returns:
      feature cursor
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(GeometryEnvelope envelope, String where, String[] whereArgs)
      Count the Features within the Geometry Envelope
      Parameters:
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      Returns:
      count
      Since:
      3.4.0
    • countFeatures

      public int countFeatures(String column, GeometryEnvelope envelope, String where, String[] whereArgs)
      Count the Features within the Geometry Envelope
      Parameters:
      column - count column name
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      Returns:
      count
      Since:
      4.0.0
    • countFeatures

      public int countFeatures(boolean distinct, String column, GeometryEnvelope envelope, String where, String[] whereArgs)
      Count the Features within the Geometry Envelope
      Parameters:
      distinct - distinct column values
      column - count column name
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      Returns:
      count
      Since:
      4.0.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(int limit)
      Query for all features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(int limit, long offset)
      Query for all features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String orderBy, int limit)
      Query for all features, starting at the offset and returning no more than the limit
      Parameters:
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String orderBy, int limit, long offset)
      Query for all features, starting at the offset and returning no more than the limit
      Parameters:
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, int limit)
      Query for all features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, int limit, long offset)
      Query for all features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String orderBy, int limit)
      Query for all features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String orderBy, int limit, long offset)
      Query for all features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, int limit)
      Query for all features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, int limit, long offset)
      Query for all features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, String orderBy, int limit)
      Query for all features, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, String orderBy, int limit, long offset)
      Query for all features, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, int limit)
      Query for all features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, int limit, long offset)
      Query for all features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, String orderBy, int limit)
      Query for all features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, String orderBy, int limit, long offset)
      Query for all features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(Map<String,Object> fieldValues, int limit)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(Map<String,Object> fieldValues, int limit, long offset)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, Map<String,Object> fieldValues, int limit)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, Map<String,Object> fieldValues, int limit, long offset)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, Map<String,Object> fieldValues, int limit)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, Map<String,Object> fieldValues, int limit, long offset)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, Map<String,Object> fieldValues, int limit)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, Map<String,Object> fieldValues, int limit, long offset)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(String where, int limit)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(String where, int limit, long offset)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String where, String orderBy, int limit)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String where, String orderBy, int limit, long offset)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, String where, int limit)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, String where, int limit, long offset)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String where, String orderBy, int limit)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String where, String orderBy, int limit, long offset)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(String[] columns, String where, int limit)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(String[] columns, String where, int limit, long offset)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, String where, String orderBy, int limit)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, String where, String orderBy, int limit, long offset)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, String[] columns, String where, int limit)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, String[] columns, String where, int limit, long offset)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, String where, String orderBy, int limit)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, String where, String orderBy, int limit, long offset)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String where, String[] whereArgs, int limit)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String where, String[] whereArgs, int limit, long offset)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String where, String[] whereArgs, String orderBy, int limit)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String where, String[] whereArgs, int limit)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String where, String[] whereArgs, int limit, long offset)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String where, String[] whereArgs, String orderBy, int limit)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, String where, String[] whereArgs, int limit)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, String where, String[] whereArgs, int limit, long offset)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, String where, String[] whereArgs, String orderBy, int limit)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, String where, String[] whereArgs, int limit)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, String where, String[] whereArgs, int limit, long offset)
      Query for features ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, String where, String[] whereArgs, String orderBy, int limit)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Map<String,Object> fieldValues, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Map<String,Object> fieldValues, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Map<String,Object> fieldValues, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Map<String,Object> fieldValues, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Map<String,Object> fieldValues, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Map<String,Object> fieldValues, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Map<String,Object> fieldValues, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Map<String,Object> fieldValues, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(BoundingBox boundingBox, String where, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(BoundingBox boundingBox, String where, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, String where, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, String where, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, BoundingBox boundingBox, String where, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, BoundingBox boundingBox, String where, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, String where, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, String where, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(String[] columns, BoundingBox boundingBox, String where, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(String[] columns, BoundingBox boundingBox, String where, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, String where, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, String where, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, String[] columns, BoundingBox boundingBox, String where, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, String[] columns, BoundingBox boundingBox, String where, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, String where, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, String where, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, String where, String[] whereArgs, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, String where, String[] whereArgs, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, String where, String[] whereArgs, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, String where, String[] whereArgs, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, String where, String[] whereArgs, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, String where, String[] whereArgs, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, String where, String[] whereArgs, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, String where, String[] whereArgs, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, String where, String[] whereArgs, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, String where, String[] whereArgs, int limit)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, String where, String[] whereArgs, int limit, long offset)
      Query for features within the bounding box ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, String where, String[] whereArgs, String orderBy, int limit)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features within the bounding box, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(BoundingBox boundingBox, Projection projection, String where, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(BoundingBox boundingBox, Projection projection, String where, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, String where, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, String where, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, BoundingBox boundingBox, Projection projection, String where, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, BoundingBox boundingBox, Projection projection, String where, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, String where, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, String where, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(String[] columns, BoundingBox boundingBox, Projection projection, String where, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(String[] columns, BoundingBox boundingBox, Projection projection, String where, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, String where, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, String where, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, String where, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, String where, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, String where, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, String where, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, int limit)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, int limit, long offset)
      Query for features within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, String orderBy, int limit)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, BoundingBox boundingBox, Projection projection, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features within the bounding box in the provided projection, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      boundingBox - bounding box
      projection - projection
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, Map<String,Object> fieldValues, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, Map<String,Object> fieldValues, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, Map<String,Object> fieldValues, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, Map<String,Object> fieldValues, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, Map<String,Object> fieldValues, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, Map<String,Object> fieldValues, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, Map<String,Object> fieldValues, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      fieldValues - field values
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, Map<String,Object> fieldValues, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      fieldValues - field values
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, Map<String,Object> fieldValues, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, Map<String,Object> fieldValues, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      fieldValues - field values
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(GeometryEnvelope envelope, String where, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(GeometryEnvelope envelope, String where, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, String where, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, String where, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, GeometryEnvelope envelope, String where, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, GeometryEnvelope envelope, String where, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, String where, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, String where, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(String[] columns, GeometryEnvelope envelope, String where, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(String[] columns, GeometryEnvelope envelope, String where, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, String where, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, String where, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, String[] columns, GeometryEnvelope envelope, String where, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      where - where clause
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunkIdOrder

      public FeatureCursor queryFeaturesForChunkIdOrder(boolean distinct, String[] columns, GeometryEnvelope envelope, String where, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      where - where clause
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, String where, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      where - where clause
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, String where, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      where - where clause
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, String where, String[] whereArgs, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, String where, String[] whereArgs, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, String where, String[] whereArgs, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(GeometryEnvelope envelope, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, String where, String[] whereArgs, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, String where, String[] whereArgs, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, String where, String[] whereArgs, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, GeometryEnvelope envelope, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, String where, String[] whereArgs, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, String where, String[] whereArgs, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, String where, String[] whereArgs, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(String[] columns, GeometryEnvelope envelope, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      columns - columns
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, String where, String[] whereArgs, int limit)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, String where, String[] whereArgs, int limit, long offset)
      Query for features within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, String where, String[] whereArgs, String orderBy, int limit)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      Returns:
      feature cursor
      Since:
      6.2.0
    • queryFeaturesForChunk

      public FeatureCursor queryFeaturesForChunk(boolean distinct, String[] columns, GeometryEnvelope envelope, String where, String[] whereArgs, String orderBy, int limit, long offset)
      Query for features within the geometry envelope, starting at the offset and returning no more than the limit
      Parameters:
      distinct - distinct rows
      columns - columns
      envelope - geometry envelope
      where - where clause
      whereArgs - where arguments
      orderBy - order by
      limit - chunk limit
      offset - chunk query offset
      Returns:
      feature cursor
      Since:
      6.2.0