Package mil.nga.geopackage.features.index

Class FeatureIndexManager

  • public class FeatureIndexManager
extends Object
    Feature Index Manager to manage indexing of feature geometries within a GeoPackage using the Geometry Index Extension and the RTree extension
    Since:
    3.1.0
    Author:
    osbornb
    See Also:
    FeatureTableIndex

    • Constructor Detail

      • FeatureIndexManager

        public FeatureIndexManager​(GeoPackage geoPackage,
                           String featureTable)
        Constructor
        Parameters:
        geoPackage - GeoPackage
        featureTable - feature table

      • FeatureIndexManager

        public FeatureIndexManager​(GeoPackage geoPackage,
                           FeatureDao featureDao)
        Constructor
        Parameters:
        geoPackage - GeoPackage
        featureDao - feature DAO

      • FeatureIndexManager

        public FeatureIndexManager​(GeoPackage geoPackage,
                           String featureTable,
                           boolean geodesic)
        Constructor
        Parameters:
        geoPackage - GeoPackage
        featureTable - feature table
        geodesic - index using geodesic bounds
        Since:
        6.6.5

      • FeatureIndexManager

        public FeatureIndexManager​(GeoPackage geoPackage,
                           FeatureDao featureDao,
                           boolean geodesic)
        Constructor
        Parameters:
        geoPackage - GeoPackage
        featureDao - feature DAO
        geodesic - index using geodesic bounds
        Since:
        6.6.5

    • Method Detail

      • close

        public void close()
        Close the index connections

      • getFeatureDao

        public FeatureDao getFeatureDao()
        Get the feature DAO
        Returns:
        feature DAO

      • getFeatureTableIndex

        public FeatureTableIndex getFeatureTableIndex()
        Get the feature table index, used to index inside the GeoPackage as an extension
        Returns:
        feature table index

      • getRTreeIndexTableDao

        public RTreeIndexTableDao getRTreeIndexTableDao()
        Get the RTree Index Table DAO
        Returns:
        RTree index table DAO

      • getIndexLocationQueryOrder

        public Set<FeatureIndexType> getIndexLocationQueryOrder()
        Get the ordered set of ordered index query locations
        Returns:
        set of ordered index types

      • getIndexLocation

        public FeatureIndexType getIndexLocation()
        Get the index location
        Returns:
        index location or null if not set

      • isContinueOnError

        public boolean isContinueOnError()
        Is the continue on error flag enabled
        Returns:
        continue on error
        Since:
        3.4.0

      • setContinueOnError

        public void setContinueOnError​(boolean continueOnError)
        Set the continue on error flag
        Parameters:
        continueOnError - continue on error
        Since:
        3.4.0

      • isGeodesic

        public boolean isGeodesic()
        Geometries indexed using geodesic lines
        Returns:
        geodesic flag
        Since:
        6.6.5

      • setGeodesic

        public void setGeodesic​(boolean geodesic)
        Set the geodestic flag, true to index geodesic geometries
        Parameters:
        geodesic - index geodesic geometries flag
        Since:
        6.6.5

      • prioritizeQueryLocation

        public void prioritizeQueryLocation​(Collection<FeatureIndexType> types)
        Prioritize the query location order. All types are placed at the front of the query order in the order they are given. Omitting a location leaves it at it's current priority location.
        Parameters:
        types - feature index types

      • prioritizeQueryLocation

        public void prioritizeQueryLocation​(FeatureIndexType... types)
        Prioritize the query location order. All types are placed at the front of the query order in the order they are given. Omitting a location leaves it at it's current priority location.
        Parameters:
        types - feature index types

      • setIndexLocationOrder

        public void setIndexLocationOrder​(Collection<FeatureIndexType> types)
        Set the index location order, overriding all previously set types
        Parameters:
        types - feature index types

      • setIndexLocationOrder

        public void setIndexLocationOrder​(FeatureIndexType... types)
        Set the index location order, overriding all previously set types
        Parameters:
        types - feature index types

      • setIndexLocation

        public void setIndexLocation​(FeatureIndexType indexLocation)
        Set the index location
        Parameters:
        indexLocation - feature index type

      • setProgress

        public void setProgress​(GeoPackageProgress progress)
        Set the GeoPackage Progress
        Parameters:
        progress - GeoPackage progress

      • index

        public int index()
        Index the feature table if needed, using the set index location
        Returns:
        count

      • index

        public int index​(List<FeatureIndexType> types)
        Index the feature tables if needed for the index types
        Parameters:
        types - feature index types
        Returns:
        largest count of indexed features

      • index

        public int index​(FeatureIndexType type)
        Index the feature table if needed
        Parameters:
        type - index location type
        Returns:
        count

      • index

        public int index​(boolean force)
        Index the feature table, using the set index location
        Parameters:
        force - true to force re-indexing
        Returns:
        count

      • index

        public int index​(boolean force,
                 List<FeatureIndexType> types)
        Index the feature tables for the index types
        Parameters:
        force - true to force re-indexing
        types - feature index types
        Returns:
        largest count of indexed features

      • index

        public int index​(FeatureIndexType type,
                 boolean force)
        Index the feature table
        Parameters:
        type - index location type
        force - true to force re-indexing
        Returns:
        count

      • index

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

      • index

        public boolean index​(FeatureRow row,
                     List<FeatureIndexType> types)
        Index the feature row for the index types. This method assumes that indexing has been completed and maintained as the last indexed time is updated.
        Parameters:
        row - feature row to index
        types - feature index types
        Returns:
        true if indexed from any type

      • index

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

      • deleteIndex

        public boolean deleteIndex()
        Delete the feature index
        Returns:
        true if deleted

      • deleteAllIndexes

        public boolean deleteAllIndexes()
        Delete the feature index from all query order locations
        Returns:
        true if deleted

      • deleteIndex

        public boolean deleteIndex​(Collection<FeatureIndexType> types)
        Delete the feature index from the index types
        Parameters:
        types - feature index types
        Returns:
        true if deleted from any type

      • deleteIndex

        public boolean deleteIndex​(FeatureIndexType type)
        Delete the feature index
        Parameters:
        type - feature index type
        Returns:
        true if deleted

      • deleteIndex

        public boolean deleteIndex​(FeatureRow row)
        Delete the feature index for the feature row
        Parameters:
        row - feature row
        Returns:
        true if deleted

      • deleteIndex

        public boolean deleteIndex​(FeatureRow row,
                           List<FeatureIndexType> types)
        Delete the feature index for the feature row from the index types
        Parameters:
        row - feature row
        types - feature index types
        Returns:
        true if deleted from any type

      • deleteIndex

        public boolean deleteIndex​(FeatureIndexType type,
                           FeatureRow row)
        Delete the feature index for the feature row
        Parameters:
        type - feature index type
        row - feature row
        Returns:
        true if deleted

      • deleteIndex

        public boolean deleteIndex​(long geomId)
        Delete the feature index for the geometry id
        Parameters:
        geomId - geometry id
        Returns:
        true if deleted

      • deleteIndex

        public boolean deleteIndex​(long geomId,
                           List<FeatureIndexType> types)
        Delete the feature index for the geometry id from the index types
        Parameters:
        geomId - geometry id
        types - feature index types
        Returns:
        true if deleted from any type

      • deleteIndex

        public boolean deleteIndex​(FeatureIndexType type,
                           long geomId)
        Delete the feature index for the geometry id
        Parameters:
        type - feature index type
        geomId - geometry id
        Returns:
        true if deleted

      • retainIndex

        public boolean retainIndex​(FeatureIndexType type)
        Retain the feature index from the index types and delete the others
        Parameters:
        type - feature index type to retain
        Returns:
        true if deleted from any type

      • retainIndex

        public boolean retainIndex​(Collection<FeatureIndexType> types)
        Retain the feature index from the index types and delete the others
        Parameters:
        types - feature index types to retain
        Returns:
        true if deleted from any type

      • isIndexed

        public boolean isIndexed()
        Determine if the feature table is indexed
        Returns:
        true if indexed

      • isIndexed

        public boolean isIndexed​(FeatureIndexType type)
        Is the feature table indexed in the provided type location
        Parameters:
        type - index location type
        Returns:
        true if indexed

      • getIndexedTypes

        public List<FeatureIndexType> getIndexedTypes()
        Get the indexed types that are currently indexed
        Returns:
        indexed types

      • getLastIndexed

        public Date getLastIndexed()
        Get the date last indexed
        Returns:
        last indexed date or null

      • getLastIndexed

        public Date getLastIndexed​(FeatureIndexType type)
        Get the date last indexed
        Parameters:
        type - feature index type
        Returns:
        last indexed date or null

      • getLocation

        public FeatureIndexLocation getLocation()
        Get a feature index location to iterate over indexed types
        Returns:
        feature index location
        Since:
        3.4.0

      • getIndexedType

        public FeatureIndexType getIndexedType()
        Get the first ordered indexed type
        Returns:
        feature index type
        Since:
        3.4.0

      • getIdColumn

        public String getIdColumn()
        Get the feature table id column name, the default column ordering
        Returns:
        feature table id column name
        Since:
        6.2.0

      • query

        public FeatureIndexResults query()
        Query for all feature index results
        Returns:
        feature index results, close when done

      • query

        public FeatureIndexResults query​(boolean distinct)
        Query for all feature index results
        Parameters:
        distinct - distinct rows
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns)
        Query for all feature index results
        Parameters:
        columns - columns
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns)
        Query for all feature index results
        Parameters:
        distinct - distinct rows
        columns - columns
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count()
        Query for all feature index count
        Returns:
        count

      • countColumn

        public long countColumn​(String column)
        Query for all feature index count
        Parameters:
        column - count column name
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column)
        Query for all feature index count
        Parameters:
        distinct - distinct column values
        column - count column name
        Returns:
        count
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(Map<String,​Object> fieldValues)
        Query for feature index results
        Parameters:
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        3.4.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 Map<String,​Object> fieldValues)
        Query for feature index results
        Parameters:
        distinct - distinct rows
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 Map<String,​Object> fieldValues)
        Query for feature index results
        Parameters:
        columns - columns
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 Map<String,​Object> fieldValues)
        Query for feature index results
        Parameters:
        distinct - distinct rows
        columns - columns
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(Map<String,​Object> fieldValues)
        Query for feature index count
        Parameters:
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        3.4.0

      • count

        public long count​(String column,
                  Map<String,​Object> fieldValues)
        Query for feature index count
        Parameters:
        column - count column name
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  Map<String,​Object> fieldValues)
        Query for feature index count
        Parameters:
        distinct - distinct column values
        column - count column name
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String where)
        Query for feature index results
        Parameters:
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        3.4.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String where)
        Query for feature index results
        Parameters:
        distinct - distinct rows
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 String where)
        Query for feature index results
        Parameters:
        columns - columns
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 String where)
        Query for feature index results
        Parameters:
        distinct - distinct rows
        columns - columns
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(String where)
        Query for feature index count
        Parameters:
        where - where clause
        Returns:
        count
        Since:
        3.4.0

      • count

        public long count​(String column,
                  String where)
        Query for feature index count
        Parameters:
        column - count column name
        where - where clause
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  String where)
        Query for feature index count
        Parameters:
        distinct - distinct column values
        column - count column name
        where - where clause
        Returns:
        count
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String where,
                                 String[] whereArgs)
        Query for feature index results
        Parameters:
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        3.4.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results
        Parameters:
        distinct - distinct rows
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results
        Parameters:
        columns - columns
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results
        Parameters:
        distinct - distinct rows
        columns - columns
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(String where,
                  String[] whereArgs)
        Query for feature index count
        Parameters:
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        3.4.0

      • count

        public long count​(String column,
                  String where,
                  String[] whereArgs)
        Query for feature index count
        Parameters:
        column - count column name
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  String where,
                  String[] whereArgs)
        Query for feature index count
        Parameters:
        distinct - distinct column values
        column - count column name
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        4.0.0

      • getBoundingBox

        public BoundingBox getBoundingBox()
        Query for the feature index bounds
        Returns:
        bounding box

      • getBoundingBox

        public BoundingBox getBoundingBox​(Projection projection)
        Query for the feature index bounds and return in the provided projection
        Parameters:
        projection - desired projection
        Returns:
        bounding box

      • query

        public FeatureIndexResults query​(BoundingBox boundingBox)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        boundingBox - bounding box
        Returns:
        feature index results, close when done

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 BoundingBox boundingBox)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 BoundingBox boundingBox)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        columns - columns
        boundingBox - bounding box
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 BoundingBox boundingBox)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(BoundingBox boundingBox)
        Query for feature index count within the bounding box, projected correctly
        Parameters:
        boundingBox - bounding box
        Returns:
        count

      • count

        public long count​(String column,
                  BoundingBox boundingBox)
        Query for feature index count within the bounding box, projected correctly
        Parameters:
        column - count column name
        boundingBox - bounding box
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  BoundingBox boundingBox)
        Query for feature index count within the bounding box, projected correctly
        Parameters:
        distinct - distinct column values
        column - count column name
        boundingBox - bounding box
        Returns:
        count
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(BoundingBox boundingBox,
                                 Map<String,​Object> fieldValues)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        boundingBox - bounding box
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        3.4.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 BoundingBox boundingBox,
                                 Map<String,​Object> fieldValues)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 BoundingBox boundingBox,
                                 Map<String,​Object> fieldValues)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        columns - columns
        boundingBox - bounding box
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 BoundingBox boundingBox,
                                 Map<String,​Object> fieldValues)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(BoundingBox boundingBox,
                  Map<String,​Object> fieldValues)
        Query for feature index count within the bounding box, projected correctly
        Parameters:
        boundingBox - bounding box
        fieldValues - field values
        Returns:
        count
        Since:
        3.4.0

      • count

        public long count​(String column,
                  BoundingBox boundingBox,
                  Map<String,​Object> fieldValues)
        Query for feature index count within the bounding box, projected correctly
        Parameters:
        column - column name
        boundingBox - bounding box
        fieldValues - field values
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  BoundingBox boundingBox,
                  Map<String,​Object> fieldValues)
        Query for feature index count within the bounding box, projected correctly
        Parameters:
        distinct - distinct column values
        column - column name
        boundingBox - bounding box
        fieldValues - field values
        Returns:
        count
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(BoundingBox boundingBox,
                                 String where)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        boundingBox - bounding box
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        3.4.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 BoundingBox boundingBox,
                                 String where)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 BoundingBox boundingBox,
                                 String where)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        columns - columns
        boundingBox - bounding box
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 BoundingBox boundingBox,
                                 String where)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(BoundingBox boundingBox,
                  String where)
        Query for feature index count within the bounding box, projected correctly
        Parameters:
        boundingBox - bounding box
        where - where clause
        Returns:
        count
        Since:
        3.4.0

      • count

        public long count​(String column,
                  BoundingBox boundingBox,
                  String where)
        Query for feature index count within the bounding box, projected correctly
        Parameters:
        column - column name
        boundingBox - bounding box
        where - where clause
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  BoundingBox boundingBox,
                  String where)
        Query for feature index count within the bounding box, projected correctly
        Parameters:
        distinct - distinct column values
        column - column name
        boundingBox - bounding box
        where - where clause
        Returns:
        count
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(BoundingBox boundingBox,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        boundingBox - bounding box
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        3.4.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 BoundingBox boundingBox,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 BoundingBox boundingBox,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        columns - columns
        boundingBox - bounding box
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 BoundingBox boundingBox,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results within the bounding box, projected correctly
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(BoundingBox boundingBox,
                  String where,
                  String[] whereArgs)
        Query for feature index count within the bounding box, projected correctly
        Parameters:
        boundingBox - bounding box
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        3.4.0

      • count

        public long count​(String column,
                  BoundingBox boundingBox,
                  String where,
                  String[] whereArgs)
        Query for feature index count within the bounding box, projected correctly
        Parameters:
        column - count column value
        boundingBox - bounding box
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  BoundingBox boundingBox,
                  String where,
                  String[] whereArgs)
        Query for feature index count within the bounding box, projected correctly
        Parameters:
        distinct - distinct column values
        column - count column value
        boundingBox - bounding box
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(GeometryEnvelope envelope)
        Query for feature index results within the Geometry Envelope
        Parameters:
        envelope - geometry envelope
        Returns:
        feature index results, close when done

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 GeometryEnvelope envelope)
        Query for feature index results within the Geometry Envelope
        Parameters:
        distinct - distinct rows
        envelope - geometry envelope
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 GeometryEnvelope envelope)
        Query for feature index results within the Geometry Envelope
        Parameters:
        columns - columns
        envelope - geometry envelope
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 GeometryEnvelope envelope)
        Query for feature index results within the Geometry Envelope
        Parameters:
        distinct - distinct rows
        columns - columns
        envelope - geometry envelope
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(GeometryEnvelope envelope)
        Query for feature index count within the Geometry Envelope
        Parameters:
        envelope - geometry envelope
        Returns:
        count

      • count

        public long count​(String column,
                  GeometryEnvelope envelope)
        Query for feature index count within the Geometry Envelope
        Parameters:
        column - count column name
        envelope - geometry envelope
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  GeometryEnvelope envelope)
        Query for feature index count within the Geometry Envelope
        Parameters:
        distinct - distinct column values
        column - count column name
        envelope - geometry envelope
        Returns:
        count
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(GeometryEnvelope envelope,
                                 Map<String,​Object> fieldValues)
        Query for feature index results within the Geometry Envelope
        Parameters:
        envelope - geometry envelope
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        3.4.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 GeometryEnvelope envelope,
                                 Map<String,​Object> fieldValues)
        Query for feature index results within the Geometry Envelope
        Parameters:
        distinct - distinct rows
        envelope - geometry envelope
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 GeometryEnvelope envelope,
                                 Map<String,​Object> fieldValues)
        Query for feature index results within the Geometry Envelope
        Parameters:
        columns - columns
        envelope - geometry envelope
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 GeometryEnvelope envelope,
                                 Map<String,​Object> fieldValues)
        Query for feature index results within the Geometry Envelope
        Parameters:
        distinct - distinct rows
        columns - columns
        envelope - geometry envelope
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(GeometryEnvelope envelope,
                  Map<String,​Object> fieldValues)
        Query for feature index count within the Geometry Envelope
        Parameters:
        envelope - geometry envelope
        fieldValues - field values
        Returns:
        count
        Since:
        3.4.0

      • count

        public long count​(String column,
                  GeometryEnvelope envelope,
                  Map<String,​Object> fieldValues)
        Query for feature index count within the Geometry Envelope
        Parameters:
        column - count column name
        envelope - geometry envelope
        fieldValues - field values
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  GeometryEnvelope envelope,
                  Map<String,​Object> fieldValues)
        Query for feature index count within the Geometry Envelope
        Parameters:
        distinct - distinct column values
        column - count column name
        envelope - geometry envelope
        fieldValues - field values
        Returns:
        count
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(GeometryEnvelope envelope,
                                 String where)
        Query for feature index results within the Geometry Envelope
        Parameters:
        envelope - geometry envelope
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        3.4.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 GeometryEnvelope envelope,
                                 String where)
        Query for feature index results within the Geometry Envelope
        Parameters:
        distinct - distinct rows
        envelope - geometry envelope
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 GeometryEnvelope envelope,
                                 String where)
        Query for feature index results within the Geometry Envelope
        Parameters:
        columns - columns
        envelope - geometry envelope
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 GeometryEnvelope envelope,
                                 String where)
        Query for feature index results within the Geometry Envelope
        Parameters:
        distinct - distinct rows
        columns - columns
        envelope - geometry envelope
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(GeometryEnvelope envelope,
                  String where)
        Query for feature index count within the Geometry Envelope
        Parameters:
        envelope - geometry envelope
        where - where clause
        Returns:
        count
        Since:
        3.4.0

      • count

        public long count​(String column,
                  GeometryEnvelope envelope,
                  String where)
        Query for feature index count within the Geometry Envelope
        Parameters:
        column - count column name
        envelope - geometry envelope
        where - where clause
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  GeometryEnvelope envelope,
                  String where)
        Query for feature index count 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

      • query

        public FeatureIndexResults query​(GeometryEnvelope envelope,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results within the Geometry Envelope
        Parameters:
        envelope - geometry envelope
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        3.4.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 GeometryEnvelope envelope,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results within the Geometry Envelope
        Parameters:
        distinct - distinct rows
        envelope - geometry envelope
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 GeometryEnvelope envelope,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results within the Geometry Envelope
        Parameters:
        columns - columns
        envelope - geometry envelope
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 GeometryEnvelope envelope,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results within the Geometry Envelope
        Parameters:
        distinct - distinct rows
        columns - columns
        envelope - geometry envelope
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(GeometryEnvelope envelope,
                  String where,
                  String[] whereArgs)
        Query for feature index count within the Geometry Envelope
        Parameters:
        envelope - geometry envelope
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        3.4.0

      • count

        public long count​(String column,
                  GeometryEnvelope envelope,
                  String where,
                  String[] whereArgs)
        Query for feature index count within the Geometry Envelope
        Parameters:
        column - count column name
        envelope - geometry envelope
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  GeometryEnvelope envelope,
                  String where,
                  String[] whereArgs)
        Query for feature index count 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

      • query

        public FeatureIndexResults query​(BoundingBox boundingBox,
                                 Projection projection)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        boundingBox - bounding box
        projection - projection
        Returns:
        feature index results, close when done

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 BoundingBox boundingBox,
                                 Projection projection)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        projection - projection
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 BoundingBox boundingBox,
                                 Projection projection)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        columns - columns
        boundingBox - bounding box
        projection - projection
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 BoundingBox boundingBox,
                                 Projection projection)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        projection - projection
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(BoundingBox boundingBox,
                  Projection projection)
        Query for feature index count within the bounding box in the provided projection
        Parameters:
        boundingBox - bounding box
        projection - projection
        Returns:
        count

      • count

        public long count​(String column,
                  BoundingBox boundingBox,
                  Projection projection)
        Query for feature index count within the bounding box in the provided projection
        Parameters:
        column - count column name
        boundingBox - bounding box
        projection - projection
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  BoundingBox boundingBox,
                  Projection projection)
        Query for feature index count within the bounding box in the provided projection
        Parameters:
        distinct - distinct column values
        column - count column name
        boundingBox - bounding box
        projection - projection
        Returns:
        count
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(BoundingBox boundingBox,
                                 Projection projection,
                                 Map<String,​Object> fieldValues)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        boundingBox - bounding box
        projection - projection
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        3.4.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 BoundingBox boundingBox,
                                 Projection projection,
                                 Map<String,​Object> fieldValues)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        projection - projection
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 BoundingBox boundingBox,
                                 Projection projection,
                                 Map<String,​Object> fieldValues)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        columns - columns
        boundingBox - bounding box
        projection - projection
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 BoundingBox boundingBox,
                                 Projection projection,
                                 Map<String,​Object> fieldValues)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        projection - projection
        fieldValues - field values
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(BoundingBox boundingBox,
                  Projection projection,
                  Map<String,​Object> fieldValues)
        Query for feature index count within the bounding box in the provided projection
        Parameters:
        boundingBox - bounding box
        projection - projection
        fieldValues - field values
        Returns:
        count
        Since:
        3.4.0

      • count

        public long count​(String column,
                  BoundingBox boundingBox,
                  Projection projection,
                  Map<String,​Object> fieldValues)
        Query for feature index count within the bounding box in the provided projection
        Parameters:
        column - count column value
        boundingBox - bounding box
        projection - projection
        fieldValues - field values
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  BoundingBox boundingBox,
                  Projection projection,
                  Map<String,​Object> fieldValues)
        Query for feature index count within the bounding box in the provided projection
        Parameters:
        distinct - distinct column values
        column - count column value
        boundingBox - bounding box
        projection - projection
        fieldValues - field values
        Returns:
        count
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(BoundingBox boundingBox,
                                 Projection projection,
                                 String where)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        boundingBox - bounding box
        projection - projection
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        3.4.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 BoundingBox boundingBox,
                                 Projection projection,
                                 String where)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        projection - projection
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 BoundingBox boundingBox,
                                 Projection projection,
                                 String where)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        columns - columns
        boundingBox - bounding box
        projection - projection
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 BoundingBox boundingBox,
                                 Projection projection,
                                 String where)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        projection - projection
        where - where clause
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(BoundingBox boundingBox,
                  Projection projection,
                  String where)
        Query for feature index count within the bounding box in the provided projection
        Parameters:
        boundingBox - bounding box
        projection - projection
        where - where clause
        Returns:
        count
        Since:
        3.4.0

      • count

        public long count​(String column,
                  BoundingBox boundingBox,
                  Projection projection,
                  String where)
        Query for feature index count within the bounding box in the provided projection
        Parameters:
        column - count column name
        boundingBox - bounding box
        projection - projection
        where - where clause
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  BoundingBox boundingBox,
                  Projection projection,
                  String where)
        Query for feature index count within the bounding box in the provided projection
        Parameters:
        distinct - distinct column values
        column - count column name
        boundingBox - bounding box
        projection - projection
        where - where clause
        Returns:
        count
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(BoundingBox boundingBox,
                                 Projection projection,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        boundingBox - bounding box
        projection - projection
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        3.4.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 BoundingBox boundingBox,
                                 Projection projection,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        projection - projection
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • query

        public FeatureIndexResults query​(String[] columns,
                                 BoundingBox boundingBox,
                                 Projection projection,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        columns - columns
        boundingBox - bounding box
        projection - projection
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        3.5.0

      • query

        public FeatureIndexResults query​(boolean distinct,
                                 String[] columns,
                                 BoundingBox boundingBox,
                                 Projection projection,
                                 String where,
                                 String[] whereArgs)
        Query for feature index results within the bounding box in the provided projection
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        projection - projection
        where - where clause
        whereArgs - where arguments
        Returns:
        feature index results, close when done
        Since:
        4.0.0

      • count

        public long count​(BoundingBox boundingBox,
                  Projection projection,
                  String where,
                  String[] whereArgs)
        Query for feature index count within the bounding box in the provided projection
        Parameters:
        boundingBox - bounding box
        projection - projection
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        3.4.0

      • count

        public long count​(String column,
                  BoundingBox boundingBox,
                  Projection projection,
                  String where,
                  String[] whereArgs)
        Query for feature index count within the bounding box in the provided projection
        Parameters:
        column - count column name
        boundingBox - bounding box
        projection - projection
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        4.0.0

      • count

        public long count​(boolean distinct,
                  String column,
                  BoundingBox boundingBox,
                  Projection projection,
                  String where,
                  String[] whereArgs)
        Query for feature index count within the bounding box in the provided projection
        Parameters:
        distinct - distinct column values
        column - count column name
        boundingBox - bounding box
        projection - projection
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        4.0.0

      • isPaginated

        public static boolean isPaginated​(FeatureIndexResults results)
        Determine if the results are paginated
        Parameters:
        results - query results
        Returns:
        true if paginated
        Since:
        6.2.0

      • isPaginated

        public static boolean isPaginated​(FeatureIndexFeatureResults results)
        Determine if the results are paginated
        Parameters:
        results - query results
        Returns:
        true if paginated
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(int limit)
        Query for all feature index results ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(int limit,
                                         long offset)
        Query for all feature index results ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String orderBy,
                                         int limit)
        Query for all feature index results, starting at the offset and returning no more than the limit
        Parameters:
        orderBy - order by
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String orderBy,
                                         int limit,
                                         long offset)
        Query for all feature index results, starting at the offset and returning no more than the limit
        Parameters:
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         int limit)
        Query for all feature index results ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         int limit,
                                         long offset)
        Query for all feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String orderBy,
                                         int limit)
        Query for all feature index results, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        orderBy - order by
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for all feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         int limit)
        Query for all feature index results ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         int limit,
                                         long offset)
        Query for all feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         String orderBy,
                                         int limit)
        Query for all feature index results, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        orderBy - order by
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for all feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         int limit)
        Query for all feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         int limit,
                                         long offset)
        Query for all feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         String orderBy,
                                         int limit)
        Query for all feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for all feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        fieldValues - field values
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results, starting at the offset and returning no more than the limit
        Parameters:
        fieldValues - field values
        orderBy - order by
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(String where,
                                                int limit)
        Query for feature index results ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        where - where clause
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(String where,
                                                int limit,
                                                long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results, starting at the offset and returning no more than the limit
        Parameters:
        where - where clause
        orderBy - order by
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                String where,
                                                int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(String[] columns,
                                                String where,
                                                int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(String[] columns,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                String[] columns,
                                                String where,
                                                int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                String[] columns,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit
        Parameters:
        boundingBox - bounding box
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit
        Parameters:
        boundingBox - bounding box
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit
        Parameters:
        boundingBox - bounding box
        orderBy - order by
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        boundingBox - bounding box
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit
        Parameters:
        boundingBox - bounding box
        fieldValues - field values
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(BoundingBox boundingBox,
                                                String where,
                                                int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit
        Parameters:
        boundingBox - bounding box
        where - where clause
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(BoundingBox boundingBox,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                BoundingBox boundingBox,
                                                String where,
                                                int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                BoundingBox boundingBox,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(String[] columns,
                                                BoundingBox boundingBox,
                                                String where,
                                                int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(String[] columns,
                                                BoundingBox boundingBox,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                String[] columns,
                                                BoundingBox boundingBox,
                                                String where,
                                                int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                String[] columns,
                                                BoundingBox boundingBox,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results within the bounding box, projected correctly, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         int limit)
        Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit
        Parameters:
        envelope - geometry envelope
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit
        Parameters:
        envelope - geometry envelope
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         int limit)
        Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        envelope - geometry envelope
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the Geometry Envelope, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         int limit)
        Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        envelope - geometry envelope
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the Geometry Envelope, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         int limit)
        Query for feature index results ordered by id within the Geometry Envelope, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the Geometry Envelope, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit
        Parameters:
        envelope - geometry envelope
        fieldValues - field values
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the Geometry Envelope, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results ordered by id within the Geometry Envelope, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id within the Geometry Envelope, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(GeometryEnvelope envelope,
                                                String where,
                                                int limit)
        Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit
        Parameters:
        envelope - geometry envelope
        where - where clause
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(GeometryEnvelope envelope,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results ordered by id within the Geometry Envelope, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                GeometryEnvelope envelope,
                                                String where,
                                                int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                GeometryEnvelope envelope,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(String[] columns,
                                                GeometryEnvelope envelope,
                                                String where,
                                                int limit)
        Query for feature index results ordered by id within the Geometry Envelope, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(String[] columns,
                                                GeometryEnvelope envelope,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results ordered by id within the Geometry Envelope, 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                String[] columns,
                                                GeometryEnvelope envelope,
                                                String where,
                                                int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                String[] columns,
                                                GeometryEnvelope envelope,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         Map<String,​Object> fieldValues,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(BoundingBox boundingBox,
                                                Projection projection,
                                                String where,
                                                int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(BoundingBox boundingBox,
                                                Projection projection,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                BoundingBox boundingBox,
                                                Projection projection,
                                                String where,
                                                int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                BoundingBox boundingBox,
                                                Projection projection,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(String[] columns,
                                                BoundingBox boundingBox,
                                                Projection projection,
                                                String where,
                                                int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(String[] columns,
                                                BoundingBox boundingBox,
                                                Projection projection,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                String[] columns,
                                                BoundingBox boundingBox,
                                                Projection projection,
                                                String where,
                                                int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunkIdOrder

        public FeatureIndexResults queryForChunkIdOrder​(boolean distinct,
                                                String[] columns,
                                                BoundingBox boundingBox,
                                                Projection projection,
                                                String where,
                                                int limit,
                                                long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         int limit)
        Query for feature index results ordered by id 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
        limit - chunk limit
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         int limit,
                                         long offset)
        Query for feature index results ordered by id 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
        limit - chunk limit
        offset - chunk query offset
        Returns:
        feature index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0

      • queryForChunk

        public FeatureIndexResults queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String where,
                                         String[] whereArgs,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for feature index results 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 index results, close when done
        Since:
        6.2.0