Where

public struct Where<O> : WhereClauseType, FetchClause, QueryClause, DeleteClause, Hashable where O : DynamicObject

extension Where: CustomDebugStringConvertible, CoreStoreDebugStringConvertible

The Where clause specifies the conditions for a fetch or a query.

&&(_:_:)
Combines two Where predicates together using AND operator
Declaration
Swift

public static func && (left: Where<O>, right: Where<O>) -> Where<O>


                    
                    
                    ||(_:_:)

Combines two Where predicates together using OR operator

Declaration

Swift

public static func || (left: Where<O>, right: Where<O>) -> Where<O>

!(_:)
Inverts the predicate of a Where clause using NOT operator
Declaration
Swift

public prefix static func ! (clause: Where<O>) -> Where<O>
&&?(_:_:)
Combines two Where predicates together using AND operator.
Declaration
Swift

public static func &&? (left: Where<O>, right: Where<O>?) -> Where<O>
Return Value

left if right is nil, otherwise equivalent to (left && right)
&&?(_:_:)
Combines two Where predicates together using AND operator.
Declaration
Swift

public static func &&? (left: Where<O>?, right: Where<O>) -> Where<O>
Return Value

right if left is nil, otherwise equivalent to (left && right)
||?(_:_:)
Combines two Where predicates together using OR operator.
Declaration
Swift

public static func ||? (left: Where<O>, right: Where<O>?) -> Where<O>
Return Value

left if right is nil, otherwise equivalent to (left || right)
||?(_:_:)
Combines two Where predicates together using OR operator.
Declaration
Swift

public static func ||? (left: Where<O>?, right: Where<O>) -> Where<O>
Return Value

right if left is nil, otherwise equivalent to (left || right)
init()
Initializes a Where clause with a predicate that always evaluates to true
Declaration
Swift

public init()


                    
                    
                    init(_:)

Initializes a Where clause with an existing Where clause.

Declaration

Swift

public init(_ clause: Where<O>)

Parameters


                                clause

the existing Where clause.


                    
                    
                    init(_:)

Initializes a Where clause with a predicate that always evaluates to the specified boolean value

Declaration

Swift

public init(_ value: Bool)

Parameters


                                value

the boolean value for the predicate


                    
                    
                    init(_:_:)

Initializes a Where clause with a predicate using the specified string format and arguments

Declaration

Swift

public init(_ format: String, _ args: Any...)

Parameters

`format`	the format string for the predicate
`args`	the arguments for `format`


                    
                    
                    init(_:argumentArray:)

Initializes a Where clause with a predicate using the specified string format and arguments

Declaration

Swift

public init(_ format: String, argumentArray: [Any]?)

Parameters

`format`	the format string for the predicate
`argumentArray`	the arguments for `format`


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality to nil

Declaration

Swift

public init(_ keyPath: KeyPathString, isEqualTo null: Void?)

Parameters

`keyPath`	the keyPath to compare with
`null`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality

Declaration

Swift

public init<V>(_ keyPath: KeyPathString, isEqualTo value: V) where V : FieldStorableType

Parameters

`keyPath`	the keyPath to compare with
`value`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality

Declaration

Swift

@_disfavoredOverload
public init<U>(_ keyPath: KeyPathString, isEqualTo value: U?) where U : QueryableAttributeType

Parameters

`keyPath`	the keyPath to compare with
`value`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality

Declaration

Swift

public init<Other>(_ keyPath: KeyPathString, isEqualTo object: Other?) where Other : DynamicObject

Parameters

`keyPath`	the keyPath to compare with
`object`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality

Declaration

Swift

public init(_ keyPath: KeyPathString, isEqualTo objectID: NSManagedObjectID)

Parameters

`keyPath`	the keyPath to compare with
`objectID`	the arguments for the `==` operator


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

public init<S>(_ keyPath: KeyPathString, isMemberOf list: S) where S : Sequence, S.Element : FieldStorableType

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

@_disfavoredOverload
public init<S>(_ keyPath: KeyPathString, isMemberOf list: S) where S : Sequence, S.Element : QueryableAttributeType

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

public init<S>(_ keyPath: KeyPathString, isMemberOf list: S) where S : Sequence, S.Element : DynamicObject

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

public init<S>(_ keyPath: KeyPathString, isMemberOf list: S) where S : Sequence, S.Element : NSManagedObjectID

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of

AnyWhereClause

predicate
Declaration
Swift

public let predicate: NSPredicate
init(_:)
Declaration
Swift

public init(_ predicate: NSPredicate)

WhereClauseType

ObjectType
Declaration
Swift

public typealias ObjectType = O

Equatable


                    
                    
                    ==(_:_:)

Declaration

Swift

public static func == (lhs: Where, rhs: Where) -> Bool

Hashable


                    
                    
                    hash(into:)

Declaration

Swift

public func hash(into hasher: inout Hasher)

CustomDebugStringConvertible


                    
                    
                    debugDescription

Declaration

Swift

public var debugDescription: String { get }

Expression


                    
                    
                    Expression

Type-safe keyPath chain usable in query/fetch expressions.

let expression: Where<Pet>.Expression = (\.master ~ \.name)
let owner = dataStack.fetchOne(
   From<Pet>().where(expression == "John")
)

Declaration

Swift

public struct Expression<T, V> : CustomStringConvertible, KeyPathStringConvertible where T : WhereExpressionTrait

SingleTarget

SingleTarget
Used only for Where.Expression type constraints. Specifies that this Where.Expression type pertains to an attribute property expression.
Declaration
Swift

public enum SingleTarget : WhereExpressionTrait

CollectionTarget

CollectionTarget
Used only for Where.Expression type constraints. Specifies that this Where.Expression type pertains to a to-many relationship expression.
Declaration
Swift

public enum CollectionTarget : WhereExpressionTrait

Available where `O`: `NSManagedObject`


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality to nil

Declaration

Swift

public init<V>(_ keyPath: KeyPath<O, V>, isEqualTo null: Void?) where V : QueryableAttributeType

Parameters

`keyPath`	the keyPath to compare with
`null`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality to nil

Declaration

Swift

public init<D>(_ keyPath: KeyPath<O, D>, isEqualTo null: Void?) where D : DynamicObject

Parameters

`keyPath`	the keyPath to compare with
`null`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality

Declaration

Swift

public init<V>(_ keyPath: KeyPath<O, V>, isEqualTo value: V?) where V : QueryableAttributeType

Parameters

`keyPath`	the keyPath to compare with
`value`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality

Declaration

Swift

public init<D>(_ keyPath: KeyPath<O, D>, isEqualTo value: D?) where D : DynamicObject

Parameters

`keyPath`	the keyPath to compare with
`value`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality

Declaration

Swift

public init<D>(_ keyPath: KeyPath<O, D>, isEqualTo objectID: NSManagedObjectID) where D : DynamicObject

Parameters

`keyPath`	the keyPath to compare with
`objectID`	the arguments for the `==` operator


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

public init<V, S>(_ keyPath: KeyPath<O, V>, isMemberOf list: S) where V : QueryableAttributeType, V == S.Element, S : Sequence

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

public init<D, S>(_ keyPath: KeyPath<O, D>, isMemberOf list: S) where D : DynamicObject, D == S.Element, S : Sequence

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

public init<D, S>(_ keyPath: KeyPath<D, O>, isMemberOf list: S) where D : DynamicObject, S : Sequence, S.Element : NSManagedObjectID

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of

Available where `O`: `CoreStoreObject`


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality

Declaration

Swift

public init<V>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, isEqualTo value: V) where V : FieldStorableType

Parameters

`keyPath`	the keyPath to compare with
`value`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality

Declaration

Swift

public init<V>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<V>>, isEqualTo value: V.DestinationObjectType?) where V : FieldRelationshipToOneType

Parameters

`keyPath`	the keyPath to compare with
`value`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality to nil

Declaration

Swift

public init<V>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, isEqualTo null: Void?) where V : FieldStorableType

Parameters

`keyPath`	the keyPath to compare with
`null`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality to nil

Declaration

Swift

public init<V>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<V>>, isEqualTo null: Void?) where V : FieldRelationshipToOneType

Parameters

`keyPath`	the keyPath to compare with
`null`	the arguments for the `==` operator


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

public init<V, S>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, isMemberOf list: S) where V : FieldStorableType, V == S.Element, S : Sequence

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

public init<V, S>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<V>>, isMemberOf list: S) where V : FieldRelationshipToOneType, S : Sequence, V.DestinationObjectType == S.Element

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

public init<V, S>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<V>>, isMemberOf list: S) where V : FieldRelationshipToOneType, S : Sequence, S.Element : NSManagedObjectID

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality

Declaration

Swift

public init<V>(_ keyPath: KeyPath<O, ValueContainer<O>.Required<V>>, isEqualTo value: V?) where V : ImportableAttributeType

Parameters

`keyPath`	the keyPath to compare with
`value`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality

Declaration

Swift

public init<V>(_ keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, isEqualTo value: V?) where V : ImportableAttributeType

Parameters

`keyPath`	the keyPath to compare with
`value`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality to nil

Declaration

Swift

public init<V>(_ keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, isEqualTo null: Void?) where V : ImportableAttributeType

Parameters

`keyPath`	the keyPath to compare with
`null`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality to nil

Declaration

Swift

public init<D>(_ keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>, isEqualTo null: Void?) where D : CoreStoreObject

Parameters

`keyPath`	the keyPath to compare with
`null`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality

Declaration

Swift

public init<D>(_ keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>, isEqualTo value: D?) where D : CoreStoreObject

Parameters

`keyPath`	the keyPath to compare with
`value`	the arguments for the `==` operator


                    
                    
                    init(_:isEqualTo:)

Initializes a Where clause that compares equality

Declaration

Swift

public init<D>(_ keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>, isEqualTo objectID: NSManagedObjectID) where D : CoreStoreObject

Parameters

`keyPath`	the keyPath to compare with
`objectID`	the arguments for the `==` operator


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

public init<V, S>(_ keyPath: KeyPath<O, ValueContainer<O>.Required<V>>, isMemberOf list: S) where V : ImportableAttributeType, V == S.Element, S : Sequence

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

public init<V, S>(_ keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, isMemberOf list: S) where V : ImportableAttributeType, V == S.Element, S : Sequence

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

public init<D, S>(_ keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>, isMemberOf list: S) where D : CoreStoreObject, D == S.Element, S : Sequence

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of


                    
                    
                    init(_:isMemberOf:)

Initializes a Where clause that compares membership

Declaration

Swift

public init<D, S>(_ keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>, isMemberOf list: S) where D : CoreStoreObject, S : Sequence, S.Element : NSManagedObjectID

Parameters

`keyPath`	the keyPath to compare with
`list`	the sequence to check membership of


                    
                    
                    init(_:)

Initializes a Where clause from a closure

Declaration

Swift

public init(_ condition: (O) -> Where<O>)

Parameters


                                condition

closure that returns the Where clause

Where

Declaration

Declaration

Declaration

Declaration

Return Value

Declaration

Return Value

Declaration

Return Value

Declaration

Return Value

Declaration

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

AnyWhereClause

Declaration

Declaration

WhereClauseType

Declaration

Equatable

Declaration

Hashable

Declaration

CustomDebugStringConvertible

Declaration

Expression

Declaration

SingleTarget

Declaration

CollectionTarget

Declaration

Available where O: NSManagedObject

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Available where O: CoreStoreObject

Declaration

Parameters

Declaration

Parameters

Declaration

Parameters

Available where `O`: `NSManagedObject`

Available where `O`: `CoreStoreObject`