GPKGManualFeatureQuery Class Reference


                    
                    
                    chunkLimit

Query single chunk limit

Declaration

Objective-C

@property (nonatomic) int chunkLimit;

Swift

var chunkLimit: Int32 { get set }

Show on GitHub


                    
                    
                    tolerance

Query range tolerance

Declaration

Objective-C

@property (nonatomic) double tolerance;

Swift

var tolerance: Double { 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


                    
                    
                    -initWithFeatureDao:

Initialize

Declaration

Objective-C

- (instancetype)initWithFeatureDao:(GPKGFeatureDao *)featureDao;

Swift

init!(featureDao: GPKGFeatureDao!)

Parameters


                                featureDao

feature DAO

Return Value

new manual feature query

Show on GitHub


                    
                    
                    -initWithFeatureDao:andGeodesic:

Initialize

Declaration

Objective-C

- (instancetype)initWithFeatureDao:(GPKGFeatureDao *)featureDao
                       andGeodesic:(BOOL)geodesic;

Swift

init!(featureDao: GPKGFeatureDao!, andGeodesic geodesic: Bool)

Parameters

`featureDao`	feature DAO
`geodesic`	index using geodesic bounds

Return Value

new manual feature query

Show on GitHub


                    
                    
                    -featureDao

Get the feature DAO

Declaration

Objective-C

- (GPKGFeatureDao *)featureDao;

Swift

func featureDao() -> GPKGFeatureDao!

Return Value

feature DAO

Show on GitHub


                    
                    
                    -query

Query for features

Declaration

Objective-C

- (GPKGResultSet *)query;

Swift

func query() -> GPKGResultSet!

Return Value

feature results

Show on GitHub


                    
                    
                    -queryWithDistinct:

Query for features

Declaration

Objective-C

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

Swift

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

Parameters


                                distinct

distinct rows

Return Value

feature results

Show on GitHub


                    
                    
                    -queryWithColumns:

Query for features

Declaration

Objective-C

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

Swift

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

Parameters


                                columns

columns

Return Value

feature results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:

Query for features

Declaration

Objective-C

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

Swift

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

Parameters

`distinct`	distinct rows
`columns`	columns

Return Value

feature results

Show on GitHub


                    
                    
                    -count

Get the count of features

Declaration

Objective-C

- (int)count;

Swift

func count() -> Int32

Return Value

count

Show on GitHub


                    
                    
                    -countWithGeometries

Get the count of features with non null geometries

Declaration

Objective-C

- (int)countWithGeometries;

Swift

func countWithGeometries() -> Int32

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:

Get a count of results

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:

Get a count of results

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


                    
                    
                    -queryWithFieldValues:

Query for features

Declaration

Objective-C

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

Swift

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

Parameters


                                fieldValues

field values

Return Value

feature results

Show on GitHub


                    
                    
                    -queryWithDistinct:andFieldValues:

Query for features

Declaration

Objective-C

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

Swift

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

Parameters

`distinct`	distinct rows
`fieldValues`	field values

Return Value

feature results

Show on GitHub


                    
                    
                    -queryWithColumns:andFieldValues:

Query for features

Declaration

Objective-C

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

Swift

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

Parameters

`columns`	columns
`fieldValues`	field values

Return Value

feature results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andFieldValues:

Query for features

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -countWithFieldValues:

Count features

Declaration

Objective-C

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

Swift

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

Parameters


                                fieldValues

field values

Return Value

count

Show on GitHub


                    
                    
                    -countWithColumn:andFieldValues:

Count features

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

count

Show on GitHub


                    
                    
                    -countWithDistinct:andColumn:andFieldValues:

Count features

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

count

Show on GitHub


                    
                    
                    -queryWhere:

Query for features

Declaration

Objective-C

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

Swift

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

Parameters


                                where

where clause

Return Value

feature results

Show on GitHub


                    
                    
                    -queryWithDistinct:andWhere:

Query for features

Declaration

Objective-C

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

Swift

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

Parameters

`distinct`	distinct rows
`where`	where clause

Return Value

feature results

Show on GitHub


                    
                    
                    -queryWithColumns:andWhere:

Query for features

Declaration

Objective-C

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

Swift

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

Parameters

`columns`	columns
`where`	where clause

Return Value

feature results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andWhere:

Query for features

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -countWhere:

Count features

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:

Count features

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:

Count features

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 features

Declaration

Objective-C

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

Swift

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

Parameters

`where`	where clause
`whereArgs`	where arguments

Return Value

feature results

Show on GitHub


                    
                    
                    -queryWithDistinct:andWhere:andWhereArgs:

Query for features

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryWithColumns:andWhere:andWhereArgs:

Query for features

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andWhere:andWhereArgs:

Query for features

Declaration

Objective-C

- (GPKGResultSet *)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]!) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -countWhere:andWhereArgs:

Count features

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:

Count features

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:

Count features

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

Manually build the bounds of the feature table

Declaration

Objective-C

- (GPKGBoundingBox *)boundingBox;

Swift

func boundingBox() -> GPKGBoundingBox!

Return Value

bounding box

Show on GitHub


                    
                    
                    -boundingBoxInProjection:

Manually build the bounds of the feature table 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:

Manually query for rows within the bounding box

Declaration

Objective-C

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

Swift

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

Parameters


                                boundingBox

bounding box

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:

Manually query for rows within the bounding box

Declaration

Objective-C

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

Swift

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

Parameters

`distinct`	distinct rows
`boundingBox`	bounding box

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:

Manually query for rows within the bounding box

Declaration

Objective-C

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

Swift

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

Parameters

`columns`	columns
`boundingBox`	bounding box

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:

Manually query for rows within the bounding box

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -countWithBoundingBox:

Manually count the rows within the bounding box

Declaration

Objective-C

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

Swift

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

Parameters


                                boundingBox

bounding box

Return Value

count

Show on GitHub


                    
                    
                    -queryWithBoundingBox:andFieldValues:

Manually query for rows within the bounding box

Declaration

Objective-C

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

Swift

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

Parameters

`boundingBox`	bounding box
`fieldValues`	field values

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:andFieldValues:

Manually query for rows within the bounding box

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:andFieldValues:

Manually query for rows within the bounding box

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:andFieldValues:

Manually query for rows within the bounding box

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -countWithBoundingBox:andFieldValues:

Manually count the rows within the bounding box

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


                    
                    
                    -queryWithBoundingBox:andWhere:

Manually query for rows within the bounding box

Declaration

Objective-C

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

Swift

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

Parameters

`boundingBox`	bounding box
`where`	where clause

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:andWhere:

Manually query for rows within the bounding box

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:andWhere:

Manually query for rows within the bounding box

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:andWhere:

Manually query for rows within the bounding box

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -countWithBoundingBox:andWhere:

Manually count the rows within the bounding box

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


                    
                    
                    -queryWithBoundingBox:andWhere:andWhereArgs:

Manually query for rows within the bounding box

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:andWhere:andWhereArgs:

Manually query for rows within the bounding box

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)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]!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:andWhere:andWhereArgs:

Manually query for rows within the bounding box

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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]!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:andWhere:andWhereArgs:

Manually query for rows within the bounding box

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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]!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -countWithBoundingBox:andWhere:andWhereArgs:

Manually count the rows within the bounding box

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


                    
                    
                    -queryWithBoundingBox:inProjection:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

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

Swift

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

Parameters

`boundingBox`	bounding box
`projection`	projection

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:inProjection:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:inProjection:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:inProjection:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -countWithBoundingBox:inProjection:

Manually count the rows 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`	projection

Return Value

count

Show on GitHub


                    
                    
                    -queryWithBoundingBox:inProjection:andFieldValues:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:inProjection:andFieldValues:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:inProjection:andFieldValues:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:inProjection:andFieldValues:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -countWithBoundingBox:inProjection:andFieldValues:

Manually count the rows 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


                    
                    
                    -queryWithBoundingBox:inProjection:andWhere:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:inProjection:andWhere:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:inProjection:andWhere:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andBoundingBox:inProjection:andWhere:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -countWithBoundingBox:inProjection:andWhere:

Manually count the rows 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


                    
                    
                    -queryWithBoundingBox:inProjection:andWhere:andWhereArgs:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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]!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andBoundingBox:inProjection:andWhere:andWhereArgs:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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]!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andBoundingBox:inProjection:andWhere:andWhereArgs:

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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]!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


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

Manually query for rows within the bounding box in the provided projection

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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]!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -countWithBoundingBox:inProjection:andWhere:andWhereArgs:

Manually count the rows 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


                    
                    
                    -queryWithEnvelope:

Manually query for rows within the geometry envelope

Declaration

Objective-C

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

Swift

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

Parameters


                                envelope

geometry envelope

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andEnvelope:

Manually query for rows within the geometry envelope

Declaration

Objective-C

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

Swift

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

Parameters

`distinct`	distinct rows
`envelope`	geometry envelope

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andEnvelope:

Manually query for rows within the geometry envelope

Declaration

Objective-C

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

Swift

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

Parameters

`columns`	columns
`envelope`	geometry envelope

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andEnvelope:

Manually query for rows within the geometry envelope

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -countWithEnvelope:

Manually count the rows 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


                    
                    
                    -queryWithEnvelope:andFieldValues:

Manually query for rows within the geometry envelope

Declaration

Objective-C

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

Swift

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

Parameters

`envelope`	geometry envelope
`fieldValues`	field values

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andEnvelope:andFieldValues:

Manually query for rows within the geometry envelope

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andEnvelope:andFieldValues:

Manually query for rows within the geometry envelope

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andEnvelope:andFieldValues:

Manually query for rows within the geometry envelope

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -countWithEnvelope:andFieldValues:

Manually count the rows 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


                    
                    
                    -queryWithEnvelope:andWhere:

Manually query for rows within the geometry envelope

Declaration

Objective-C

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

Swift

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

Parameters

`envelope`	geometry envelope
`where`	where clause

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andEnvelope:andWhere:

Manually query for rows within the geometry envelope

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andEnvelope:andWhere:

Manually query for rows within the geometry envelope

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andEnvelope:andWhere:

Manually query for rows within the geometry envelope

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -countWithEnvelope:andWhere:

Manually count the rows 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


                    
                    
                    -queryWithEnvelope:andWhere:andWhereArgs:

Manually query for rows within the geometry envelope

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andEnvelope:andWhere:andWhereArgs:

Manually query for rows within the geometry envelope

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)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]!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andEnvelope:andWhere:andWhereArgs:

Manually query for rows within the geometry envelope

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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]!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andEnvelope:andWhere:andWhereArgs:

Manually query for rows within the geometry envelope

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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]!) -> GPKGManualFeatureQueryResults!

Parameters

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

Return Value

results

Show on GitHub


                    
                    
                    -countWithEnvelope:andWhere:andWhereArgs:

Manually count the rows 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


                    
                    
                    -queryWithMinX:andMinY:andMaxX:andMaxY:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithMinX:(double)minX
                                         andMinY:(double)minY
                                         andMaxX:(double)maxX
                                         andMaxY:(double)maxY;

Swift

func query(withMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double) -> GPKGManualFeatureQueryResults!

Parameters

`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andMinX:andMinY:andMaxX:andMaxY:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithDistinct:(BOOL)distinct
                                             andMinX:(double)minX
                                             andMinY:(double)minY
                                             andMaxX:(double)maxX
                                             andMaxY:(double)maxY;

Swift

func query(withDistinct distinct: Bool, andMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double) -> GPKGManualFeatureQueryResults!

Parameters

`distinct`	distinct rows
`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andMinX:andMinY:andMaxX:andMaxY:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithColumns:
                                       (NSArray<NSString *> *)columns
                                            andMinX:(double)minX
                                            andMinY:(double)minY
                                            andMaxX:(double)maxX
                                            andMaxY:(double)maxY;

Swift

func query(withColumns columns: [String]!, andMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double) -> GPKGManualFeatureQueryResults!

Parameters

`columns`	columns
`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andMinX:andMinY:andMaxX:andMaxY:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithDistinct:(BOOL)distinct
                                          andColumns:
                                              (NSArray<NSString *> *)columns
                                             andMinX:(double)minX
                                             andMinY:(double)minY
                                             andMaxX:(double)maxX
                                             andMaxY:(double)maxY;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double) -> GPKGManualFeatureQueryResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y

Return Value

results

Show on GitHub


                    
                    
                    -countWithMinX:andMinY:andMaxX:andMaxY:

Manually count the rows within the bounds

Declaration

Objective-C

- (int)countWithMinX:(double)minX
             andMinY:(double)minY
             andMaxX:(double)maxX
             andMaxY:(double)maxY;

Swift

func count(withMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double) -> Int32

Parameters

`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y

Return Value

count

Show on GitHub


                    
                    
                    -queryWithMinX:andMinY:andMaxX:andMaxY:andFieldValues:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithMinX:(double)minX
                                         andMinY:(double)minY
                                         andMaxX:(double)maxX
                                         andMaxY:(double)maxY
                                  andFieldValues:
                                      (GPKGColumnValues *)fieldValues;

Swift

func query(withMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGManualFeatureQueryResults!

Parameters

`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`fieldValues`	field values

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andMinX:andMinY:andMaxX:andMaxY:andFieldValues:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithDistinct:(BOOL)distinct
                                             andMinX:(double)minX
                                             andMinY:(double)minY
                                             andMaxX:(double)maxX
                                             andMaxY:(double)maxY
                                      andFieldValues:
                                          (GPKGColumnValues *)fieldValues;

Swift

func query(withDistinct distinct: Bool, andMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGManualFeatureQueryResults!

Parameters

`distinct`	distinct rows
`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`fieldValues`	field values

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andMinX:andMinY:andMaxX:andMaxY:andFieldValues:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    queryWithColumns:(NSArray<NSString *> *)columns
             andMinX:(double)minX
             andMinY:(double)minY
             andMaxX:(double)maxX
             andMaxY:(double)maxY
      andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withColumns columns: [String]!, andMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGManualFeatureQueryResults!

Parameters

`columns`	columns
`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`fieldValues`	field values

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andMinX:andMinY:andMaxX:andMaxY:andFieldValues:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    queryWithDistinct:(BOOL)distinct
           andColumns:(NSArray<NSString *> *)columns
              andMinX:(double)minX
              andMinY:(double)minY
              andMaxX:(double)maxX
              andMaxY:(double)maxY
       andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andFieldValues fieldValues: GPKGColumnValues!) -> GPKGManualFeatureQueryResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`fieldValues`	field values

Return Value

results

Show on GitHub


                    
                    
                    -countWithMinX:andMinY:andMaxX:andMaxY:andFieldValues:

Manually count the rows within the bounds

Declaration

Objective-C

- (int)countWithMinX:(double)minX
             andMinY:(double)minY
             andMaxX:(double)maxX
             andMaxY:(double)maxY
      andFieldValues:(GPKGColumnValues *)fieldValues;

Swift

func count(withMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andFieldValues fieldValues: GPKGColumnValues!) -> Int32

Parameters

`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`fieldValues`	field values

Return Value

count

Show on GitHub


                    
                    
                    -queryWithMinX:andMinY:andMaxX:andMaxY:andWhere:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithMinX:(double)minX
                                         andMinY:(double)minY
                                         andMaxX:(double)maxX
                                         andMaxY:(double)maxY
                                        andWhere:(NSString *)where;

Swift

func query(withMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andWhere where: String!) -> GPKGManualFeatureQueryResults!

Parameters

`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`where`	where clause

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andMinX:andMinY:andMaxX:andMaxY:andWhere:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithDistinct:(BOOL)distinct
                                             andMinX:(double)minX
                                             andMinY:(double)minY
                                             andMaxX:(double)maxX
                                             andMaxY:(double)maxY
                                            andWhere:(NSString *)where;

Swift

func query(withDistinct distinct: Bool, andMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andWhere where: String!) -> GPKGManualFeatureQueryResults!

Parameters

`distinct`	distinct rows
`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`where`	where clause

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andMinX:andMinY:andMaxX:andMaxY:andWhere:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithColumns:
                                       (NSArray<NSString *> *)columns
                                            andMinX:(double)minX
                                            andMinY:(double)minY
                                            andMaxX:(double)maxX
                                            andMaxY:(double)maxY
                                           andWhere:(NSString *)where;

Swift

func query(withColumns columns: [String]!, andMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andWhere where: String!) -> GPKGManualFeatureQueryResults!

Parameters

`columns`	columns
`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`where`	where clause

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andMinX:andMinY:andMaxX:andMaxY:andWhere:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithDistinct:(BOOL)distinct
                                          andColumns:
                                              (NSArray<NSString *> *)columns
                                             andMinX:(double)minX
                                             andMinY:(double)minY
                                             andMaxX:(double)maxX
                                             andMaxY:(double)maxY
                                            andWhere:(NSString *)where;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andWhere where: String!) -> GPKGManualFeatureQueryResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`where`	where clause

Return Value

results

Show on GitHub


                    
                    
                    -countWithMinX:andMinY:andMaxX:andMaxY:andWhere:

Manually count the rows within the bounds

Declaration

Objective-C

- (int)countWithMinX:(double)minX
             andMinY:(double)minY
             andMaxX:(double)maxX
             andMaxY:(double)maxY
            andWhere:(NSString *)where;

Swift

func count(withMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andWhere where: String!) -> Int32

Parameters

`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`where`	where clause

Return Value

count

Show on GitHub


                    
                    
                    -queryWithMinX:andMinY:andMaxX:andMaxY:andWhere:andWhereArgs:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithMinX:(double)minX
                                         andMinY:(double)minY
                                         andMaxX:(double)maxX
                                         andMaxY:(double)maxY
                                        andWhere:(NSString *)where
                                    andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGManualFeatureQueryResults!

Parameters

`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`where`	where clause
`whereArgs`	where args

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andMinX:andMinY:andMaxX:andMaxY:andWhere:andWhereArgs:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithDistinct:(BOOL)distinct
                                             andMinX:(double)minX
                                             andMinY:(double)minY
                                             andMaxX:(double)maxX
                                             andMaxY:(double)maxY
                                            andWhere:(NSString *)where
                                        andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withDistinct distinct: Bool, andMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGManualFeatureQueryResults!

Parameters

`distinct`	distinct rows
`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`where`	where clause
`whereArgs`	where args

Return Value

results

Show on GitHub


                    
                    
                    -queryWithColumns:andMinX:andMinY:andMaxX:andMaxY:andWhere:andWhereArgs:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithColumns:
                                       (NSArray<NSString *> *)columns
                                            andMinX:(double)minX
                                            andMinY:(double)minY
                                            andMaxX:(double)maxX
                                            andMaxY:(double)maxY
                                           andWhere:(NSString *)where
                                       andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withColumns columns: [String]!, andMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGManualFeatureQueryResults!

Parameters

`columns`	columns
`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`where`	where clause
`whereArgs`	where args

Return Value

results

Show on GitHub


                    
                    
                    -queryWithDistinct:andColumns:andMinX:andMinY:andMaxX:andMaxY:andWhere:andWhereArgs:

Manually query for rows within the bounds

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)queryWithDistinct:(BOOL)distinct
                                          andColumns:
                                              (NSArray<NSString *> *)columns
                                             andMinX:(double)minX
                                             andMinY:(double)minY
                                             andMaxX:(double)maxX
                                             andMaxY:(double)maxY
                                            andWhere:(NSString *)where
                                        andWhereArgs:(NSArray *)whereArgs;

Swift

func query(withDistinct distinct: Bool, andColumns columns: [String]!, andMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> GPKGManualFeatureQueryResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`where`	where clause
`whereArgs`	where args

Return Value

results

Show on GitHub


                    
                    
                    -countWithMinX:andMinY:andMaxX:andMaxY:andWhere:andWhereArgs:

Manually count the rows within the bounds

Declaration

Objective-C

- (int)countWithMinX:(double)minX
             andMinY:(double)minY
             andMaxX:(double)maxX
             andMaxY:(double)maxY
            andWhere:(NSString *)where
        andWhereArgs:(NSArray *)whereArgs;

Swift

func count(withMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andWhere where: String!, andWhereArgs whereArgs: [Any]!) -> Int32

Parameters

`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`where`	where clause
`whereArgs`	where args

Return Value

count

Show on GitHub


                    
                    
                    -queryForChunkWithLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters


                                limit

chunk limit

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

`limit`	chunk limit
`offset`	chunk query offset

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

`orderBy`	order by
`limit`	chunk limit

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithOrderBy:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

`distinct`	distinct rows
`limit`	chunk limit

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andOrderBy:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

`columns`	columns
`limit`	chunk limit

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andOrderBy:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andOrderBy:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithFieldValues:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

`fieldValues`	field values
`limit`	chunk limit

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithFieldValues:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithFieldValues:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithFieldValues:andOrderBy:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andFieldValues:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andFieldValues:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andFieldValues:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andFieldValues:andOrderBy:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andFieldValues:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andFieldValues:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andFieldValues:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andFieldValues:andOrderBy:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andFieldValues:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andFieldValues:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andFieldValues:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


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

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

`where`	where clause
`limit`	chunk limit

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andOrderBy:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andOrderBy:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andOrderBy:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andWhere:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andWhere:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andWhere:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


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

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andWhereArgs:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

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

Swift

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

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andWhereArgs:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andWhereArgs:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andWhereArgs:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andWhereArgs:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


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

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andWhereArgs:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andWhereArgs:andLimit:andOffset:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


                    
                    
                    -queryForChunkWithColumns:andWhere:andWhereArgs:andOrderBy:andLimit:

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


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

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

Parameters

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

Return Value

feature results

Show on GitHub


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

Query for features, starting at the offset and returning no more than the limit

Declaration

Objective-C

- (GPKGResultSet *)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) -> GPKGResultSet!

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 results

Show on GitHub


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

Manually query for rows within the geometry envelope, starting at the offset and returning no more than the limit

WARNING: This method must iterate from the 0 offset each time, is extremely inefficient, and not recommended for use

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    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) -> GPKGManualFeatureQueryResults!

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

results

Show on GitHub


                    
                    
                    -queryForChunkWithDistinct:andColumns:andMinX:andMinY:andMaxX:andMaxY:andWhere:andWhereArgs:andOrderBy:andLimit:andOffset:

Manually query for rows within the bounds, starting at the offset and returning no more than the limit

WARNING: This method must iterate from the 0 offset each time, is extremely inefficient, and not recommended for use

Declaration

Objective-C

- (GPKGManualFeatureQueryResults *)
    queryForChunkWithDistinct:(BOOL)distinct
                   andColumns:(NSArray<NSString *> *)columns
                      andMinX:(double)minX
                      andMinY:(double)minY
                      andMaxX:(double)maxX
                      andMaxY:(double)maxY
                     andWhere:(NSString *)where
                 andWhereArgs:(NSArray *)whereArgs
                   andOrderBy:(NSString *)orderBy
                     andLimit:(int)limit
                    andOffset:(int)offset;

Swift

func queryForChunk(withDistinct distinct: Bool, andColumns columns: [String]!, andMinX minX: Double, andMinY minY: Double, andMaxX maxX: Double, andMaxY maxY: Double, andWhere where: String!, andWhereArgs whereArgs: [Any]!, andOrderBy orderBy: String!, andLimit limit: Int32, andOffset offset: Int32) -> GPKGManualFeatureQueryResults!

Parameters

`distinct`	distinct rows
`columns`	columns
`minX`	min x
`minY`	min y
`maxX`	max x
`maxY`	max y
`where`	where clause
`whereArgs`	where args
`orderBy`	order by
`limit`	chunk limit
`offset`	chunk query offset

Return Value

results

Show on GitHub