GPKGFeatureIndexManager Class Reference


                    
                    
                    indexLocation

Index location

Declaration

Objective-C

@property (nonatomic) enum GPKGFeatureIndexType indexLocation;

Swift

var indexLocation: GPKGFeatureIndexType { get set }

Show on GitHub


                    
                    
                    continueOnError

When an exception occurs on a certain index, continue to other index types to attempt to retrieve the value

Declaration

Objective-C

@property (nonatomic) BOOL continueOnError;

Swift

var continueOnError: Bool { get set }

Show on GitHub


                    
                    
                    geodesic

Index geometries using geodesic lines

Declaration

Objective-C

@property (nonatomic) BOOL geodesic;

Swift

var geodesic: Bool { get set }

Show on GitHub


                    
                    
                    -initWithGeoPackage:andFeatureTable:

Initialize

Declaration

Objective-C

- (instancetype)initWithGeoPackage:(GPKGGeoPackage *)geoPackage
                   andFeatureTable:(NSString *)featureTable;

Swift

init!(geoPackage: GPKGGeoPackage!, andFeatureTable featureTable: String!)

Parameters

`geoPackage`	GeoPackage
`featureTable`	feature table

Return Value

new feature index manager

Show on GitHub


                    
                    
                    -initWithGeoPackage:andFeatureDao:

Initialize

Declaration

Objective-C

- (instancetype)initWithGeoPackage:(GPKGGeoPackage *)geoPackage
                     andFeatureDao:(GPKGFeatureDao *)featureDao;

Swift

init!(geoPackage: GPKGGeoPackage!, andFeatureDao featureDao: GPKGFeatureDao!)

Parameters

`geoPackage`	GeoPackage
`featureDao`	feature data access object

Return Value

new feature index manager

Show on GitHub


                    
                    
                    -initWithGeoPackage:andFeatureTable:andGeodesic:

Initialize

Declaration

Objective-C

- (instancetype)initWithGeoPackage:(GPKGGeoPackage *)geoPackage
                   andFeatureTable:(NSString *)featureTable
                       andGeodesic:(BOOL)geodesic;

Swift

init!(geoPackage: GPKGGeoPackage!, andFeatureTable featureTable: String!, andGeodesic geodesic: Bool)

Parameters

`geoPackage`	GeoPackage
`featureTable`	feature table
`geodesic`	index using geodesic bounds

Return Value

new feature index manager

Show on GitHub


                    
                    
                    -initWithGeoPackage:andFeatureDao:andGeodesic:

Initialize

Declaration

Objective-C

- (instancetype)initWithGeoPackage:(GPKGGeoPackage *)geoPackage
                     andFeatureDao:(GPKGFeatureDao *)featureDao
                       andGeodesic:(BOOL)geodesic;

Swift

init!(geoPackage: GPKGGeoPackage!, andFeatureDao featureDao: GPKGFeatureDao!, andGeodesic geodesic: Bool)

Parameters

`geoPackage`	GeoPackage
`featureDao`	feature data access object
`geodesic`	index using geodesic bounds

Return Value

new feature index manager

Show on GitHub


                    
                    
                    -close

Close the index connections

Declaration

Objective-C

- (void)close;

Swift

func close()

Show on GitHub


                    
                    
                    -featureDao

Get the feature DAO

Declaration

Objective-C

- (GPKGFeatureDao *)featureDao;

Swift

func featureDao() -> GPKGFeatureDao!

Return Value

feature DAO

Show on GitHub


                    
                    
                    -featureTableIndex

Get the feature table index, used to index inside the GeoPackage as an extension

Declaration

Objective-C

- (GPKGFeatureTableIndex *)featureTableIndex;

Swift

func featureTableIndex() -> GPKGFeatureTableIndex!

Return Value

feature table index

Show on GitHub


                    
                    
                    -featureIndexer

Get the feature indexer, used to index in metadata tables

Declaration

Objective-C

- (GPKGFeatureIndexer *)featureIndexer;

Swift

func featureIndexer() -> GPKGFeatureIndexer!

Return Value

feature indexer

Show on GitHub


                    
                    
                    -rTreeIndexTableDao

Get the RTree Index Table DAO

Declaration

Objective-C

- (GPKGRTreeIndexTableDao *)rTreeIndexTableDao;

Swift

func rTreeIndexTableDao() -> GPKGRTreeIndexTableDao!

Return Value

RTree index table DAO

Show on GitHub


                    
                    
                    -indexLocationQueryOrder

Get the ordered index query locations

Declaration

Objective-C

- (NSArray *)indexLocationQueryOrder;

Swift

func indexLocationQueryOrder() -> [Any]!

Return Value

ordered index types

Show on GitHub


                    
                    
                    -prioritizeQueryLocationWithType:

Prioritize the query location order. The type is placed at the front of the query order, leaving the remaining locations in their current order.

Declaration

Objective-C

- (void)prioritizeQueryLocationWithType:
    (enum GPKGFeatureIndexType)featureIndexType;

Swift

func prioritizeQueryLocation(with featureIndexType: GPKGFeatureIndexType)

Parameters


                                featureIndexType

feature index type

Show on GitHub


                    
                    
                    -prioritizeQueryLocationWithTypes:

Prioritize the query location order. All types are placed at the front of the query order in the order they are given. Omitting a location leaves it at it’s current priority location.

Declaration

Objective-C

- (void)prioritizeQueryLocationWithTypes:
    (NSArray<NSString *> *)featureIndexTypes;

Swift

func prioritizeQueryLocation(withTypes featureIndexTypes: [String]!)

Parameters


                                featureIndexTypes

array of feature index type names

Show on GitHub


                    
                    
                    -setIndexLocationOrderWithTypes:

Set the index location order, overriding all previously set types

Declaration

Objective-C

- (void)setIndexLocationOrderWithTypes:(NSArray *)featureIndexTypes;

Swift

func setIndexLocationOrderWithTypes(_ featureIndexTypes: [Any]!)

Parameters


                                featureIndexTypes

feature index types

Show on GitHub


                    
                    
                    -setProgress:

Set the GeoPackage Progress

Declaration

Objective-C

- (void)setProgress:(NSObject<GPKGProgress> *)progress;

Swift

func setProgress(_ progress: (any GPKGProgress)!)

Parameters


                                progress

progress

Show on GitHub


                    
                    
                    -index

Index the feature table if needed, using the set index location

Declaration

Objective-C

- (int)index;

Swift

func index() -> Int32

Return Value

count

Show on GitHub


                    
                    
                    -indexFeatureIndexTypes:

Index the feature tables if needed for the index types

Declaration

Objective-C

- (int)indexFeatureIndexTypes:(NSArray<NSString *> *)types;

Swift

func indexFeatureIndexTypes(_ types: [String]!) -> Int32

Parameters


                                types

feature index types

Return Value

largest count of indexed features

Show on GitHub


                    
                    
                    -indexWithFeatureIndexType:

Index the feature table if needed

Declaration

Objective-C

- (int)indexWithFeatureIndexType:(enum GPKGFeatureIndexType)type;

Swift

func index(with type: GPKGFeatureIndexType) -> Int32

Parameters


                                type

index location type

Return Value

count

Show on GitHub


                    
                    
                    -indexWithForce:

Index the feature table, using the set index location

Declaration

Objective-C

- (int)indexWithForce:(BOOL)force;

Swift

func index(withForce force: Bool) -> Int32

Parameters


                                force

true to force re-indexing

Return Value

count

Show on GitHub


                    
                    
                    -indexWithForce:andFeatureIndexTypes:

Index the feature tables for the index types

Declaration

Objective-C

- (int)indexWithForce:(BOOL)force
    andFeatureIndexTypes:(NSArray<NSString *> *)types;

Swift

func index(withForce force: Bool, andFeatureIndexTypes types: [String]!) -> Int32

Parameters

`force`	true to force re-indexing
`types`	feature index types

Return Value

largest count of indexed features

Show on GitHub


                    
                    
                    -indexWithFeatureIndexType:andForce:

Index the feature table

Declaration

Objective-C

- (int)indexWithFeatureIndexType:(enum GPKGFeatureIndexType)type
                        andForce:(BOOL)force;

Swift

func index(with type: GPKGFeatureIndexType, andForce force: Bool) -> Int32

Parameters

`type`	index location type
`force`	true to force re-indexing

Return Value

count

Show on GitHub


                    
                    
                    -indexWithFeatureRow:

Index the feature row, using the set index location. This method assumes that indexing has been completed and maintained as the last indexed time is updated.

Declaration

Objective-C

- (BOOL)indexWithFeatureRow:(GPKGFeatureRow *)row;

Swift

func index(with row: GPKGFeatureRow!) -> Bool

Parameters

row

feature row to index

Return Value

true if indexed

Show on GitHub


                    
                    
                    -indexWithFeatureRow:andFeatureIndexTypes:

Index the feature row for the index types. This method assumes that indexing has been completed and maintained as the last indexed time is updated.

Declaration

Objective-C

- (BOOL)indexWithFeatureRow:(GPKGFeatureRow *)row
       andFeatureIndexTypes:(NSArray<NSString *> *)types;

Swift

func index(with row: GPKGFeatureRow!, andFeatureIndexTypes types: [String]!) -> Bool

Parameters

`row`	feature row to index
`types`	feature index types

Return Value

true if indexed from any type

Show on GitHub


                    
                    
                    -indexWithFeatureIndexType:andFeatureRow:

Index the feature row. This method assumes that indexing has been completed and maintained as the last indexed time is updated.

Declaration

Objective-C

- (BOOL)indexWithFeatureIndexType:(enum GPKGFeatureIndexType)type
                    andFeatureRow:(GPKGFeatureRow *)row;

Swift

func index(with type: GPKGFeatureIndexType, andFeatureRow row: GPKGFeatureRow!) -> Bool

Parameters

`type`	index location type
`row`	feature row to index

Return Value

true if indexed

Show on GitHub


                    
                    
                    -deleteIndex

Delete the feature index

Declaration

Objective-C

- (BOOL)deleteIndex;

Swift

func deleteIndex() -> Bool

Return Value

true if deleted

Show on GitHub


                    
                    
                    -deleteAllIndexes

Delete the feature index from all query order locations

Declaration

Objective-C

- (BOOL)deleteAllIndexes;

Swift

func deleteAllIndexes() -> Bool

Return Value

true if deleted

Show on GitHub


                    
                    
                    -deleteIndexWithFeatureIndexTypes:

Delete the feature index from the index types

Declaration

Objective-C

- (BOOL)deleteIndexWithFeatureIndexTypes:(NSArray<NSString *> *)types;

Swift

func deleteIndex(withFeatureIndexTypes types: [String]!) -> Bool

Parameters


                                types

feature index types

Return Value

true if deleted from any type

Show on GitHub


                    
                    
                    -deleteIndexWithFeatureIndexType:

Delete the feature index

Declaration

Objective-C

- (BOOL)deleteIndexWithFeatureIndexType:(enum GPKGFeatureIndexType)type;

Swift

func deleteIndex(with type: GPKGFeatureIndexType) -> Bool

Parameters


                                type

index location type

Return Value

true if deleted

Show on GitHub


                    
                    
                    -deleteIndexWithFeatureRow:

Delete the feature index for the feature row

Declaration

Objective-C

- (BOOL)deleteIndexWithFeatureRow:(GPKGFeatureRow *)row;

Swift

func deleteIndex(with row: GPKGFeatureRow!) -> Bool

Parameters

row

feature row

Return Value

true if deleted

Show on GitHub


                    
                    
                    -deleteIndexWithFeatureRow:andFeatureIndexTypes:

Delete the feature index for the feature row from the index types

Declaration

Objective-C

- (BOOL)deleteIndexWithFeatureRow:(GPKGFeatureRow *)row
             andFeatureIndexTypes:(NSArray<NSString *> *)types;

Swift

func deleteIndex(with row: GPKGFeatureRow!, andFeatureIndexTypes types: [String]!) -> Bool

Parameters

`row`	feature row
`types`	feature index types

Return Value

true if deleted from any type

Show on GitHub


                    
                    
                    -deleteIndexWithFeatureIndexType:andFeatureRow:

Delete the feature index for the feature row

Declaration

Objective-C

- (BOOL)deleteIndexWithFeatureIndexType:(enum GPKGFeatureIndexType)type
                          andFeatureRow:(GPKGFeatureRow *)row;

Swift

func deleteIndex(with type: GPKGFeatureIndexType, andFeatureRow row: GPKGFeatureRow!) -> Bool

Parameters

`type`	index location type
`row`	feature row

Return Value

true if deleted

Show on GitHub


                    
                    
                    -deleteIndexWithGeomId:

Delete the feature index for the geometry id

Declaration

Objective-C

- (BOOL)deleteIndexWithGeomId:(int)geomId;

Swift

func deleteIndex(withGeomId geomId: Int32) -> Bool

Parameters


                                geomId

geometry id

Return Value

true if deleted

Show on GitHub


                    
                    
                    -deleteIndexWithGeomId:andFeatureIndexTypes:

Delete the feature index for the geometry id from the index types

Declaration

Objective-C

- (BOOL)deleteIndexWithGeomId:(int)geomId
         andFeatureIndexTypes:(NSArray<NSString *> *)types;

Swift

func deleteIndex(withGeomId geomId: Int32, andFeatureIndexTypes types: [String]!) -> Bool

Parameters

`geomId`	geometry id
`types`	feature index types

Return Value

true if deleted from any type

Show on GitHub


                    
                    
                    -deleteIndexWithFeatureIndexType:andGeomId:

Delete the feature index for the geometry id

Declaration

Objective-C

- (BOOL)deleteIndexWithFeatureIndexType:(enum GPKGFeatureIndexType)type
                              andGeomId:(int)geomId;

Swift

func deleteIndex(with type: GPKGFeatureIndexType, andGeomId geomId: Int32) -> Bool

Parameters

`type`	index location type
`geomId`	geometry id

Return Value

true if deleted

Show on GitHub


                    
                    
                    -retainIndexWithFeatureIndexType:

Retain the feature index from the index types and delete the others

Declaration

Objective-C

- (BOOL)retainIndexWithFeatureIndexType:(enum GPKGFeatureIndexType)type;

Swift

func retainIndex(with type: GPKGFeatureIndexType) -> Bool

Parameters


                                type

feature index type to retain

Return Value

true if deleted from any type

Show on GitHub


                    
                    
                    -retainIndexWithFeatureIndexTypes:

Retain the feature index from the index types and delete the others

Declaration

Objective-C

- (BOOL)retainIndexWithFeatureIndexTypes:(NSArray<NSString *> *)types;

Swift

func retainIndex(withFeatureIndexTypes types: [String]!) -> Bool

Parameters


                                types

feature index types to retain

Return Value

true if deleted from any type

Show on GitHub


                    
                    
                    -indexedTypes

Get the indexed types that are currently indexed

Declaration

Objective-C

- (NSArray<NSString *> *)indexedTypes;

Swift

func indexedTypes() -> [String]!

Return Value

indexed types

Show on GitHub


                    
                    
                    -isIndexed

Determine if the feature table is indexed

Declaration

Objective-C

- (BOOL)isIndexed;

Swift

func isIndexed() -> Bool

Return Value

true if indexed

Show on GitHub


                    
                    
                    -isIndexedWithFeatureIndexType:

Is the feature table indexed in the provided type location

Declaration

Objective-C

- (BOOL)isIndexedWithFeatureIndexType:(enum GPKGFeatureIndexType)type;

Swift

func isIndexed(with type: GPKGFeatureIndexType) -> Bool

Parameters


                                type

index location type

Return Value

true if indexed

Show on GitHub


                    
                    
                    -lastIndexed

Get the date last indexed

Declaration

Objective-C

- (NSDate *)lastIndexed;

Swift

func lastIndexed() -> Date!

Return Value

last indexed date or null

Show on GitHub


                    
                    
                    -lastIndexedWithFeatureIndexType:

Get the date last indexed

Declaration

Objective-C

- (NSDate *)lastIndexedWithFeatureIndexType:(enum GPKGFeatureIndexType)type;

Swift

func lastIndexed(with type: GPKGFeatureIndexType) -> Date!

Parameters


                                type

index location type

Return Value

last indexed date or null

Show on GitHub


                    
                    
                    -location

Get a feature index location to iterate over indexed types

Declaration

Objective-C

- (GPKGFeatureIndexLocation *)location;

Swift

func location() -> GPKGFeatureIndexLocation!

Return Value

feature index location

Show on GitHub


                    
                    
                    -indexedType

Get the first ordered indexed type

Declaration

Objective-C

- (enum GPKGFeatureIndexType)indexedType;

Swift

func indexedType() -> GPKGFeatureIndexType

Return Value

feature index type

Show on GitHub


                    
                    
                    -idColumn

Get the feature table id column name, the default column ordering

Declaration

Objective-C

- (NSString *)idColumn;

Swift

func idColumn() -> String!

Return Value

feature table id column name

Show on GitHub


                    
                    
                    -query

Query for all feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)query;

Swift

func query() -> GPKGFeatureIndexResults!

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:

Query for all feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct;

Swift

func query(withDistinct distinct: Bool) -> GPKGFeatureIndexResults!

Parameters


                                distinct

distinct rows

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:

Query for all feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns;

Swift

func query(withColumns columns: [String]!) -> GPKGFeatureIndexResults!

Parameters


                                columns

columns

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:

Query for all feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithColumn:

Query for all feature index count

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column;

Swift

func count(withColumn column: String!) -> Int32

Parameters


                                column

count column name

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:

Query for all feature index count

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct andColumn:(NSString *)column;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column name

Return Value

count

Show on GitHub


                    
                    
                    -count

Query for all feature index count

Declaration

Objective-C

- (int)count;

Swift

func count() -> Int32

Return Value

count

Show on GitHub


                    
                    
                    -queryWithFieldValues:

Query for feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithFieldValues:
    (GPKGColumnValues *)fieldValues;

Swift

func query(withFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters


                                fieldValues

field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andFieldValues:

Query for feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withDistinct distinct: Bool, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andFieldValues:

Query for feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                               andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withColumns columns: [String]!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andFieldValues:

Query for feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithFieldValues:

Query for feature index count

Declaration

Objective-C

- (int)countWithFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func count(withFieldValues fieldValues: GPKGColumnValues!) -> Int32

Parameters


                                fieldValues

field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithColumn:andFieldValues:

Query for feature index count

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
        andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func count(withColumn column: String!, andFieldValues fieldValues: GPKGColumnValues!) -> Int32

Parameters

`column`	count column name
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andFieldValues:

Query for feature index count

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
          andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andFieldValues fieldValues: GPKGColumnValues!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column name
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWhere:

Query for feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWhere:(NSString *)where;

Swift

func queryWhere(_ where: String!) -> GPKGFeatureIndexResults!

Parameters


                                where

where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andWhere:

Query for feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                      andWhere:(NSString *)where;

Swift

func query(withDistinct distinct: Bool, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andWhere:

Query for feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                                     andWhere:(NSString *)where;

Swift

func query(withColumns columns: [String]!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andWhere:

Query for feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                      andWhere:(NSString *)where;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWhere:

Query for feature index count

Declaration

Objective-C

- (int)countWhere:(NSString *)where;

Swift

func countWhere(_ where: String!) -> Int32

Parameters


                                where

where clause

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andWhere:

Query for feature index count

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column andWhere:(NSString *)where;

Swift

func count(withColumn column: String!, andWhere where: String!) -> Int32

Parameters

`column`	count column name
`where`	where clause

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andWhere:

Query for feature index count

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
                andWhere:(NSString *)where;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andWhere where: String!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column name
`where`	where clause

Return Value

count

Show on GitHub


                    
                    
                    -queryWhere:andWhereArgs:

Query for feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWhere:(NSString *)where
                           andWhereArgs:(NSArray *)whereArgs;

Swift

func queryWhere(_ where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andWhere:andWhereArgs:

Query for feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                      andWhere:(NSString *)where
                                  andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withDistinct distinct: Bool, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andWhere:andWhereArgs:

Query for feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                                     andWhere:(NSString *)where
                                 andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withColumns columns: [String]!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andWhere:andWhereArgs:

Query for feature index results

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                      andWhere:(NSString *)where
                                  andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWhere:andWhereArgs:

Query for feature index count

Declaration

Objective-C

- (int)countWhere:(NSString *)where andWhereArgs:(NSArray *)whereArgs;

Swift

func countWhere(_ where: String!, andWhereArgs whereArgs: [Any]!) -> Int32

Parameters

`where`	where clause
`whereArgs`	where arguments

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andWhere:andWhereArgs:

Query for feature index count

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
              andWhere:(NSString *)where
          andWhereArgs:(NSArray *)whereArgs;

Swift

func count(withColumn column: String!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> Int32

Parameters

`column`	count column name
`where`	where clause
`whereArgs`	where arguments

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andWhere:andWhereArgs:

Query for feature index count

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
                andWhere:(NSString *)where
            andWhereArgs:(NSArray *)whereArgs;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column name
`where`	where clause
`whereArgs`	where arguments

Return Value

count

Show on GitHub


                    
                    
                    -boundingBox

Query for the feature index bounds

Declaration

Objective-C

- (GPKGBoundingBox *)boundingBox;

Swift

func boundingBox() -> GPKGBoundingBox!

Return Value

bounding box

Show on GitHub


                    
                    
                    -boundingBoxInProjection:

Query for the feature index bounds and return in the provided projection

Declaration

Objective-C

- (GPKGBoundingBox *)boundingBoxInProjection:(PROJProjection *)projection;

Swift

func boundingBox(in projection: PROJProjection!) -> GPKGBoundingBox!

Parameters


                                projection

desired projection

Return Value

bounding box

Show on GitHub


                    
                    
                    -queryWithBoundingBox:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithBoundingBox:
    (GPKGBoundingBox *)boundingBox;

Swift

func query(with boundingBox: GPKGBoundingBox!) -> GPKGFeatureIndexResults!

Parameters


                                boundingBox

bounding box

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                andBoundingBox:(GPKGBoundingBox *)boundingBox;

Swift

func query(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                               andBoundingBox:(GPKGBoundingBox *)boundingBox;

Swift

func query(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                andBoundingBox:(GPKGBoundingBox *)boundingBox;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithBoundingBox:

Query for feature index count within the bounding box, projected correctly

Declaration

Objective-C

- (int)countWithBoundingBox:(GPKGBoundingBox *)boundingBox;

Swift

func count(with boundingBox: GPKGBoundingBox!) -> Int32

Parameters


                                boundingBox

bounding box

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andBoundingBox:

Query for feature index count within the bounding box, projected correctly

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
        andBoundingBox:(GPKGBoundingBox *)boundingBox;

Swift

func count(withColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!) -> Int32

Parameters

`column`	count column name
`boundingBox`	bounding box

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andBoundingBox:

Query for feature index count within the bounding box, projected correctly

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
          andBoundingBox:(GPKGBoundingBox *)boundingBox;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column name
`boundingBox`	bounding box

Return Value

count

Show on GitHub


                    
                    
                    -queryWithBoundingBox:andFieldValues:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithBoundingBox:(GPKGBoundingBox *)boundingBox
                                   andFieldValues:
                                       (GPKGColumnValues *)fieldValues;

Swift

func query(with boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:andFieldValues:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                andBoundingBox:(GPKGBoundingBox *)boundingBox
                                andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:andFieldValues:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                               andBoundingBox:(GPKGBoundingBox *)boundingBox
                               andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:andFieldValues:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                andBoundingBox:(GPKGBoundingBox *)boundingBox
                                andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithBoundingBox:andFieldValues:

Query for feature index count within the bounding box, projected correctly

Declaration

Objective-C

- (int)countWithBoundingBox:(GPKGBoundingBox *)boundingBox
             andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func count(with boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!) -> Int32

Parameters

`boundingBox`	bounding box
`fieldValues`	field values

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andBoundingBox:andFieldValues:

Query for feature index count within the bounding box, projected correctly

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
        andBoundingBox:(GPKGBoundingBox *)boundingBox
        andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func count(withColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!) -> Int32

Parameters

`column`	column name
`boundingBox`	bounding box
`fieldValues`	field values

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andBoundingBox:andFieldValues:

Query for feature index count within the bounding box, projected correctly

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
          andBoundingBox:(GPKGBoundingBox *)boundingBox
          andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!) -> Int32

Parameters

`column`	column name
`boundingBox`	bounding box
`fieldValues`	field values

Return Value

count

Show on GitHub


                    
                    
                    -queryWithBoundingBox:andWhere:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithBoundingBox:(GPKGBoundingBox *)boundingBox
                                         andWhere:(NSString *)where;

Swift

func query(with boundingBox: GPKGBoundingBox!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:andWhere:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                andBoundingBox:(GPKGBoundingBox *)boundingBox
                                      andWhere:(NSString *)where;

Swift

func query(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:andWhere:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                               andBoundingBox:(GPKGBoundingBox *)boundingBox
                                     andWhere:(NSString *)where;

Swift

func query(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:andWhere:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                andBoundingBox:(GPKGBoundingBox *)boundingBox
                                      andWhere:(NSString *)where;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithBoundingBox:andWhere:

Query for feature index count within the bounding box, projected correctly

Declaration

Objective-C

- (int)countWithBoundingBox:(GPKGBoundingBox *)boundingBox
                   andWhere:(NSString *)where;

Swift

func count(with boundingBox: GPKGBoundingBox!, andWhere where: String!) -> Int32

Parameters

`boundingBox`	bounding box
`where`	where clause

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andBoundingBox:andWhere:

Query for feature index count within the bounding box, projected correctly

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
        andBoundingBox:(GPKGBoundingBox *)boundingBox
              andWhere:(NSString *)where;

Swift

func count(withColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!) -> Int32

Parameters

`column`	column name
`boundingBox`	bounding box
`where`	where clause

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andBoundingBox:andWhere:

Query for feature index count within the bounding box, projected correctly

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
          andBoundingBox:(GPKGBoundingBox *)boundingBox
                andWhere:(NSString *)where;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!) -> Int32

Parameters

`distinct`	distinct column values
`column`	column name
`boundingBox`	bounding box
`where`	where clause

Return Value

count

Show on GitHub


                    
                    
                    -queryWithBoundingBox:andWhere:andWhereArgs:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithBoundingBox:(GPKGBoundingBox *)boundingBox
                                         andWhere:(NSString *)where
                                     andWhereArgs:(NSArray *)whereArgs;

Swift

func query(with boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:andWhere:andWhereArgs:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                andBoundingBox:(GPKGBoundingBox *)boundingBox
                                      andWhere:(NSString *)where
                                  andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:andWhere:andWhereArgs:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                               andBoundingBox:(GPKGBoundingBox *)boundingBox
                                     andWhere:(NSString *)where
                                 andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:andWhere:andWhereArgs:

Query for feature index results within the bounding box, projected correctly

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                andBoundingBox:(GPKGBoundingBox *)boundingBox
                                      andWhere:(NSString *)where
                                  andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithBoundingBox:andWhere:andWhereArgs:

Query for feature index count within the bounding box, projected correctly

Declaration

Objective-C

- (int)countWithBoundingBox:(GPKGBoundingBox *)boundingBox
                   andWhere:(NSString *)where
               andWhereArgs:(NSArray *)whereArgs;

Swift

func count(with boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> Int32

Parameters

`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andBoundingBox:andWhere:andWhereArgs:

Query for feature index count within the bounding box, projected correctly

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
        andBoundingBox:(GPKGBoundingBox *)boundingBox
              andWhere:(NSString *)where
          andWhereArgs:(NSArray *)whereArgs;

Swift

func count(withColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> Int32

Parameters

`column`	count column value
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andBoundingBox:andWhere:andWhereArgs:

Query for feature index count within the bounding box, projected correctly

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
          andBoundingBox:(GPKGBoundingBox *)boundingBox
                andWhere:(NSString *)where
            andWhereArgs:(NSArray *)whereArgs;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column value
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments

Return Value

count

Show on GitHub


                    
                    
                    -queryWithEnvelope:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithEnvelope:(SFGeometryEnvelope *)envelope;

Swift

func query(with envelope: SFGeometryEnvelope!) -> GPKGFeatureIndexResults!

Parameters


                                envelope

geometry envelope

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andEnvelope:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                   andEnvelope:(SFGeometryEnvelope *)envelope;

Swift

func query(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andEnvelope:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                                  andEnvelope:(SFGeometryEnvelope *)envelope;

Swift

func query(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andEnvelope:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                   andEnvelope:(SFGeometryEnvelope *)envelope;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithEnvelope:

Query for feature index count within the Geometry Envelope

Declaration

Objective-C

- (int)countWithEnvelope:(SFGeometryEnvelope *)envelope;

Swift

func count(with envelope: SFGeometryEnvelope!) -> Int32

Parameters


                                envelope

geometry envelope

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andEnvelope:

Query for feature index count within the Geometry Envelope

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
           andEnvelope:(SFGeometryEnvelope *)envelope;

Swift

func count(withColumn column: String!, andEnvelope envelope: SFGeometryEnvelope!) -> Int32

Parameters

`column`	count column name
`envelope`	geometry envelope

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andEnvelope:

Query for feature index count within the Geometry Envelope

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
             andEnvelope:(SFGeometryEnvelope *)envelope;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andEnvelope envelope: SFGeometryEnvelope!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column name
`envelope`	geometry envelope

Return Value

count

Show on GitHub


                    
                    
                    -queryWithEnvelope:andFieldValues:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithEnvelope:(SFGeometryEnvelope *)envelope
                                andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(with envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andEnvelope:andFieldValues:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                   andEnvelope:(SFGeometryEnvelope *)envelope
                                andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andEnvelope:andFieldValues:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                                  andEnvelope:(SFGeometryEnvelope *)envelope
                               andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andEnvelope:andFieldValues:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                   andEnvelope:(SFGeometryEnvelope *)envelope
                                andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithEnvelope:andFieldValues:

Query for feature index count within the Geometry Envelope

Declaration

Objective-C

- (int)countWithEnvelope:(SFGeometryEnvelope *)envelope
          andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func count(with envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!) -> Int32

Parameters

`envelope`	geometry envelope
`fieldValues`	field values

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andEnvelope:andFieldValues:

Query for feature index count within the Geometry Envelope

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
           andEnvelope:(SFGeometryEnvelope *)envelope
        andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func count(withColumn column: String!, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!) -> Int32

Parameters

`column`	count column name
`envelope`	geometry envelope
`fieldValues`	field values

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andEnvelope:andFieldValues:

Query for feature index count within the Geometry Envelope

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
             andEnvelope:(SFGeometryEnvelope *)envelope
          andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column name
`envelope`	geometry envelope
`fieldValues`	field values

Return Value

count

Show on GitHub


                    
                    
                    -queryWithEnvelope:andWhere:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithEnvelope:(SFGeometryEnvelope *)envelope
                                      andWhere:(NSString *)where;

Swift

func query(with envelope: SFGeometryEnvelope!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andEnvelope:andWhere:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                   andEnvelope:(SFGeometryEnvelope *)envelope
                                      andWhere:(NSString *)where;

Swift

func query(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andEnvelope:andWhere:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                                  andEnvelope:(SFGeometryEnvelope *)envelope
                                     andWhere:(NSString *)where;

Swift

func query(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andEnvelope:andWhere:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                   andEnvelope:(SFGeometryEnvelope *)envelope
                                      andWhere:(NSString *)where;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithEnvelope:andWhere:

Query for feature index count within the Geometry Envelope

Declaration

Objective-C

- (int)countWithEnvelope:(SFGeometryEnvelope *)envelope
                andWhere:(NSString *)where;

Swift

func count(with envelope: SFGeometryEnvelope!, andWhere where: String!) -> Int32

Parameters

`envelope`	geometry envelope
`where`	where clause

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andEnvelope:andWhere:

Query for feature index count within the Geometry Envelope

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
           andEnvelope:(SFGeometryEnvelope *)envelope
              andWhere:(NSString *)where;

Swift

func count(withColumn column: String!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!) -> Int32

Parameters

`column`	count column name
`envelope`	geometry envelope
`where`	where clause

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andEnvelope:andWhere:

Query for feature index count within the Geometry Envelope

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
             andEnvelope:(SFGeometryEnvelope *)envelope
                andWhere:(NSString *)where;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column name
`envelope`	geometry envelope
`where`	where clause

Return Value

count

Show on GitHub


                    
                    
                    -queryWithEnvelope:andWhere:andWhereArgs:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithEnvelope:(SFGeometryEnvelope *)envelope
                                      andWhere:(NSString *)where
                                  andWhereArgs:(NSArray *)whereArgs;

Swift

func query(with envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andEnvelope:andWhere:andWhereArgs:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                   andEnvelope:(SFGeometryEnvelope *)envelope
                                      andWhere:(NSString *)where
                                  andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andEnvelope:andWhere:andWhereArgs:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                                  andEnvelope:(SFGeometryEnvelope *)envelope
                                     andWhere:(NSString *)where
                                 andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andEnvelope:andWhere:andWhereArgs:

Query for feature index results within the Geometry Envelope

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                   andEnvelope:(SFGeometryEnvelope *)envelope
                                      andWhere:(NSString *)where
                                  andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithEnvelope:andWhere:andWhereArgs:

Query for feature index count within the Geometry Envelope

Declaration

Objective-C

- (int)countWithEnvelope:(SFGeometryEnvelope *)envelope
                andWhere:(NSString *)where
            andWhereArgs:(NSArray *)whereArgs;

Swift

func count(with envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> Int32

Parameters

`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andEnvelope:andWhere:andWhereArgs:

Query for feature index count within the Geometry Envelope

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
           andEnvelope:(SFGeometryEnvelope *)envelope
              andWhere:(NSString *)where
          andWhereArgs:(NSArray *)whereArgs;

Swift

func count(withColumn column: String!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> Int32

Parameters

`column`	count column name
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andEnvelope:andWhere:andWhereArgs:

Query for feature index count within the Geometry Envelope

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
             andEnvelope:(SFGeometryEnvelope *)envelope
                andWhere:(NSString *)where
            andWhereArgs:(NSArray *)whereArgs;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column name
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments

Return Value

count

Show on GitHub


                    
                    
                    -queryWithBoundingBox:inProjection:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithBoundingBox:(GPKGBoundingBox *)boundingBox
                                     inProjection:(PROJProjection *)projection;

Swift

func query(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	bounding box projection

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:inProjection:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                andBoundingBox:(GPKGBoundingBox *)boundingBox
                                  inProjection:(PROJProjection *)projection;

Swift

func query(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:inProjection:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                               andBoundingBox:(GPKGBoundingBox *)boundingBox
                                 inProjection:(PROJProjection *)projection;

Swift

func query(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithBoundingBox:inProjection:

Query for feature index count within the bounding box in the provided projection

Declaration

Objective-C

- (int)countWithBoundingBox:(GPKGBoundingBox *)boundingBox
               inProjection:(PROJProjection *)projection;

Swift

func count(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!) -> Int32

Parameters

`boundingBox`	bounding box
`projection`	bounding box projection

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andBoundingBox:inProjection:

Query for feature index count within the bounding box in the provided projection

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
        andBoundingBox:(GPKGBoundingBox *)boundingBox
          inProjection:(PROJProjection *)projection;

Swift

func count(withColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!) -> Int32

Parameters

`column`	count column name
`boundingBox`	bounding box
`projection`	projection

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andBoundingBox:inProjection:

Query for feature index count within the bounding box in the provided projection

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
          andBoundingBox:(GPKGBoundingBox *)boundingBox
            inProjection:(PROJProjection *)projection;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column name
`boundingBox`	bounding box
`projection`	projection

Return Value

count

Show on GitHub


                    
                    
                    -queryWithBoundingBox:inProjection:andFieldValues:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithBoundingBox:(GPKGBoundingBox *)boundingBox
                                     inProjection:(PROJProjection *)projection
                                   andFieldValues:
                                       (GPKGColumnValues *)fieldValues;

Swift

func query(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:inProjection:andFieldValues:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                andBoundingBox:(GPKGBoundingBox *)boundingBox
                                  inProjection:(PROJProjection *)projection
                                andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:inProjection:andFieldValues:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                               andBoundingBox:(GPKGBoundingBox *)boundingBox
                                 inProjection:(PROJProjection *)projection
                               andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:inProjection:andFieldValues:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                andBoundingBox:(GPKGBoundingBox *)boundingBox
                                  inProjection:(PROJProjection *)projection
                                andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithBoundingBox:inProjection:andFieldValues:

Query for feature index count within the bounding box in the provided projection

Declaration

Objective-C

- (int)countWithBoundingBox:(GPKGBoundingBox *)boundingBox
               inProjection:(PROJProjection *)projection
             andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func count(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!) -> Int32

Parameters

`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andBoundingBox:inProjection:andFieldValues:

Query for feature index count within the bounding box in the provided projection

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
        andBoundingBox:(GPKGBoundingBox *)boundingBox
          inProjection:(PROJProjection *)projection
        andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func count(withColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!) -> Int32

Parameters

`column`	count column value
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andBoundingBox:inProjection:andFieldValues:

Query for feature index count within the bounding box in the provided projection

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
          andBoundingBox:(GPKGBoundingBox *)boundingBox
            inProjection:(PROJProjection *)projection
          andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column value
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values

Return Value

count

Show on GitHub


                    
                    
                    -queryWithBoundingBox:inProjection:andWhere:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithBoundingBox:(GPKGBoundingBox *)boundingBox
                                     inProjection:(PROJProjection *)projection
                                         andWhere:(NSString *)where;

Swift

func query(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:inProjection:andWhere:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                andBoundingBox:(GPKGBoundingBox *)boundingBox
                                  inProjection:(PROJProjection *)projection
                                      andWhere:(NSString *)where;

Swift

func query(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:inProjection:andWhere:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                               andBoundingBox:(GPKGBoundingBox *)boundingBox
                                 inProjection:(PROJProjection *)projection
                                     andWhere:(NSString *)where;

Swift

func query(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:inProjection:andWhere:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                andBoundingBox:(GPKGBoundingBox *)boundingBox
                                  inProjection:(PROJProjection *)projection
                                      andWhere:(NSString *)where;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithBoundingBox:inProjection:andWhere:

Query for feature index count within the bounding box in the provided projection

Declaration

Objective-C

- (int)countWithBoundingBox:(GPKGBoundingBox *)boundingBox
               inProjection:(PROJProjection *)projection
                   andWhere:(NSString *)where;

Swift

func count(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!) -> Int32

Parameters

`boundingBox`	bounding box
`projection`	projection
`where`	where clause

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andBoundingBox:inProjection:andWhere:

Query for feature index count within the bounding box in the provided projection

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
        andBoundingBox:(GPKGBoundingBox *)boundingBox
          inProjection:(PROJProjection *)projection
              andWhere:(NSString *)where;

Swift

func count(withColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!) -> Int32

Parameters

`column`	count column name
`boundingBox`	bounding box
`projection`	projection
`where`	where clause

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andBoundingBox:inProjection:andWhere:

Query for feature index count within the bounding box in the provided projection

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
          andBoundingBox:(GPKGBoundingBox *)boundingBox
            inProjection:(PROJProjection *)projection
                andWhere:(NSString *)where;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column name
`boundingBox`	bounding box
`projection`	projection
`where`	where clause

Return Value

count

Show on GitHub


                    
                    
                    -queryWithBoundingBox:inProjection:andWhere:andWhereArgs:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithBoundingBox:(GPKGBoundingBox *)boundingBox
                                     inProjection:(PROJProjection *)projection
                                         andWhere:(NSString *)where
                                     andWhereArgs:(NSArray *)whereArgs;

Swift

func query(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:inProjection:andWhere:andWhereArgs:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                andBoundingBox:(GPKGBoundingBox *)boundingBox
                                  inProjection:(PROJProjection *)projection
                                      andWhere:(NSString *)where
                                  andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:inProjection:andWhere:andWhereArgs:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithColumns:(NSArray<NSString *> *)columns
                               andBoundingBox:(GPKGBoundingBox *)boundingBox
                                 inProjection:(PROJProjection *)projection
                                     andWhere:(NSString *)where
                                 andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:inProjection:andWhere:andWhereArgs:

Query for feature index results within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryWithDistinct:(BOOL)distinct
                                    andColumns:(NSArray<NSString *> *)columns
                                andBoundingBox:(GPKGBoundingBox *)boundingBox
                                  inProjection:(PROJProjection *)projection
                                      andWhere:(NSString *)where
                                  andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -countWithBoundingBox:inProjection:andWhere:andWhereArgs:

Query for feature index count within the bounding box in the provided projection

Declaration

Objective-C

- (int)countWithBoundingBox:(GPKGBoundingBox *)boundingBox
               inProjection:(PROJProjection *)projection
                   andWhere:(NSString *)where
               andWhereArgs:(NSArray *)whereArgs;

Swift

func count(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> Int32

Parameters

`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andBoundingBox:inProjection:andWhere:andWhereArgs:

Query for feature index count within the bounding box in the provided projection

Declaration

Objective-C

- (int)countWithColumn:(NSString *)column
        andBoundingBox:(GPKGBoundingBox *)boundingBox
          inProjection:(PROJProjection *)projection
              andWhere:(NSString *)where
          andWhereArgs:(NSArray *)whereArgs;

Swift

func count(withColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> Int32

Parameters

`column`	count column name
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments

Return Value

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andBoundingBox:inProjection:andWhere:andWhereArgs:

Query for feature index count within the bounding box in the provided projection

Declaration

Objective-C

- (int)countWithDistinct:(BOOL)distinct
               andColumn:(NSString *)column
          andBoundingBox:(GPKGBoundingBox *)boundingBox
            inProjection:(PROJProjection *)projection
                andWhere:(NSString *)where
            andWhereArgs:(NSArray *)whereArgs;

Swift

func count(withDistinct distinct: Bool, andColumn column: String!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> Int32

Parameters

`distinct`	distinct column values
`column`	count column name
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments

Return Value

count

Show on GitHub


                    
                    
                    +isPaginated:

Determine if the results are paginated

Declaration

Objective-C

+ (BOOL)isPaginated:(GPKGFeatureIndexResults *)results;

Swift

class func isPaginated(_ results: GPKGFeatureIndexResults!) -> Bool

Parameters


                                results

query results

Return Value

true if paginated

Show on GitHub


                    
                    
                    -paginate:

Paginate the results

Declaration

Objective-C

- (GPKGRowPaginatedResults *)paginate:(GPKGFeatureIndexResults *)results;

Swift

func paginate(_ results: GPKGFeatureIndexResults!) -> GPKGRowPaginatedResults!

Parameters


                                results

feature index results

Return Value

feature paginated results

Show on GitHub


                    
                    
                    +paginate:withDao:

Paginate the results

Declaration

Objective-C

+ (GPKGRowPaginatedResults *)paginate:(GPKGFeatureIndexResults *)results
                              withDao:(GPKGFeatureDao *)dao;

Swift

class func paginate(_ results: GPKGFeatureIndexResults!, with dao: GPKGFeatureDao!) -> GPKGRowPaginatedResults!

Parameters

`results`	feature index results
`dao`	feature DAO

Return Value

feature paginated results

Show on GitHub


                    
                    
                    -queryForChunkWithLimit:

Query for all feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithLimit:(int)limit;

Swift

func queryForChunk(withLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters


                                limit

chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithLimit:andOffset:

Query for all feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithLimit:(int)limit
                                          andOffset:(int)offset;

Swift

func queryForChunk(withLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithOrderBy:andLimit:

Query for all feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithOrderBy:(NSString *)orderBy
                                             andLimit:(int)limit;

Swift

func queryForChunkWithOrder(by orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithOrderBy:andLimit:andOffset:

Query for all feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithOrderBy:(NSString *)orderBy
                                             andLimit:(int)limit
                                            andOffset:(int)offset;

Swift

func queryForChunkWithOrder(by orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andLimit:

Query for all feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andLimit:andOffset:

Query for all feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andOrderBy:andLimit:

Query for all feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andOrderBy:andLimit:andOffset:

Query for all feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andLimit:

Query for all feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithColumns:
                                 (NSArray<NSString *> *)columns
                                             andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andLimit:andOffset:

Query for all feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithColumns:
                                 (NSArray<NSString *> *)columns
                                             andLimit:(int)limit
                                            andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andOrderBy:andLimit:

Query for all feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithColumns:
                                 (NSArray<NSString *> *)columns
                                           andOrderBy:(NSString *)orderBy
                                             andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andOrderBy:andLimit:andOffset:

Query for all feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithColumns:
                                 (NSArray<NSString *> *)columns
                                           andOrderBy:(NSString *)orderBy
                                             andLimit:(int)limit
                                            andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andLimit:

Query for all feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andColumns:
                                                (NSArray<NSString *> *)columns
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andLimit:andOffset:

Query for all feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andColumns:
                                                (NSArray<NSString *> *)columns
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andOrderBy:andLimit:

Query for all feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andColumns:
                                                (NSArray<NSString *> *)columns
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andOrderBy:andLimit:andOffset:

Query for all feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andColumns:
                                                (NSArray<NSString *> *)columns
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithFieldValues:andLimit:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithFieldValues:
                                 (GPKGColumnValues *)fieldValues
                                                 andLimit:(int)limit;

Swift

func queryForChunk(withFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithFieldValues:andLimit:andOffset:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithFieldValues:
                                 (GPKGColumnValues *)fieldValues
                                                 andLimit:(int)limit
                                                andOffset:(int)offset;

Swift

func queryForChunk(withFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithFieldValues:andOrderBy:andLimit:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithFieldValues:
                                 (GPKGColumnValues *)fieldValues
                                               andOrderBy:(NSString *)orderBy
                                                 andLimit:(int)limit;

Swift

func queryForChunk(withFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithFieldValues:
                                 (GPKGColumnValues *)fieldValues
                                               andOrderBy:(NSString *)orderBy
                                                 andLimit:(int)limit
                                                andOffset:(int)offset;

Swift

func queryForChunk(withFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andFieldValues:andLimit:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andFieldValues:
                                            (GPKGColumnValues *)fieldValues
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andFieldValues:
                                            (GPKGColumnValues *)fieldValues
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andFieldValues:andOrderBy:andLimit:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andFieldValues:
                                            (GPKGColumnValues *)fieldValues
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andFieldValues:
                                            (GPKGColumnValues *)fieldValues
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andFieldValues:andLimit:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andFieldValues:(GPKGColumnValues *)fieldValues
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andFieldValues:(GPKGColumnValues *)fieldValues
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andFieldValues:andOrderBy:andLimit:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andFieldValues:(GPKGColumnValues *)fieldValues
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andFieldValues:(GPKGColumnValues *)fieldValues
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andFieldValues:andLimit:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andFieldValues:andOrderBy:andLimit:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andLimit:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithWhere:(NSString *)where
                                           andLimit:(int)limit;

Swift

func queryForChunk(withWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andLimit:andOffset:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithWhere:(NSString *)where
                                           andLimit:(int)limit
                                          andOffset:(int)offset;

Swift

func queryForChunk(withWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andOrderBy:andLimit:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithWhere:(NSString *)where
                                         andOrderBy:(NSString *)orderBy
                                           andLimit:(int)limit;

Swift

func queryForChunk(withWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andOrderBy:andLimit:andOffset:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithWhere:(NSString *)where
                                         andOrderBy:(NSString *)orderBy
                                           andLimit:(int)limit
                                          andOffset:(int)offset;

Swift

func queryForChunk(withWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andLimit:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                              andWhere:(NSString *)where
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andLimit:andOffset:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                              andWhere:(NSString *)where
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andOrderBy:andLimit:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                              andWhere:(NSString *)where
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                              andWhere:(NSString *)where
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andLimit:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithColumns:
                                 (NSArray<NSString *> *)columns
                                             andWhere:(NSString *)where
                                             andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andLimit:andOffset:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithColumns:
                                 (NSArray<NSString *> *)columns
                                             andWhere:(NSString *)where
                                             andLimit:(int)limit
                                            andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andOrderBy:andLimit:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithColumns:
                                 (NSArray<NSString *> *)columns
                                             andWhere:(NSString *)where
                                           andOrderBy:(NSString *)orderBy
                                             andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithColumns:
                                 (NSArray<NSString *> *)columns
                                             andWhere:(NSString *)where
                                           andOrderBy:(NSString *)orderBy
                                             andLimit:(int)limit
                                            andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andWhere:andLimit:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andColumns:
                                                (NSArray<NSString *> *)columns
                                              andWhere:(NSString *)where
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andWhere:andLimit:andOffset:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andColumns:
                                                (NSArray<NSString *> *)columns
                                              andWhere:(NSString *)where
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andWhere:andOrderBy:andLimit:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andColumns:
                                                (NSArray<NSString *> *)columns
                                              andWhere:(NSString *)where
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andColumns:
                                                (NSArray<NSString *> *)columns
                                              andWhere:(NSString *)where
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithWhere:(NSString *)where
                                       andWhereArgs:(NSArray *)whereArgs
                                           andLimit:(int)limit;

Swift

func queryForChunk(withWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithWhere:(NSString *)where
                                       andWhereArgs:(NSArray *)whereArgs
                                           andLimit:(int)limit
                                          andOffset:(int)offset;

Swift

func queryForChunk(withWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithWhere:(NSString *)where
                                       andWhereArgs:(NSArray *)whereArgs
                                         andOrderBy:(NSString *)orderBy
                                           andLimit:(int)limit;

Swift

func queryForChunk(withWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithWhere:(NSString *)where
                                       andWhereArgs:(NSArray *)whereArgs
                                         andOrderBy:(NSString *)orderBy
                                           andLimit:(int)limit
                                          andOffset:(int)offset;

Swift

func queryForChunk(withWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithColumns:
                                 (NSArray<NSString *> *)columns
                                             andWhere:(NSString *)where
                                         andWhereArgs:(NSArray *)whereArgs
                                             andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithColumns:
                                 (NSArray<NSString *> *)columns
                                             andWhere:(NSString *)where
                                         andWhereArgs:(NSArray *)whereArgs
                                             andLimit:(int)limit
                                            andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithColumns:
                                 (NSArray<NSString *> *)columns
                                             andWhere:(NSString *)where
                                         andWhereArgs:(NSArray *)whereArgs
                                           andOrderBy:(NSString *)orderBy
                                             andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithColumns:
                                 (NSArray<NSString *> *)columns
                                             andWhere:(NSString *)where
                                         andWhereArgs:(NSArray *)whereArgs
                                           andOrderBy:(NSString *)orderBy
                                             andLimit:(int)limit
                                            andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andColumns:
                                                (NSArray<NSString *> *)columns
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andColumns:
                                                (NSArray<NSString *> *)columns
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andColumns:
                                                (NSArray<NSString *> *)columns
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                            andColumns:
                                                (NSArray<NSString *> *)columns
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithBoundingBox:
                                 (GPKGBoundingBox *)boundingBox
                                                 andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithBoundingBox:
                                 (GPKGBoundingBox *)boundingBox
                                                 andLimit:(int)limit
                                                andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithBoundingBox:
                                 (GPKGBoundingBox *)boundingBox
                                               andOrderBy:(NSString *)orderBy
                                                 andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithBoundingBox:
                                 (GPKGBoundingBox *)boundingBox
                                               andOrderBy:(NSString *)orderBy
                                                 andLimit:(int)limit
                                                andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andBoundingBox:
                                            (GPKGBoundingBox *)boundingBox
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andBoundingBox:
                                            (GPKGBoundingBox *)boundingBox
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andBoundingBox:
                                            (GPKGBoundingBox *)boundingBox
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andBoundingBox:
                                            (GPKGBoundingBox *)boundingBox
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andFieldValues:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                  andFieldValues:(GPKGColumnValues *)fieldValues
                        andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                  andFieldValues:(GPKGColumnValues *)fieldValues
                        andLimit:(int)limit
                       andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andFieldValues:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                  andFieldValues:(GPKGColumnValues *)fieldValues
                      andOrderBy:(NSString *)orderBy
                        andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                  andFieldValues:(GPKGColumnValues *)fieldValues
                      andOrderBy:(NSString *)orderBy
                        andLimit:(int)limit
                       andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andFieldValues:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andFieldValues:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andFieldValues:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
              andFieldValues:(GPKGColumnValues *)fieldValues
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
              andFieldValues:(GPKGColumnValues *)fieldValues
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andFieldValues:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
              andFieldValues:(GPKGColumnValues *)fieldValues
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
              andFieldValues:(GPKGColumnValues *)fieldValues
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andFieldValues:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andFieldValues:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andWhere:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithBoundingBox:
                                 (GPKGBoundingBox *)boundingBox
                                                 andWhere:(NSString *)where
                                                 andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andWhere:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithBoundingBox:
                                 (GPKGBoundingBox *)boundingBox
                                                 andWhere:(NSString *)where
                                                 andLimit:(int)limit
                                                andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andWhere:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithBoundingBox:
                                 (GPKGBoundingBox *)boundingBox
                                                 andWhere:(NSString *)where
                                               andOrderBy:(NSString *)orderBy
                                                 andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithBoundingBox:
                                 (GPKGBoundingBox *)boundingBox
                                                 andWhere:(NSString *)where
                                               andOrderBy:(NSString *)orderBy
                                                 andLimit:(int)limit
                                                andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andWhere:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andBoundingBox:
                                            (GPKGBoundingBox *)boundingBox
                                              andWhere:(NSString *)where
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andWhere:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andBoundingBox:
                                            (GPKGBoundingBox *)boundingBox
                                              andWhere:(NSString *)where
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andWhere:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andBoundingBox:
                                            (GPKGBoundingBox *)boundingBox
                                              andWhere:(NSString *)where
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andBoundingBox:
                                            (GPKGBoundingBox *)boundingBox
                                              andWhere:(NSString *)where
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andWhere:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                    andWhere:(NSString *)where
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andWhere:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                    andWhere:(NSString *)where
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andWhere:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                    andWhere:(NSString *)where
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                    andWhere:(NSString *)where
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andWhere:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                     andWhere:(NSString *)where
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andWhere:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                     andWhere:(NSString *)where
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andWhere:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                     andWhere:(NSString *)where
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                     andWhere:(NSString *)where
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithBoundingBox:
                                 (GPKGBoundingBox *)boundingBox
                                                 andWhere:(NSString *)where
                                             andWhereArgs:(NSArray *)whereArgs
                                                 andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithBoundingBox:
                                 (GPKGBoundingBox *)boundingBox
                                                 andWhere:(NSString *)where
                                             andWhereArgs:(NSArray *)whereArgs
                                                 andLimit:(int)limit
                                                andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithBoundingBox:
                                 (GPKGBoundingBox *)boundingBox
                                                 andWhere:(NSString *)where
                                             andWhereArgs:(NSArray *)whereArgs
                                               andOrderBy:(NSString *)orderBy
                                                 andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithBoundingBox:
                                 (GPKGBoundingBox *)boundingBox
                                                 andWhere:(NSString *)where
                                             andWhereArgs:(NSArray *)whereArgs
                                               andOrderBy:(NSString *)orderBy
                                                 andLimit:(int)limit
                                                andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andBoundingBox:
                                            (GPKGBoundingBox *)boundingBox
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andBoundingBox:
                                            (GPKGBoundingBox *)boundingBox
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andBoundingBox:
                                            (GPKGBoundingBox *)boundingBox
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                        andBoundingBox:
                                            (GPKGBoundingBox *)boundingBox
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                    andWhere:(NSString *)where
                andWhereArgs:(NSArray *)whereArgs
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                    andWhere:(NSString *)where
                andWhereArgs:(NSArray *)whereArgs
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                    andWhere:(NSString *)where
                andWhereArgs:(NSArray *)whereArgs
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                    andWhere:(NSString *)where
                andWhereArgs:(NSArray *)whereArgs
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box, projected correctly, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

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

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithEnvelope:
                                 (SFGeometryEnvelope *)envelope
                                              andLimit:(int)limit;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithEnvelope:
                                 (SFGeometryEnvelope *)envelope
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithEnvelope:
                                 (SFGeometryEnvelope *)envelope
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithEnvelope:
                                 (SFGeometryEnvelope *)envelope
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                           andEnvelope:
                                               (SFGeometryEnvelope *)envelope
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                           andEnvelope:
                                               (SFGeometryEnvelope *)envelope
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                           andEnvelope:
                                               (SFGeometryEnvelope *)envelope
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                           andEnvelope:
                                               (SFGeometryEnvelope *)envelope
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andFieldValues:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithEnvelope:(SFGeometryEnvelope *)envelope
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithEnvelope:(SFGeometryEnvelope *)envelope
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andFieldValues:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithEnvelope:(SFGeometryEnvelope *)envelope
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithEnvelope:(SFGeometryEnvelope *)envelope
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andFieldValues:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                  andEnvelope:(SFGeometryEnvelope *)envelope
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                  andEnvelope:(SFGeometryEnvelope *)envelope
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andFieldValues:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                  andEnvelope:(SFGeometryEnvelope *)envelope
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                  andEnvelope:(SFGeometryEnvelope *)envelope
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andFieldValues:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
              andFieldValues:(GPKGColumnValues *)fieldValues
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
              andFieldValues:(GPKGColumnValues *)fieldValues
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andFieldValues:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
              andFieldValues:(GPKGColumnValues *)fieldValues
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
              andFieldValues:(GPKGColumnValues *)fieldValues
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andFieldValues:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andFieldValues:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andWhere:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithEnvelope:
                                 (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                              andLimit:(int)limit;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andWhere:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithEnvelope:
                                 (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andWhere:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithEnvelope:
                                 (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithEnvelope:
                                 (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andWhere:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                           andEnvelope:
                                               (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andWhere:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                           andEnvelope:
                                               (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andWhere:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                           andEnvelope:
                                               (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                           andEnvelope:
                                               (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andWhere:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
                    andWhere:(NSString *)where
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andWhere:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
                    andWhere:(NSString *)where
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andWhere:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
                    andWhere:(NSString *)where
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
                    andWhere:(NSString *)where
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andWhere:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
                     andWhere:(NSString *)where
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andWhere:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
                     andWhere:(NSString *)where
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andWhere:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
                     andWhere:(NSString *)where
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
                     andWhere:(NSString *)where
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithEnvelope:
                                 (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                              andLimit:(int)limit;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithEnvelope:
                                 (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithEnvelope:
                                 (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithEnvelope:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithEnvelope:
                                 (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(with envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                           andEnvelope:
                                               (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                           andEnvelope:
                                               (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                           andEnvelope:
                                               (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andEnvelope:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)queryForChunkWithDistinct:(BOOL)distinct
                                           andEnvelope:
                                               (SFGeometryEnvelope *)envelope
                                              andWhere:(NSString *)where
                                          andWhereArgs:(NSArray *)whereArgs
                                            andOrderBy:(NSString *)orderBy
                                              andLimit:(int)limit
                                             andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
                    andWhere:(NSString *)where
                andWhereArgs:(NSArray *)whereArgs
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
                    andWhere:(NSString *)where
                andWhereArgs:(NSArray *)whereArgs
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
                    andWhere:(NSString *)where
                andWhereArgs:(NSArray *)whereArgs
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andEnvelope:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
                 andEnvelope:(SFGeometryEnvelope *)envelope
                    andWhere:(NSString *)where
                andWhereArgs:(NSArray *)whereArgs
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`envelope`	geometry envelope
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andEnvelope:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results within the Geometry Envelope, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                  andEnvelope:(SFGeometryEnvelope *)envelope
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andEnvelope envelope: SFGeometryEnvelope!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

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

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                        andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                        andLimit:(int)limit
                       andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                      andOrderBy:(NSString *)orderBy
                        andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                      andOrderBy:(NSString *)orderBy
                        andLimit:(int)limit
                       andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andFieldValues:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                  andFieldValues:(GPKGColumnValues *)fieldValues
                        andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                  andFieldValues:(GPKGColumnValues *)fieldValues
                        andLimit:(int)limit
                       andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andFieldValues:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                  andFieldValues:(GPKGColumnValues *)fieldValues
                      andOrderBy:(NSString *)orderBy
                        andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                  andFieldValues:(GPKGColumnValues *)fieldValues
                      andOrderBy:(NSString *)orderBy
                        andLimit:(int)limit
                       andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andFieldValues:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andFieldValues:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andFieldValues:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
              andFieldValues:(GPKGColumnValues *)fieldValues
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
              andFieldValues:(GPKGColumnValues *)fieldValues
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andFieldValues:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
              andFieldValues:(GPKGColumnValues *)fieldValues
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
              andFieldValues:(GPKGColumnValues *)fieldValues
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andFieldValues:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andFieldValues:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
               andFieldValues:(GPKGColumnValues *)fieldValues
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andFieldValues:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andFieldValues:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
               andFieldValues:(GPKGColumnValues *)fieldValues
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andFieldValues fieldValues: GPKGColumnValues!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`fieldValues`	field values
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andWhere:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                        andWhere:(NSString *)where
                        andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andWhere:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                        andWhere:(NSString *)where
                        andLimit:(int)limit
                       andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andWhere:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                        andWhere:(NSString *)where
                      andOrderBy:(NSString *)orderBy
                        andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                        andWhere:(NSString *)where
                      andOrderBy:(NSString *)orderBy
                        andLimit:(int)limit
                       andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andWhere:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andWhere:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andWhere:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andWhere:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
                    andWhere:(NSString *)where
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andWhere:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
                    andWhere:(NSString *)where
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andWhere:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
                    andWhere:(NSString *)where
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
                    andWhere:(NSString *)where
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andWhere:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andWhere:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andWhere:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andWhere:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                        andWhere:(NSString *)where
                    andWhereArgs:(NSArray *)whereArgs
                        andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                        andWhere:(NSString *)where
                    andWhereArgs:(NSArray *)whereArgs
                        andLimit:(int)limit
                       andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                        andWhere:(NSString *)where
                    andWhereArgs:(NSArray *)whereArgs
                      andOrderBy:(NSString *)orderBy
                        andLimit:(int)limit;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithBoundingBox:inProjection:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithBoundingBox:(GPKGBoundingBox *)boundingBox
                    inProjection:(PROJProjection *)projection
                        andWhere:(NSString *)where
                    andWhereArgs:(NSArray *)whereArgs
                      andOrderBy:(NSString *)orderBy
                        andLimit:(int)limit
                       andOffset:(int)offset;

Swift

func queryForChunk(with boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andBoundingBox:inProjection:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

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

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
                    andWhere:(NSString *)where
                andWhereArgs:(NSArray *)whereArgs
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
                    andWhere:(NSString *)where
                andWhereArgs:(NSArray *)whereArgs
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
                    andWhere:(NSString *)where
                andWhereArgs:(NSArray *)whereArgs
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andBoundingBox:inProjection:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithColumns:(NSArray<NSString *> *)columns
              andBoundingBox:(GPKGBoundingBox *)boundingBox
                inProjection:(PROJProjection *)projection
                    andWhere:(NSString *)where
                andWhereArgs:(NSArray *)whereArgs
                  andOrderBy:(NSString *)orderBy
                    andLimit:(int)limit
                   andOffset:(int)offset;

Swift

func queryForChunk(withColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andWhere:andWhereArgs:andLimit:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andWhere:andWhereArgs:andLimit:andOffset:

Query for feature index results ordered by id within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32) -> GPKGFeatureIndexResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`boundingBox`	bounding box
`projection`	projection
`where`	where clause
`whereArgs`	where arguments
`orderBy`	order by
`limit`	chunk limit

Return Value

feature index results, close when done

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andBoundingBox:inProjection:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for feature index results within the bounding box in the provided projection, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGFeatureIndexResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
               andBoundingBox:(GPKGBoundingBox *)boundingBox
                 inProjection:(PROJProjection *)projection
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andBoundingBox boundingBox: GPKGBoundingBox!, in projection: PROJProjection!, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGFeatureIndexResults!

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

Return Value

feature index results, close when done

Show on GitHub