Query
Query
To fetch all or find Entries use Query.
| Name | Type | Description |
|---|---|---|
| stack | Stack | Stack instance for the Query. |
| parameters | [String : Any] | URI parameter |
| queryParameter | [String : Any] | Query parameters. |
| cachePolicy | CachePolicy | To set the cache policy for the query request. |
where(valueAtKey:_:)
Use this method to do a search on Entries which enables searching for entries based on value’s for field key Path.
| Name | Type | Description |
|---|---|---|
| path (required) | string | The field key path that you are performing your select operation against. |
| operation (required) | Query.Operation | The query operation used in the query. |
let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKey: "<FIELD_UID>", .equals("Entry Title"))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKey: "<FIELD_UID>", .notEquals("Entry Title"))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKey: "<FIELD_UID>", .includes(["one", "two"])
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKey: "<FIELD_UID>", .excludes(["three", "four"]))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKey: "<FIELD_UID>", .isLessThan(10))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKey: "<FIELD_UID>", .isLessThanOrEqual(10))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKey: "<FIELD_UID>", .isGreaterThan(10))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKey: "<FIELD_UID>", .isGreaterThanOrEqual(10))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKey: "<FIELD_UID>", exists(true))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKey: "<FIELD_UID>", .matches("^[a-z]"))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}where(queryableCodingKey:_:)
Use this method to do a search on Entries which enables searching for entries based on value’s for members of referenced entries.
| Name | Type | Description |
|---|---|---|
| queryableCodingKey (required) | EntryModel.FieldKeys | The member of your EntryModel.FieldKeys that you are performing your select operation against. |
| operation (required) | Query.Operation | The query operation used in the query. |
let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(queryableCodingKey: .title, .equals("Entry Title"))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(queryableCodingKey: .title, .notEquals("Entry Title"))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(queryableCodingKey: .title, .includes(["one", "two"])
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(queryableCodingKey: .title, .excludes(["three", "four"]))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(queryableCodingKey: .age, .isLessThan(10))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(queryableCodingKey: .age, .isLessThanOrEqual(10))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(queryableCodingKey: .age, .isGreaterThan(10))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(queryableCodingKey: .age, .isGreaterThanOrEqual(10))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(queryableCodingKey: .title, exists(true))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(queryableCodingKey: .title, .matches("^[a-z]"))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}where(referenceAtKeyPath:_:)
Use this method to do a search on Entries which enables searching for entries based on value’s for members of referenced entries.
| Name | Type | Description |
|---|---|---|
| keyPath (required) | string | The reference field key path that you are performing your select operation against. |
| operation (required) | Query.Reference | The query operation used in the query. |
let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
let referenceQuery = stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(queryableCodingKey: EntryModel.FieldKeys.title,Query.Operation.equals("10"))
let inReference = Query.Reference.include(referenceQuery)
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(referenceAtKeyPath: .title, inReference)
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
let referenceQuery = stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(queryableCodingKey: EntryModel.FieldKeys.title,Query.Operation.equals("10"))
let ninReference = Query.Reference.notInclude(referenceQuery)
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(referenceAtKeyPath: .title, ninReference)
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}orderByAscending(propertyName:)
When fetching entries, you can sort them in the ascending order with respect to the value of a specific field in the response body.
| Name | Type | Description |
|---|---|---|
| propertyName (required) | string | The member of your `EntryModel.FieldKeys` that you are performing order by ascending. |
let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.orderByAscending(propertyName: .title)
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}orderByDecending(propertyName:)
When fetching entries, you can sort them in the descending order with respect to the value of a specific field in the response body.
| Name | Type | Description |
|---|---|---|
| propertyName (required) | string | The member of your `EntryModel.FieldKeys` that you are performing order by descending. |
let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.orderByDecending(propertyName: .title)
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}tags(for:)
Use this method to do a search on tags for Entries.
| Name | Type | Description |
|---|---|---|
| text (required) | string | The text string to match against. |
let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.tags(for: "tagSearchString")
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}operator(_:)
Use this method to do a search on Entries which enables searching for entries based on Query.Operator.
| Name | Type | Description |
|---|---|---|
| operator (required) | Query.Operator | The member of Query.Operator that you are performing. |
let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
let query1 = stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKeyPath: "title", Query.Operation.equals("Gold"))
let query2 = stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKeyPath: "name", Query.Operation.equals("John"))
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.operator(.and([query1, query2]))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
let query1 = stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKeyPath: "title", Query.Operation.equals("Gold"))
let query2 = stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.where(valueAtKeyPath: "name", Query.Operation.equals("John"))
stack.contentType(uid: "<CONTENT_TYPE_UID>").entry().query()
.operator(.or([query1, query2]))
.find { (result: Result<ContentstackResponse<EntryModel>, Error>, response: ResponseType) in
switch result {
case .success(let contentstackResponse):
case .failure(let error):
}
}