Package mil.nga.geopackage.extension.rtree

Class RTreeIndexTableDao

  • public class RTreeIndexTableDao
extends UserCustomDao
    RTree Index Table DAO for reading geometry index ranges
    Since:
    3.1.0
    Author:
    osbornb

    • Field Detail

      • tolerance

        protected double tolerance
        Query range tolerance

    • Method Detail

      • setProgress

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

      • getTolerance

        public double getTolerance()
        Get the query range tolerance
        Returns:
        query range tolerance

      • setTolerance

        public void setTolerance​(double tolerance)
        Set the query range tolerance
        Parameters:
        tolerance - query range tolerance

      • has

        public boolean has()
        Determine if this feature table has the RTree extension
        Returns:
        true if has extension

      • create

        public Extensions create()
        Create the RTree extension for the feature table
        Returns:
        extension

      • delete

        public void delete()
        Delete the RTree extension for the feature table

      • getRTreeIndexExtension

        public RTreeIndexExtension getRTreeIndexExtension()
        Get the RTree index extension
        Returns:
        RTree index extension

      • getFeatureDao

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

      • getRow

        public RTreeIndexTableRow getRow​(UserCustomResultSet resultSet)
        Get the RTree Index Table row from the current result set location
        Parameters:
        resultSet - result set
        Returns:
        RTree Index Table row

      • getRow

        public RTreeIndexTableRow getRow​(UserCustomRow row)
        Get the RTree Index Table row from the user custom row
        Parameters:
        row - custom row
        Returns:
        RTree Index Table row

      • getFeatureRow

        public FeatureRow getFeatureRow​(RTreeIndexTableRow row)
        Get the feature row from the RTree Index Table row
        Parameters:
        row - RTree Index Table row
        Returns:
        feature row

      • getFeatureRow

        public FeatureRow getFeatureRow​(UserCustomResultSet resultSet)
        Get the feature row from the RTree Index Table row
        Parameters:
        resultSet - result set
        Returns:
        feature row

      • getFeatureRow

        public FeatureRow getFeatureRow​(UserCustomRow row)
        Get the feature row from the user custom row
        Parameters:
        row - custom row
        Returns:
        feature row

      • queryFeatures

        public FeatureResultSet queryFeatures()
        Query for all features
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct)
        Query for all features
        Parameters:
        distinct - distinct rows
        Returns:
        feature results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns)
        Query for all features
        Parameters:
        columns - columns
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns)
        Query for all features
        Parameters:
        distinct - distinct rows
        columns - columns
        Returns:
        feature results
        Since:
        4.0.0

      • countFeatures

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

      • countColumnFeatures

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

      • countFeatures

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

      • queryFeatures

        public FeatureResultSet queryFeatures​(Map<String,​Object> fieldValues)
        Query for features
        Parameters:
        fieldValues - field values
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

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

      • queryFeatures

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

      • queryFeatures

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

      • countFeatures

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

      • countFeatures

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

      • countFeatures

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

      • queryFeatures

        public FeatureResultSet queryFeatures​(String where)
        Query for features
        Parameters:
        where - where clause
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String where)
        Query for features
        Parameters:
        distinct - distinct rows
        where - where clause
        Returns:
        feature results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      String where)
        Query for features
        Parameters:
        columns - columns
        where - where clause
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      String where)
        Query for features
        Parameters:
        distinct - distinct rows
        columns - columns
        where - where clause
        Returns:
        feature results
        Since:
        4.0.0

      • countFeatures

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

      • countFeatures

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

      • countFeatures

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

      • queryFeatures

        public FeatureResultSet queryFeatures​(String where,
                                      String[] whereArgs)
        Query for features
        Parameters:
        where - where clause
        whereArgs - where arguments
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

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

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      String where,
                                      String[] whereArgs)
        Query for features
        Parameters:
        columns - columns
        where - where clause
        whereArgs - where arguments
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      String where,
                                      String[] whereArgs)
        Query for features
        Parameters:
        distinct - distinct rows
        columns - columns
        where - where clause
        whereArgs - where arguments
        Returns:
        feature results
        Since:
        4.0.0

      • countFeatures

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

      • countFeatures

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

      • countFeatures

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

      • query

        public UserCustomResultSet query​(BoundingBox boundingBox)
        Query for rows within the bounding box
        Parameters:
        boundingBox - bounding box
        Returns:
        results

      • query

        public UserCustomResultSet query​(boolean distinct,
                                 BoundingBox boundingBox)
        Query for rows within the bounding box
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        Returns:
        results
        Since:
        4.0.0

      • query

        public UserCustomResultSet query​(String[] columns,
                                 BoundingBox boundingBox)
        Query for rows within the bounding box
        Parameters:
        columns - columns
        boundingBox - bounding box
        Returns:
        results
        Since:
        3.5.0

      • query

        public UserCustomResultSet query​(boolean distinct,
                                 String[] columns,
                                 BoundingBox boundingBox)
        Query for rows within the bounding box
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        Returns:
        results
        Since:
        4.0.0

      • count

        public int count​(BoundingBox boundingBox)
        Count the rows within the bounding box
        Parameters:
        boundingBox - bounding box
        Returns:
        count

      • count

        public int count​(String column,
                 BoundingBox boundingBox)
        Count the rows within the bounding box
        Parameters:
        column - count column name
        boundingBox - bounding box
        Returns:
        count
        Since:
        4.0.0

      • count

        public int count​(boolean distinct,
                 String column,
                 BoundingBox boundingBox)
        Count the rows within the bounding box
        Parameters:
        distinct - distinct column values
        column - count column name
        boundingBox - bounding box
        Returns:
        count
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(BoundingBox boundingBox)
        Query for features within the bounding box
        Parameters:
        boundingBox - bounding box
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      BoundingBox boundingBox)
        Query for features within the bounding box
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        Returns:
        feature results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      BoundingBox boundingBox)
        Query for features within the bounding box
        Parameters:
        columns - columns
        boundingBox - bounding box
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      BoundingBox boundingBox)
        Query for features within the bounding box
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        Returns:
        feature results
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(BoundingBox boundingBox)
        Count the features within the bounding box
        Parameters:
        boundingBox - bounding box
        Returns:
        count
        Since:
        3.4.0

      • countFeatures

        public int countFeatures​(String column,
                         BoundingBox boundingBox)
        Count the features within the bounding box
        Parameters:
        column - count column values
        boundingBox - bounding box
        Returns:
        count
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(boolean distinct,
                         String column,
                         BoundingBox boundingBox)
        Count the features within the bounding box
        Parameters:
        distinct - distinct column values
        column - count column values
        boundingBox - bounding box
        Returns:
        count
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(BoundingBox boundingBox,
                                      Map<String,​Object> fieldValues)
        Query for features within the bounding box
        Parameters:
        boundingBox - bounding box
        fieldValues - field values
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      BoundingBox boundingBox,
                                      Map<String,​Object> fieldValues)
        Query for features within the bounding box
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        fieldValues - field values
        Returns:
        feature results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      BoundingBox boundingBox,
                                      Map<String,​Object> fieldValues)
        Query for features within the bounding box
        Parameters:
        columns - columns
        boundingBox - bounding box
        fieldValues - field values
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      BoundingBox boundingBox,
                                      Map<String,​Object> fieldValues)
        Query for features within the bounding box
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        fieldValues - field values
        Returns:
        feature results
        Since:
        4.0.0

      • countFeatures

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

      • countFeatures

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

      • countFeatures

        public int countFeatures​(boolean distinct,
                         String column,
                         BoundingBox boundingBox,
                         Map<String,​Object> fieldValues)
        Count the features within the bounding box
        Parameters:
        distinct - distinct column values
        column - count column name
        boundingBox - bounding box
        fieldValues - field values
        Returns:
        count
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(BoundingBox boundingBox,
                                      String where)
        Query for features within the bounding box
        Parameters:
        boundingBox - bounding box
        where - where clause
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      BoundingBox boundingBox,
                                      String where)
        Query for features within the bounding box
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        where - where clause
        Returns:
        feature results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      BoundingBox boundingBox,
                                      String where)
        Query for features within the bounding box
        Parameters:
        columns - columns
        boundingBox - bounding box
        where - where clause
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      BoundingBox boundingBox,
                                      String where)
        Query for features within the bounding box
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        where - where clause
        Returns:
        feature results
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(BoundingBox boundingBox,
                         String where)
        Count the features within the bounding box
        Parameters:
        boundingBox - bounding box
        where - where clause
        Returns:
        count
        Since:
        3.4.0

      • countFeatures

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

      • countFeatures

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

      • queryFeatures

        public FeatureResultSet queryFeatures​(BoundingBox boundingBox,
                                      String where,
                                      String[] whereArgs)
        Query for features within the bounding box
        Parameters:
        boundingBox - bounding box
        where - where clause
        whereArgs - where arguments
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      BoundingBox boundingBox,
                                      String where,
                                      String[] whereArgs)
        Query for features within the bounding box
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        where - where clause
        whereArgs - where arguments
        Returns:
        feature results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      BoundingBox boundingBox,
                                      String where,
                                      String[] whereArgs)
        Query for features within the bounding box
        Parameters:
        columns - columns
        boundingBox - bounding box
        where - where clause
        whereArgs - where arguments
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      BoundingBox boundingBox,
                                      String where,
                                      String[] whereArgs)
        Query for features within the bounding box
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        where - where clause
        whereArgs - where arguments
        Returns:
        feature results
        Since:
        4.0.0

      • countFeatures

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

      • countFeatures

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

      • countFeatures

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

      • query

        public UserCustomResultSet query​(BoundingBox boundingBox,
                                 Projection projection)
        Query for rows within the bounding box in the provided projection
        Parameters:
        boundingBox - bounding box
        projection - projection
        Returns:
        results

      • query

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

      • query

        public UserCustomResultSet query​(String[] columns,
                                 BoundingBox boundingBox,
                                 Projection projection)
        Query for rows within the bounding box in the provided projection
        Parameters:
        columns - columns
        boundingBox - bounding box
        projection - projection
        Returns:
        results
        Since:
        3.5.0

      • query

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

      • count

        public int count​(BoundingBox boundingBox,
                 Projection projection)
        Count the rows within the bounding box in the provided projection
        Parameters:
        boundingBox - bounding box
        projection - projection
        Returns:
        count

      • count

        public int count​(String column,
                 BoundingBox boundingBox,
                 Projection projection)
        Count the rows 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 int count​(boolean distinct,
                 String column,
                 BoundingBox boundingBox,
                 Projection projection)
        Count the rows 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

      • queryFeatures

        public FeatureResultSet queryFeatures​(BoundingBox boundingBox,
                                      Projection projection)
        Query for features within the bounding box in the provided projection
        Parameters:
        boundingBox - bounding box
        projection - projection
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      BoundingBox boundingBox,
                                      Projection projection)
        Query for features within the bounding box in the provided projection
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        projection - projection
        Returns:
        feature results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      BoundingBox boundingBox,
                                      Projection projection)
        Query for features within the bounding box in the provided projection
        Parameters:
        columns - columns
        boundingBox - bounding box
        projection - projection
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      BoundingBox boundingBox,
                                      Projection projection)
        Query for features within the bounding box in the provided projection
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        projection - projection
        Returns:
        feature results
        Since:
        4.0.0

      • countFeatures

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

      • countFeatures

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

      • countFeatures

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

      • queryFeatures

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

      • queryFeatures

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

      • queryFeatures

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

      • queryFeatures

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

      • countFeatures

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

      • countFeatures

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

      • countFeatures

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

      • queryFeatures

        public FeatureResultSet queryFeatures​(BoundingBox boundingBox,
                                      Projection projection,
                                      String where)
        Query for features within the bounding box in the provided projection
        Parameters:
        boundingBox - bounding box
        projection - projection
        where - where clause
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      BoundingBox boundingBox,
                                      Projection projection,
                                      String where)
        Query for features within the bounding box in the provided projection
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        projection - projection
        where - where clause
        Returns:
        feature results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      BoundingBox boundingBox,
                                      Projection projection,
                                      String where)
        Query for features within the bounding box in the provided projection
        Parameters:
        columns - columns
        boundingBox - bounding box
        projection - projection
        where - where clause
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      BoundingBox boundingBox,
                                      Projection projection,
                                      String where)
        Query for features within the bounding box in the provided projection
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        projection - projection
        where - where clause
        Returns:
        feature results
        Since:
        4.0.0

      • countFeatures

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

      • countFeatures

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

      • countFeatures

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

      • queryFeatures

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

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      BoundingBox boundingBox,
                                      Projection projection,
                                      String where,
                                      String[] whereArgs)
        Query for features within the bounding box in the provided projection
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        projection - projection
        where - where clause
        whereArgs - where arguments
        Returns:
        feature results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      BoundingBox boundingBox,
                                      Projection projection,
                                      String where,
                                      String[] whereArgs)
        Query for features within the bounding box in the provided projection
        Parameters:
        columns - columns
        boundingBox - bounding box
        projection - projection
        where - where clause
        whereArgs - where arguments
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

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

      • countFeatures

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

      • countFeatures

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

      • countFeatures

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

      • query

        public UserCustomResultSet query​(GeometryEnvelope envelope)
        Query for rows within the geometry envelope
        Parameters:
        envelope - geometry envelope
        Returns:
        results

      • query

        public UserCustomResultSet query​(boolean distinct,
                                 GeometryEnvelope envelope)
        Query for rows within the geometry envelope
        Parameters:
        distinct - distinct rows
        envelope - geometry envelope
        Returns:
        results
        Since:
        4.0.0

      • query

        public UserCustomResultSet query​(String[] columns,
                                 GeometryEnvelope envelope)
        Query for rows within the geometry envelope
        Parameters:
        columns - columns
        envelope - geometry envelope
        Returns:
        results
        Since:
        3.5.0

      • query

        public UserCustomResultSet query​(boolean distinct,
                                 String[] columns,
                                 GeometryEnvelope envelope)
        Query for rows within the geometry envelope
        Parameters:
        distinct - distinct rows
        columns - columns
        envelope - geometry envelope
        Returns:
        results
        Since:
        4.0.0

      • count

        public int count​(GeometryEnvelope envelope)
        Count the rows within the geometry envelope
        Parameters:
        envelope - geometry envelope
        Returns:
        count

      • count

        public int count​(String column,
                 GeometryEnvelope envelope)
        Count the rows within the geometry envelope
        Parameters:
        column - count column name
        envelope - geometry envelope
        Returns:
        count
        Since:
        4.0.0

      • count

        public int count​(boolean distinct,
                 String column,
                 GeometryEnvelope envelope)
        Count the rows within the geometry envelope
        Parameters:
        distinct - distinct column values
        column - count column name
        envelope - geometry envelope
        Returns:
        count
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(GeometryEnvelope envelope)
        Query for features within the geometry envelope
        Parameters:
        envelope - geometry envelope
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      GeometryEnvelope envelope)
        Query for features within the geometry envelope
        Parameters:
        distinct - distinct rows
        envelope - geometry envelope
        Returns:
        feature results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      GeometryEnvelope envelope)
        Query for features within the geometry envelope
        Parameters:
        columns - columns
        envelope - geometry envelope
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      GeometryEnvelope envelope)
        Query for features within the geometry envelope
        Parameters:
        distinct - distinct rows
        columns - columns
        envelope - geometry envelope
        Returns:
        feature results
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(GeometryEnvelope envelope)
        Count the features within the geometry envelope
        Parameters:
        envelope - geometry envelope
        Returns:
        count
        Since:
        3.4.0

      • countFeatures

        public int countFeatures​(String column,
                         GeometryEnvelope envelope)
        Count the features within the geometry envelope
        Parameters:
        column - count column name
        envelope - geometry envelope
        Returns:
        count
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(boolean distinct,
                         String column,
                         GeometryEnvelope envelope)
        Count the features within the geometry envelope
        Parameters:
        distinct - distinct column values
        column - count column name
        envelope - geometry envelope
        Returns:
        count
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(GeometryEnvelope envelope,
                                      Map<String,​Object> fieldValues)
        Query for features within the geometry envelope
        Parameters:
        envelope - geometry envelope
        fieldValues - field values
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      GeometryEnvelope envelope,
                                      Map<String,​Object> fieldValues)
        Query for features within the geometry envelope
        Parameters:
        distinct - distinct rows
        envelope - geometry envelope
        fieldValues - field values
        Returns:
        feature results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      GeometryEnvelope envelope,
                                      Map<String,​Object> fieldValues)
        Query for features within the geometry envelope
        Parameters:
        columns - columns
        envelope - geometry envelope
        fieldValues - field values
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      GeometryEnvelope envelope,
                                      Map<String,​Object> fieldValues)
        Query for features within the geometry envelope
        Parameters:
        distinct - distinct rows
        columns - columns
        envelope - geometry envelope
        fieldValues - field values
        Returns:
        feature results
        Since:
        4.0.0

      • countFeatures

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

      • countFeatures

        public int countFeatures​(String column,
                         GeometryEnvelope envelope,
                         Map<String,​Object> fieldValues)
        Count the features within the geometry envelope
        Parameters:
        column - count column name
        envelope - geometry envelope
        fieldValues - field values
        Returns:
        count
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(boolean distinct,
                         String column,
                         GeometryEnvelope envelope,
                         Map<String,​Object> fieldValues)
        Count the features within the geometry envelope
        Parameters:
        distinct - distinct column values
        column - count column name
        envelope - geometry envelope
        fieldValues - field values
        Returns:
        count
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(GeometryEnvelope envelope,
                                      String where)
        Query for features within the geometry envelope
        Parameters:
        envelope - geometry envelope
        where - where clause
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      GeometryEnvelope envelope,
                                      String where)
        Query for features within the geometry envelope
        Parameters:
        distinct - distinct rows
        envelope - geometry envelope
        where - where clause
        Returns:
        feature results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      GeometryEnvelope envelope,
                                      String where)
        Query for features within the geometry envelope
        Parameters:
        columns - columns
        envelope - geometry envelope
        where - where clause
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      GeometryEnvelope envelope,
                                      String where)
        Query for features within the geometry envelope
        Parameters:
        distinct - distinct rows
        columns - columns
        envelope - geometry envelope
        where - where clause
        Returns:
        feature results
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(GeometryEnvelope envelope,
                         String where)
        Count the features within the geometry envelope
        Parameters:
        envelope - geometry envelope
        where - where clause
        Returns:
        count
        Since:
        3.4.0

      • countFeatures

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

      • countFeatures

        public int countFeatures​(boolean distinct,
                         String column,
                         GeometryEnvelope envelope,
                         String where)
        Count the features within the geometry envelope
        Parameters:
        distinct - distinct column values
        column - count column name
        envelope - geometry envelope
        where - where clause
        Returns:
        count
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(GeometryEnvelope envelope,
                                      String where,
                                      String[] whereArgs)
        Query for features within the geometry envelope
        Parameters:
        envelope - geometry envelope
        where - where clause
        whereArgs - where arguments
        Returns:
        feature results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      GeometryEnvelope envelope,
                                      String where,
                                      String[] whereArgs)
        Query for features within the geometry envelope
        Parameters:
        distinct - distinct rows
        envelope - geometry envelope
        where - where clause
        whereArgs - where arguments
        Returns:
        feature results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      GeometryEnvelope envelope,
                                      String where,
                                      String[] whereArgs)
        Query for features within the geometry envelope
        Parameters:
        columns - columns
        envelope - geometry envelope
        where - where clause
        whereArgs - where arguments
        Returns:
        feature results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      GeometryEnvelope envelope,
                                      String where,
                                      String[] whereArgs)
        Query for features within the geometry envelope
        Parameters:
        distinct - distinct rows
        columns - columns
        envelope - geometry envelope
        where - where clause
        whereArgs - where arguments
        Returns:
        feature results
        Since:
        4.0.0

      • countFeatures

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

      • countFeatures

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

      • countFeatures

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

      • query

        public UserCustomResultSet query​(double minX,
                                 double minY,
                                 double maxX,
                                 double maxY)
        Query for rows within the bounds
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        results

      • query

        public UserCustomResultSet query​(boolean distinct,
                                 double minX,
                                 double minY,
                                 double maxX,
                                 double maxY)
        Query for rows within the bounds
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        results
        Since:
        4.0.0

      • query

        public UserCustomResultSet query​(String[] columns,
                                 double minX,
                                 double minY,
                                 double maxX,
                                 double maxY)
        Query for rows within the bounds
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        results
        Since:
        3.5.0

      • query

        public UserCustomResultSet query​(boolean distinct,
                                 String[] columns,
                                 double minX,
                                 double minY,
                                 double maxX,
                                 double maxY)
        Query for rows within the bounds
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        results
        Since:
        4.0.0

      • count

        public int count​(double minX,
                 double minY,
                 double maxX,
                 double maxY)
        Count the rows within the bounds
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        count

      • count

        public int count​(String column,
                 double minX,
                 double minY,
                 double maxX,
                 double maxY)
        Count the rows within the bounds
        Parameters:
        column - count column name
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        count
        Since:
        4.0.0

      • count

        public int count​(boolean distinct,
                 String column,
                 double minX,
                 double minY,
                 double maxX,
                 double maxY)
        Count the rows within the bounds
        Parameters:
        distinct - distinct column values
        column - count column name
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        count
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(double minX,
                                      double minY,
                                      double maxX,
                                      double maxY)
        Query for features within the bounds
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      double minX,
                                      double minY,
                                      double maxX,
                                      double maxY)
        Query for features within the bounds
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      double minX,
                                      double minY,
                                      double maxX,
                                      double maxY)
        Query for features within the bounds
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      double minX,
                                      double minY,
                                      double maxX,
                                      double maxY)
        Query for features within the bounds
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        results
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(double minX,
                         double minY,
                         double maxX,
                         double maxY)
        Count the features within the bounds
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        count
        Since:
        3.4.0

      • countFeatures

        public int countFeatures​(String column,
                         double minX,
                         double minY,
                         double maxX,
                         double maxY)
        Count the features within the bounds
        Parameters:
        column - count column name
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        count
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(boolean distinct,
                         String column,
                         double minX,
                         double minY,
                         double maxX,
                         double maxY)
        Count the features within the bounds
        Parameters:
        distinct - distinct column values
        column - count column name
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        Returns:
        count
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(double minX,
                                      double minY,
                                      double maxX,
                                      double maxY,
                                      Map<String,​Object> fieldValues)
        Query for features within the bounds
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        Returns:
        results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      double minX,
                                      double minY,
                                      double maxX,
                                      double maxY,
                                      Map<String,​Object> fieldValues)
        Query for features within the bounds
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        Returns:
        results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      double minX,
                                      double minY,
                                      double maxX,
                                      double maxY,
                                      Map<String,​Object> fieldValues)
        Query for features within the bounds
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        Returns:
        results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      double minX,
                                      double minY,
                                      double maxX,
                                      double maxY,
                                      Map<String,​Object> fieldValues)
        Query for features within the bounds
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        Returns:
        results
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(double minX,
                         double minY,
                         double maxX,
                         double maxY,
                         Map<String,​Object> fieldValues)
        Count the features within the bounds
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        Returns:
        count
        Since:
        3.4.0

      • countFeatures

        public int countFeatures​(String column,
                         double minX,
                         double minY,
                         double maxX,
                         double maxY,
                         Map<String,​Object> fieldValues)
        Count the features within the bounds
        Parameters:
        column - count column name
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        Returns:
        count
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(boolean distinct,
                         String column,
                         double minX,
                         double minY,
                         double maxX,
                         double maxY,
                         Map<String,​Object> fieldValues)
        Count the features within the bounds
        Parameters:
        distinct - distinct column values
        column - count column name
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        Returns:
        count
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(double minX,
                                      double minY,
                                      double maxX,
                                      double maxY,
                                      String where)
        Query for features within the bounds
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        Returns:
        results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      double minX,
                                      double minY,
                                      double maxX,
                                      double maxY,
                                      String where)
        Query for features within the bounds
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        Returns:
        results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      double minX,
                                      double minY,
                                      double maxX,
                                      double maxY,
                                      String where)
        Query for features within the bounds
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        Returns:
        results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      double minX,
                                      double minY,
                                      double maxX,
                                      double maxY,
                                      String where)
        Query for features within the bounds
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        Returns:
        results
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(double minX,
                         double minY,
                         double maxX,
                         double maxY,
                         String where)
        Count the features within the bounds
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        Returns:
        count
        Since:
        3.4.0

      • countFeatures

        public int countFeatures​(String column,
                         double minX,
                         double minY,
                         double maxX,
                         double maxY,
                         String where)
        Count the features within the bounds
        Parameters:
        column - count column name
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        Returns:
        count
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(boolean distinct,
                         String column,
                         double minX,
                         double minY,
                         double maxX,
                         double maxY,
                         String where)
        Count the features within the bounds
        Parameters:
        distinct - distinct column values
        column - count column name
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        Returns:
        count
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(double minX,
                                      double minY,
                                      double maxX,
                                      double maxY,
                                      String where,
                                      String[] whereArgs)
        Query for features within the bounds
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        Returns:
        results
        Since:
        3.4.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      double minX,
                                      double minY,
                                      double maxX,
                                      double maxY,
                                      String where,
                                      String[] whereArgs)
        Query for features within the bounds
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        Returns:
        results
        Since:
        4.0.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(String[] columns,
                                      double minX,
                                      double minY,
                                      double maxX,
                                      double maxY,
                                      String where,
                                      String[] whereArgs)
        Query for features within the bounds
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        Returns:
        results
        Since:
        3.5.0

      • queryFeatures

        public FeatureResultSet queryFeatures​(boolean distinct,
                                      String[] columns,
                                      double minX,
                                      double minY,
                                      double maxX,
                                      double maxY,
                                      String where,
                                      String[] whereArgs)
        Query for features within the bounds
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        Returns:
        results
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(double minX,
                         double minY,
                         double maxX,
                         double maxY,
                         String where,
                         String[] whereArgs)
        Count the features within the bounds
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        3.4.0

      • countFeatures

        public int countFeatures​(String column,
                         double minX,
                         double minY,
                         double maxX,
                         double maxY,
                         String where,
                         String[] whereArgs)
        Count the features within the bounds
        Parameters:
        column - count column name
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        4.0.0

      • countFeatures

        public int countFeatures​(boolean distinct,
                         String column,
                         double minX,
                         double minY,
                         double maxX,
                         double maxY,
                         String where,
                         String[] whereArgs)
        Count the features within the bounds
        Parameters:
        distinct - distinct column values
        column - count column name
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        Returns:
        count
        Since:
        4.0.0

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryForChunk

        public UserCustomResultSet queryForChunk​(BoundingBox boundingBox,
                                         int limit)
        Query for rows within the bounding box ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        boundingBox - bounding box
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(BoundingBox boundingBox,
                                         int limit,
                                         long offset)
        Query for rows within the bounding box ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        boundingBox - bounding box
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(BoundingBox boundingBox,
                                         String orderBy,
                                         int limit)
        Query for rows within the bounding box, starting at the offset and returning no more than the limit
        Parameters:
        boundingBox - bounding box
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(BoundingBox boundingBox,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for rows within the bounding box, starting at the offset and returning no more than the limit
        Parameters:
        boundingBox - bounding box
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

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

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         int limit,
                                         long offset)
        Query for rows within the bounding box ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         String orderBy,
                                         int limit)
        Query for rows within the bounding box, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for rows within the bounding box, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         int limit)
        Query for rows within the bounding box ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        boundingBox - bounding box
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         int limit,
                                         long offset)
        Query for rows within the bounding box ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        boundingBox - bounding box
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         String orderBy,
                                         int limit)
        Query for rows within the bounding box, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        boundingBox - bounding box
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for rows within the bounding box, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        boundingBox - bounding box
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         int limit)
        Query for rows within the bounding box ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

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

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         String[] columns,
                                         BoundingBox boundingBox,
                                         String orderBy,
                                         int limit)
        Query for rows within the bounding box, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        boundingBox - bounding box
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryForChunk

        public UserCustomResultSet queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         int limit)
        Query for rows within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        boundingBox - bounding box
        projection - projection
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         int limit,
                                         long offset)
        Query for rows within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        boundingBox - bounding box
        projection - projection
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         String orderBy,
                                         int limit)
        Query for rows 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:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(BoundingBox boundingBox,
                                         Projection projection,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for rows 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:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         int limit)
        Query for rows within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        boundingBox - bounding box
        projection - projection
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

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

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String orderBy,
                                         int limit)
        Query for rows 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:
        results
        Since:
        6.2.0

      • queryForChunk

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

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         int limit)
        Query for rows within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        boundingBox - bounding box
        projection - projection
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         int limit,
                                         long offset)
        Query for rows within the bounding box in the provided projection ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        boundingBox - bounding box
        projection - projection
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         BoundingBox boundingBox,
                                         Projection projection,
                                         String orderBy,
                                         int limit)
        Query for rows 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:
        results
        Since:
        6.2.0

      • queryForChunk

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

      • queryForChunk

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

      • queryForChunk

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

      • queryForChunk

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

      • queryForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryForChunk

        public UserCustomResultSet queryForChunk​(GeometryEnvelope envelope,
                                         int limit)
        Query for rows within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        envelope - geometry envelope
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(GeometryEnvelope envelope,
                                         int limit,
                                         long offset)
        Query for rows within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        envelope - geometry envelope
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit)
        Query for rows 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:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for rows 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:
        results
        Since:
        6.2.0

      • queryForChunk

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

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         int limit,
                                         long offset)
        Query for rows within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        envelope - geometry envelope
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit)
        Query for rows 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:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for rows 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:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         int limit)
        Query for rows within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        envelope - geometry envelope
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         int limit,
                                         long offset)
        Query for rows within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        envelope - geometry envelope
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit)
        Query for rows 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:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for rows 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:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         int limit)
        Query for rows within the geometry envelope ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        envelope - geometry envelope
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

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

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         String[] columns,
                                         GeometryEnvelope envelope,
                                         String orderBy,
                                         int limit)
        Query for rows 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:
        results
        Since:
        6.2.0

      • queryForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunkIdOrder

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryFeaturesForChunk

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

      • queryForChunk

        public UserCustomResultSet queryForChunk​(double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         int limit)
        Query for rows within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         int limit,
                                         long offset)
        Query for rows within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         String orderBy,
                                         int limit)
        Query for rows within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for rows within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         int limit)
        Query for rows within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         int limit,
                                         long offset)
        Query for rows within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         String orderBy,
                                         int limit)
        Query for rows within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for rows within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         int limit)
        Query for rows within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         int limit,
                                         long offset)
        Query for rows within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         String orderBy,
                                         int limit)
        Query for rows within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(String[] columns,
                                         double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for rows within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         String[] columns,
                                         double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         int limit)
        Query for rows within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         String[] columns,
                                         double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         int limit,
                                         long offset)
        Query for rows within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         String[] columns,
                                         double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         String orderBy,
                                         int limit)
        Query for rows within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryForChunk

        public UserCustomResultSet queryForChunk​(boolean distinct,
                                         String[] columns,
                                         double minX,
                                         double minY,
                                         double maxX,
                                         double maxY,
                                         String orderBy,
                                         int limit,
                                         long offset)
        Query for rows within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              int limit,
                                              long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              int limit,
                                              long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              int limit,
                                              long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              int limit,
                                              long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              int limit,
                                              long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              int limit,
                                              long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              int limit,
                                              long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              int limit,
                                              long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              Map<String,​Object> fieldValues,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        fieldValues - field values
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunkIdOrder

        public FeatureResultSet queryFeaturesForChunkIdOrder​(double minX,
                                                     double minY,
                                                     double maxX,
                                                     double maxY,
                                                     String where,
                                                     int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunkIdOrder

        public FeatureResultSet queryFeaturesForChunkIdOrder​(double minX,
                                                     double minY,
                                                     double maxX,
                                                     double maxY,
                                                     String where,
                                                     int limit,
                                                     long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunkIdOrder

        public FeatureResultSet queryFeaturesForChunkIdOrder​(boolean distinct,
                                                     double minX,
                                                     double minY,
                                                     double maxX,
                                                     double maxY,
                                                     String where,
                                                     int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunkIdOrder

        public FeatureResultSet queryFeaturesForChunkIdOrder​(boolean distinct,
                                                     double minX,
                                                     double minY,
                                                     double maxX,
                                                     double maxY,
                                                     String where,
                                                     int limit,
                                                     long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunkIdOrder

        public FeatureResultSet queryFeaturesForChunkIdOrder​(String[] columns,
                                                     double minX,
                                                     double minY,
                                                     double maxX,
                                                     double maxY,
                                                     String where,
                                                     int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunkIdOrder

        public FeatureResultSet queryFeaturesForChunkIdOrder​(String[] columns,
                                                     double minX,
                                                     double minY,
                                                     double maxX,
                                                     double maxY,
                                                     String where,
                                                     int limit,
                                                     long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunkIdOrder

        public FeatureResultSet queryFeaturesForChunkIdOrder​(boolean distinct,
                                                     String[] columns,
                                                     double minX,
                                                     double minY,
                                                     double maxX,
                                                     double maxY,
                                                     String where,
                                                     int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunkIdOrder

        public FeatureResultSet queryFeaturesForChunkIdOrder​(boolean distinct,
                                                     String[] columns,
                                                     double minX,
                                                     double minY,
                                                     double maxX,
                                                     double maxY,
                                                     String where,
                                                     int limit,
                                                     long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              int limit,
                                              long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              int limit,
                                              long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              int limit,
                                              long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              int limit)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              int limit,
                                              long offset)
        Query for features within the bounds ordered by id, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              String orderBy,
                                              int limit)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        orderBy - order by
        limit - chunk limit
        Returns:
        results
        Since:
        6.2.0

      • queryFeaturesForChunk

        public FeatureResultSet queryFeaturesForChunk​(boolean distinct,
                                              String[] columns,
                                              double minX,
                                              double minY,
                                              double maxX,
                                              double maxY,
                                              String where,
                                              String[] whereArgs,
                                              String orderBy,
                                              int limit,
                                              long offset)
        Query for features within the bounds, starting at the offset and returning no more than the limit
        Parameters:
        distinct - distinct rows
        columns - columns
        minX - min x
        minY - min y
        maxX - max x
        maxY - max y
        where - where clause
        whereArgs - where arguments
        orderBy - order by
        limit - chunk limit
        offset - chunk query offset
        Returns:
        results
        Since:
        6.2.0