Functions Reference

KeyPath where Root: NSManagedObject, Value: QueryableAttributeType & Equatable


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.nickname == "John"))

Declaration

Swift

public func == <O, V>(keyPath: KeyPath<O, V>, value: V) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.nickname != "John"))

Declaration

Swift

public func != <O, V>(keyPath: KeyPath<O, V>, value: V) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains the value of a property

let dog = dataStack.fetchOne(From<Dog>().where(["Pluto", "Snoopy", "Scooby"] ~= \.nickname))

Declaration

Swift

public func ~= <O, V, S>(sequence: S, keyPath: KeyPath<O, V>) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType, V == S.Element, S : Sequence

KeyPath where Root: NSManagedObject, Value: Optional


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.nickname == "John"))

Declaration

Swift

public func == <O, V>(keyPath: KeyPath<O, Optional<V>>, value: V?) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.nickname != "John"))

Declaration

Swift

public func != <O, V>(keyPath: KeyPath<O, Optional<V>>, value: V?) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains the value of a property

let dog = dataStack.fetchOne(From<Dog>().where(["Pluto", "Snoopy", "Scooby"] ~= \.nickname))

Declaration

Swift

public func ~= <O, V, S>(sequence: S, keyPath: KeyPath<O, Optional<V>>) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType, V == S.Element, S : Sequence

KeyPath where Root: NSManagedObject, Value: QueryableAttributeType & Comparable


                    
                    
                    <(_:_:)

Creates a Where clause by comparing if a property is less than a value

let person = dataStack.fetchOne(From<Person>().where(\.age < 20))

Declaration

Swift

public func < <O, V>(keyPath: KeyPath<O, V>, value: V) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType, V : Comparable


                    
                    
                    >(_:_:)

Creates a Where clause by comparing if a property is greater than a value

let person = dataStack.fetchOne(From<Person>().where(\.age > 20))

Declaration

Swift

public func > <O, V>(keyPath: KeyPath<O, V>, value: V) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType, V : Comparable


                    
                    
                    <=(_:_:)

Creates a Where clause by comparing if a property is less than or equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.age <= 20))

Declaration

Swift

public func <= <O, V>(keyPath: KeyPath<O, V>, value: V) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType, V : Comparable


                    
                    
                    >=(_:_:)

Creates a Where clause by comparing if a property is greater than or equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.age >= 20))

Declaration

Swift

public func >= <O, V>(keyPath: KeyPath<O, V>, value: V) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType, V : Comparable

KeyPath where Root: NSManagedObject, Value: Optional


                    
                    
                    <(_:_:)

Creates a Where clause by comparing if a property is less than a value

let person = dataStack.fetchOne(From<Person>().where(\.age < 20))

Declaration

Swift

public func < <O, V>(keyPath: KeyPath<O, Optional<V>>, value: V?) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType, V : Comparable


                    
                    
                    >(_:_:)

Creates a Where clause by comparing if a property is greater than a value

let person = dataStack.fetchOne(From<Person>().where(\.age > 20))

Declaration

Swift

public func > <O, V>(keyPath: KeyPath<O, Optional<V>>, value: V?) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType, V : Comparable


                    
                    
                    <=(_:_:)

Creates a Where clause by comparing if a property is less than or equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.age <= 20))

Declaration

Swift

public func <= <O, V>(keyPath: KeyPath<O, Optional<V>>, value: V?) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType, V : Comparable


                    
                    
                    >=(_:_:)

Creates a Where clause by comparing if a property is greater than or equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.age >= 20))

Declaration

Swift

public func >= <O, V>(keyPath: KeyPath<O, Optional<V>>, value: V?) -> Where<O> where O : NSManagedObject, V : QueryableAttributeType, V : Comparable

KeyPath where Root: NSManagedObject, Value: NSManagedObject


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master == john))

Declaration

Swift

public func == <O, D>(keyPath: KeyPath<O, D>, object: D) -> Where<O> where O : NSManagedObject, D : NSManagedObject


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master != john))

Declaration

Swift

public func != <O, D>(keyPath: KeyPath<O, D>, object: D) -> Where<O> where O : NSManagedObject, D : NSManagedObject


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains a value of a property

let dog = dataStack.fetchOne(From<Dog>().where([john, bob, joe] ~= \.master))

Declaration

Swift

public func ~= <O, D, S>(sequence: S, keyPath: KeyPath<O, D>) -> Where<O> where O : NSManagedObject, D : NSManagedObject, D == S.Element, S : Sequence


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master == john))

Declaration

Swift

public func == <O, D>(keyPath: KeyPath<O, D>, objectID: NSManagedObjectID) -> Where<O> where O : NSManagedObject, D : NSManagedObject


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master == john))

Declaration

Swift

public func == <O, D>(keyPath: KeyPath<O, D>, object: O) -> Where<O> where O : DynamicObject, O : ObjectRepresentation, D : NSManagedObject, O.ObjectType : NSManagedObject


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master != john))

Declaration

Swift

public func != <O, D>(keyPath: KeyPath<O, D>, objectID: NSManagedObjectID) -> Where<O> where O : NSManagedObject, D : NSManagedObject


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master != john))

Declaration

Swift

public func != <O, D>(keyPath: KeyPath<O, D>, object: O) -> Where<O> where O : DynamicObject, O : ObjectRepresentation, D : NSManagedObject, O.ObjectType : NSManagedObject


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains a value of a property

let dog = dataStack.fetchOne(From<Dog>().where([john, bob, joe] ~= \.master))

Declaration

Swift

public func ~= <O, D, S>(sequence: S, keyPath: KeyPath<O, D>) -> Where<O> where O : NSManagedObject, D : NSManagedObject, S : Sequence, S.Element == NSManagedObjectID

KeyPath where Root: NSManagedObject, Value: Optional


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master == john))

Declaration

Swift

public func == <O, D>(keyPath: KeyPath<O, Optional<D>>, object: D?) -> Where<O> where O : NSManagedObject, D : NSManagedObject


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master == john))

Declaration

Swift

public func == <O, D>(keyPath: KeyPath<O, Optional<D>>, object: O?) -> Where<O> where O : DynamicObject, O : ObjectRepresentation, D : NSManagedObject, O.ObjectType : NSManagedObject


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master != john))

Declaration

Swift

public func != <O, D>(keyPath: KeyPath<O, Optional<D>>, object: D?) -> Where<O> where O : NSManagedObject, D : NSManagedObject


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master != john))

Declaration

Swift

public func != <O, D>(keyPath: KeyPath<O, Optional<D>>, object: O?) -> Where<O> where O : DynamicObject, O : ObjectRepresentation, D : NSManagedObject, O.ObjectType : NSManagedObject


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains a value of a property

let dog = dataStack.fetchOne(From<Dog>().where([john, bob, joe] ~= \.master))

Declaration

Swift

public func ~= <O, D, S>(sequence: S, keyPath: KeyPath<O, Optional<D>>) -> Where<O> where O : NSManagedObject, D : NSManagedObject, D == S.Element, S : Sequence


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master == john))

Declaration

Swift

public func == <O, D>(keyPath: KeyPath<O, Optional<D>>, objectID: NSManagedObjectID) -> Where<O> where O : NSManagedObject, D : NSManagedObject


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master != john))

Declaration

Swift

public func != <O, D>(keyPath: KeyPath<O, Optional<D>>, objectID: NSManagedObjectID) -> Where<O> where O : NSManagedObject, D : NSManagedObject


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains a value of a property

let dog = dataStack.fetchOne(From<Dog>().where([john, bob, joe] ~= \.master))

Declaration

Swift

public func ~= <O, D, S>(sequence: S, keyPath: KeyPath<O, Optional<D>>) -> Where<O> where O : NSManagedObject, D : NSManagedObject, S : Sequence, S.Element == NSManagedObjectID

KeyPath where Root: CoreStoreObject, Value: FieldContainer.Stored


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.$nickname == "John"))

Declaration

Swift

public func == <O, V>(keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : FieldStorableType


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.$nickname != "John"))

Declaration

Swift

public func != <O, V>(keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : FieldStorableType


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains the value of a property

let dog = dataStack.fetchOne(From<Dog>().where(["Pluto", "Snoopy", "Scooby"] ~= \.nickname))

Declaration

Swift

public func ~= <O, V, S>(sequence: S, keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>) -> Where<O> where O : CoreStoreObject, V : FieldStorableType, V == S.Element, S : Sequence

KeyPath where Root: CoreStoreObject, Value: FieldContainer.Stored


                    
                    
                    <(_:_:)

Creates a Where clause by comparing if a property is less than a value

let person = dataStack.fetchOne(From<Person>().where(\.$age < 20))

Declaration

Swift

public func < <O, V>(keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : FieldStorableType, V : Comparable


                    
                    
                    <(_:_:)

Creates a Where clause by comparing if a property is less than a value

let person = dataStack.fetchOne(From<Person>().where(\.$age < 20))

Declaration

Swift

public func < <O, V>(keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : FieldOptionalType, V : FieldStorableType, V.Wrapped : Comparable


                    
                    
                    >(_:_:)

Creates a Where clause by comparing if a property is greater than a value

let person = dataStack.fetchOne(From<Person>().where(\.$age > 20))

Declaration

Swift

public func > <O, V>(keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : FieldStorableType, V : Comparable


                    
                    
                    >(_:_:)

Creates a Where clause by comparing if a property is greater than a value

let person = dataStack.fetchOne(From<Person>().where(\.$age > 20))

Declaration

Swift

public func > <O, V>(keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : FieldOptionalType, V : FieldStorableType, V.Wrapped : Comparable


                    
                    
                    <=(_:_:)

Creates a Where clause by comparing if a property is less than or equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.$age <= 20))

Declaration

Swift

public func <= <O, V>(keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : FieldStorableType, V : Comparable


                    
                    
                    <=(_:_:)

Creates a Where clause by comparing if a property is less than or equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.$age <= 20))

Declaration

Swift

public func <= <O, V>(keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : FieldOptionalType, V : FieldStorableType, V.Wrapped : Comparable


                    
                    
                    >=(_:_:)

Creates a Where clause by comparing if a property is greater than or equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.$age >= 20))

Declaration

Swift

public func >= <O, V>(keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : FieldStorableType, V : Comparable


                    
                    
                    >=(_:_:)

Creates a Where clause by comparing if a property is greater than or equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.$age >= 20))

Declaration

Swift

public func >= <O, V>(keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : FieldOptionalType, V : FieldStorableType, V.Wrapped : Comparable

KeyPath where Root: CoreStoreObject, Value: FieldContainer.Relationship


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.$master == john))

Declaration

Swift

public func == <O, D>(keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>, object: D.DestinationObjectType?) -> Where<O> where O : CoreStoreObject, D : FieldRelationshipToOneType


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master == john))

Declaration

Swift

public func == <O, D, R>(keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>, object: R?) -> Where<O> where O : CoreStoreObject, D : FieldRelationshipToOneType, R : ObjectRepresentation, D.DestinationObjectType == R.ObjectType


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.$master != john))

Declaration

Swift

public func != <O, D>(keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>, object: D.DestinationObjectType?) -> Where<O> where O : CoreStoreObject, D : FieldRelationshipToOneType


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master != john))

Declaration

Swift

public func != <O, D, R>(keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>, object: R?) -> Where<O> where O : CoreStoreObject, D : FieldRelationshipToOneType, R : ObjectRepresentation, D.DestinationObjectType == R.ObjectType


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains a value of a property

let dog = dataStack.fetchOne(From<Dog>().where([john, bob, joe] ~= \.$master))

Declaration

Swift

public func ~= <O, D, S>(sequence: S, keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>) -> Where<O> where O : CoreStoreObject, D : FieldRelationshipToOneType, S : Sequence, D.DestinationObjectType == S.Element

KeyPath where Root: CoreStoreObject, Value: ValueContainer.Required


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.nickname == "John"))

Declaration

Swift

public func == <O, V>(keyPath: KeyPath<O, ValueContainer<O>.Required<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.nickname != "John"))

Declaration

Swift

public func != <O, V>(keyPath: KeyPath<O, ValueContainer<O>.Required<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains the value of a property

let dog = dataStack.fetchOne(From<Dog>().where(["Pluto", "Snoopy", "Scooby"] ~= \.nickname))

Declaration

Swift

public func ~= <O, V, S>(sequence: S, keyPath: KeyPath<O, ValueContainer<O>.Required<V>>) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType, V == S.Element, S : Sequence

KeyPath where Root: CoreStoreObject, Value: ValueContainer.Optional


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.nickname == "John"))

Declaration

Swift

public func == <O, V>(keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, value: V?) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.nickname != "John"))

Declaration

Swift

public func != <O, V>(keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, value: V?) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains the value of a property

let dog = dataStack.fetchOne(From<Dog>().where(["Pluto", "Snoopy", "Scooby"] ~= \.nickname))

Declaration

Swift

public func ~= <O, V, S>(sequence: S, keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType, V == S.Element, S : Sequence

KeyPath where Root: CoreStoreObject, Value: ValueContainer.Required


                    
                    
                    <(_:_:)

Creates a Where clause by comparing if a property is less than a value

let person = dataStack.fetchOne(From<Person>().where(\.age < 20))

Declaration

Swift

public func < <O, V>(keyPath: KeyPath<O, ValueContainer<O>.Required<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType, V : Comparable


                    
                    
                    >(_:_:)

Creates a Where clause by comparing if a property is greater than a value

let person = dataStack.fetchOne(From<Person>().where(\.age > 20))

Declaration

Swift

public func > <O, V>(keyPath: KeyPath<O, ValueContainer<O>.Required<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType, V : Comparable


                    
                    
                    <=(_:_:)

Creates a Where clause by comparing if a property is less than or equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.age <= 20))

Declaration

Swift

public func <= <O, V>(keyPath: KeyPath<O, ValueContainer<O>.Required<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType, V : Comparable


                    
                    
                    >=(_:_:)

Creates a Where clause by comparing if a property is greater than or equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.age >= 20))

Declaration

Swift

public func >= <O, V>(keyPath: KeyPath<O, ValueContainer<O>.Required<V>>, value: V) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType, V : Comparable

KeyPath where Root: CoreStoreObject, Value: ValueContainer.Optional


                    
                    
                    <(_:_:)

Creates a Where clause by comparing if a property is less than a value

let person = dataStack.fetchOne(From<Person>().where(\.age < 20))

Declaration

Swift

public func < <O, V>(keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, value: V?) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType


                    
                    
                    >(_:_:)

Creates a Where clause by comparing if a property is greater than a value

let person = dataStack.fetchOne(From<Person>().where(\.age > 20))

Declaration

Swift

public func > <O, V>(keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, value: V?) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType


                    
                    
                    <=(_:_:)

Creates a Where clause by comparing if a property is less than or equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.age <= 20))

Declaration

Swift

public func <= <O, V>(keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, value: V?) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType


                    
                    
                    >=(_:_:)

Creates a Where clause by comparing if a property is greater than or equal to a value

let person = dataStack.fetchOne(From<Person>().where(\.age >= 20))

Declaration

Swift

public func >= <O, V>(keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, value: V?) -> Where<O> where O : CoreStoreObject, V : ImportableAttributeType

KeyPath where Root: CoreStoreObject, Value: RelationshipContainer.ToOne


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master == john))

Declaration

Swift

public func == <O, D>(keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>, object: D) -> Where<O> where O : CoreStoreObject, D : CoreStoreObject


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if a property is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master == john))

Declaration

Swift

public func == <O, D>(keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>, object: D?) -> Where<O> where O : CoreStoreObject, D : CoreStoreObject


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master != john))

Declaration

Swift

public func != <O, D>(keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>, object: D) -> Where<O> where O : CoreStoreObject, D : CoreStoreObject


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if a property is not equal to a value

let dog = dataStack.fetchOne(From<Dog>().where(\.master != john))

Declaration

Swift

public func != <O, D>(keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>, object: D?) -> Where<O> where O : CoreStoreObject, D : CoreStoreObject


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains a value of a property

let dog = dataStack.fetchOne(From<Dog>().where([john, bob, joe] ~= \.master))

Declaration

Swift

public func ~= <O, D, S>(sequence: S, keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>) -> Where<O> where O : CoreStoreObject, D : CoreStoreObject, D == S.Element, S : Sequence

~ where D: NSManagedObject


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

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

Declaration

Swift

public func ~ <O, D, V>(lhs: KeyPath<O, D>, rhs: KeyPath<D, V>) -> Where<O>.Expression<Where<O>.SingleTarget, V> where O : NSManagedObject, D : NSManagedObject, V : AllowedObjectiveCKeyPathValue


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

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

Declaration

Swift

public func ~ <O, D, V>(lhs: KeyPath<O, D?>, rhs: KeyPath<D, V>) -> Where<O>.Expression<Where<O>.SingleTarget, V> where O : NSManagedObject, D : NSManagedObject, V : AllowedObjectiveCKeyPathValue


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

let happyPets = dataStack.fetchAll(From<Pet>().where((\.master ~ \.pets).count() > 1))

Declaration

Swift

public func ~ <O, D, V>(lhs: KeyPath<O, D>, rhs: KeyPath<D, V>) -> Where<O>.Expression<Where<O>.CollectionTarget, V> where O : NSManagedObject, D : NSManagedObject, V : AllowedObjectiveCToManyRelationshipKeyPathValue


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

let happyPets = dataStack.fetchAll(From<Pet>().where((\.master ~ \.pets).count() > 1))

Declaration

Swift

public func ~ <O, D, V>(lhs: KeyPath<O, D?>, rhs: KeyPath<D, V>) -> Where<O>.Expression<Where<O>.CollectionTarget, V> where O : NSManagedObject, D : NSManagedObject, V : AllowedObjectiveCToManyRelationshipKeyPathValue


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

let johnsSonInLaw = dataStack.fetchOne(From<Person>().where((\.spouse ~ \.father ~ \.name) == "John"))

Declaration

Swift

public func ~ <O, D, T, V>(lhs: Where<O>.Expression<T, D>, rhs: KeyPath<D, V>) -> Where<O>.Expression<T, V> where O : NSManagedObject, D : NSManagedObject, T : WhereExpressionTrait, V : AllowedObjectiveCKeyPathValue


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

let johnsSonInLaw = dataStack.fetchOne(From<Person>().where((\.spouse ~ \.father ~ \.name) == "John"))

Declaration

Swift

public func ~ <O, D, T, V>(lhs: Where<O>.Expression<T, D?>, rhs: KeyPath<D, V>) -> Where<O>.Expression<T, V> where O : NSManagedObject, D : NSManagedObject, T : WhereExpressionTrait, V : AllowedObjectiveCKeyPathValue


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

let spouseHasSiblings = dataStack.fetchOne(From<Person>().where((\.spouse ~ \.father ~ \.children).count() > 0))

Declaration

Swift

public func ~ <O, D, T, V>(lhs: Where<O>.Expression<T, D>, rhs: KeyPath<D, V>) -> Where<O>.Expression<Where<O>.CollectionTarget, V> where O : NSManagedObject, D : NSManagedObject, T : WhereExpressionTrait, V : AllowedObjectiveCToManyRelationshipKeyPathValue


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

let spouseHasSiblings = dataStack.fetchOne(From<Person>().where((\.spouse ~ \.father ~ \.children).count() > 0))

Declaration

Swift

public func ~ <O, D, T, V>(lhs: Where<O>.Expression<T, D?>, rhs: KeyPath<D, V>) -> Where<O>.Expression<Where<O>.CollectionTarget, V> where O : NSManagedObject, D : NSManagedObject, T : WhereExpressionTrait, V : AllowedObjectiveCToManyRelationshipKeyPathValue


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

let spousesWithBadNamingSense = dataStack.fetchAll(From<Person>().where((\.spouse ~ \.pets ~ \.name).any() == "Spot"))

Declaration

Swift

public func ~ <O, D, T, C, V>(lhs: Where<O>.Expression<T, C>, rhs: KeyPath<D, V>) -> Where<O>.Expression<Where<O>.CollectionTarget, V> where O : NSManagedObject, D : NSManagedObject, T : WhereExpressionTrait, C : AllowedObjectiveCToManyRelationshipKeyPathValue, V : AllowedObjectiveCKeyPathValue

~ where D: CoreStoreObject


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

let owner = dataStack.fetchOne(From<Pet>().where((\.$master ~ \.$name) == "John"))

Declaration

Swift

public func ~ <O, D, K>(lhs: KeyPath<O, FieldContainer<O>.Relationship<D>>, rhs: KeyPath<D.DestinationObjectType, K>) -> Where<O>.Expression<Where<O>.SingleTarget, K.DestinationValueType> where O : CoreStoreObject, D : FieldRelationshipToOneType, K : KeyPathStringConvertible, D.DestinationObjectType == K.ObjectType


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

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

Declaration

Swift

public func ~ <O, D, K>(lhs: KeyPath<O, RelationshipContainer<O>.ToOne<D>>, rhs: KeyPath<D, K>) -> Where<O>.Expression<Where<O>.SingleTarget, K.DestinationValueType> where O : CoreStoreObject, D : CoreStoreObject, D == K.ObjectType, K : KeyPathStringConvertible


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

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

Declaration

Swift

public func ~ <O, D, T, K>(lhs: Where<O>.Expression<T, D>, rhs: KeyPath<D, K>) -> Where<O>.Expression<T, K.DestinationValueType> where O : CoreStoreObject, D : CoreStoreObject, D == K.ObjectType, T : WhereExpressionTrait, K : KeyPathStringConvertible


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

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

Declaration

Swift

public func ~ <O, D, T, K>(lhs: Where<O>.Expression<T, D?>, rhs: KeyPath<D, K>) -> Where<O>.Expression<T, K.DestinationValueType> where O : CoreStoreObject, D : CoreStoreObject, D == K.ObjectType, T : WhereExpressionTrait, K : KeyPathStringConvertible


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

let happyPets = dataStack.fetchAll(From<Pet>().where((\.$master ~ \.$pets).count() > 1))

Declaration

Swift

public func ~ <O, D, K>(lhs: KeyPath<O, FieldContainer<O>.Relationship<D>>, rhs: KeyPath<D.DestinationObjectType, K>) -> Where<O>.Expression<Where<O>.CollectionTarget, K.DestinationValueType> where O : CoreStoreObject, D : FieldRelationshipToOneType, K : ToManyRelationshipKeyPathStringConvertible, D.DestinationObjectType == K.ObjectType


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

let happyPets = dataStack.fetchAll(From<Pet>().where((\.master ~ \.pets).count() > 1))

Declaration

Swift

public func ~ <O, D, K>(lhs: KeyPath<O, RelationshipContainer<O>.ToOne<D>>, rhs: KeyPath<D, K>) -> Where<O>.Expression<Where<O>.CollectionTarget, K.DestinationValueType> where O : CoreStoreObject, D : CoreStoreObject, D == K.ObjectType, K : ToManyRelationshipKeyPathStringConvertible


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

let happyPets = dataStack.fetchAll(From<Pet>().where((\.master ~ \.pets).count() > 1))

Declaration

Swift

public func ~ <O, D, T, K>(lhs: Where<O>.Expression<T, D>, rhs: KeyPath<D, K>) -> Where<O>.Expression<Where<O>.CollectionTarget, K.DestinationValueType> where O : CoreStoreObject, O == K.ObjectType, D : CoreStoreObject, T : WhereExpressionTrait, K : ToManyRelationshipKeyPathStringConvertible


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

let happyPets = dataStack.fetchAll(From<Pet>().where((\.master ~ \.pets).count() > 1))

Declaration

Swift

public func ~ <O, D, T, K>(lhs: Where<O>.Expression<T, D?>, rhs: KeyPath<D, K>) -> Where<O>.Expression<Where<O>.CollectionTarget, K.DestinationValueType> where O : CoreStoreObject, O == K.ObjectType, D : CoreStoreObject, T : WhereExpressionTrait, K : ToManyRelationshipKeyPathStringConvertible


                    
                    
                    ~(_:_:)

Connects multiple KeyPathStringConvertibles to create a type-safe chain usable in query/fetch expressions

let spousesWithBadNamingSense = dataStack.fetchAll(From<Pet>().where((\.master ~ \.pets ~ \.name).any() == "Spot"))

Declaration

Swift

public func ~ <O, D, T, KC, KV>(lhs: Where<O>.Expression<T, KC>, rhs: KeyPath<D, KV>) -> Where<O>.Expression<Where<O>.CollectionTarget, KV.DestinationValueType> where O : CoreStoreObject, O == KC.ObjectType, D : CoreStoreObject, D == KV.ObjectType, T : WhereExpressionTrait, KC : ToManyRelationshipKeyPathStringConvertible, KV : ToManyRelationshipKeyPathStringConvertible

Where.Expression where V: QueryableAttributeType


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if an expression is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where((\.master ~ \.name) == "John"))

Declaration

Swift

public func == <O, T, V>(lhs: Where<O>.Expression<T, V>, rhs: V) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if an expression is not equal to a value

let dog = dataStack.fetchOne(From<Dog>().where((\.master ~ \.name) != "John"))

Declaration

Swift

public func != <O, T, V>(lhs: Where<O>.Expression<T, V>, rhs: V) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains a value

let dog = dataStack.fetchOne(From<Dog>().where(["John", "Joe"] ~= (\.master ~ \.name))

Declaration

Swift

public func ~= <O, T, V, S>(sequence: S, expression: Where<O>.Expression<T, V>) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType, V == S.Element, S : Sequence

Where.Expression where V: QueryableAttributeType & Comparable


                    
                    
                    <(_:_:)

Creates a Where clause by comparing if an expression is less than a value

let lonelyDog = dataStack.fetchOne(From<Dog>().where((\.master ~ \.pets).count() < 2))

Declaration

Swift

public func < <O, T, V>(lhs: Where<O>.Expression<T, V>, rhs: V) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType, V : Comparable


                    
                    
                    <=(_:_:)

Creates a Where clause by comparing if an expression is less than or equal to a value

let lonelyDog = dataStack.fetchOne(From<Dog>().where((\.master ~ \.pets).count() <= 1)

Declaration

Swift

public func <= <O, T, V>(lhs: Where<O>.Expression<T, V>, rhs: V) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType, V : Comparable


                    
                    
                    >(_:_:)

Creates a Where clause by comparing if an expression is greater than a value

let happyDog = dataStack.fetchOne(From<Dog>().where((\.master ~ \.pets).count() > 1)

Declaration

Swift

public func > <O, T, V>(lhs: Where<O>.Expression<T, V>, rhs: V) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType, V : Comparable


                    
                    
                    >=(_:_:)

Creates a Where clause by comparing if an expression is greater than or equal to a value

let happyDog = dataStack.fetchOne(From<Dog>().where((\.master ~ \.pets).count() >= 2)

Declaration

Swift

public func >= <O, T, V>(lhs: Where<O>.Expression<T, V>, rhs: V) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType, V : Comparable

Where.Expression where V: Optional


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if an expression is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where((\.master ~ \.name) == "John"))

Declaration

Swift

public func == <O, T, V>(lhs: Where<O>.Expression<T, V?>, rhs: V) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType


                    
                    
                    ==(_:_:)

Creates a Where clause by comparing if an expression is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where((\.master ~ \.name) == "John"))

Declaration

Swift

public func == <O, T, V>(lhs: Where<O>.Expression<T, V?>, rhs: V?) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if an expression is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where((\.master ~ \.name) != "John"))

Declaration

Swift

public func != <O, T, V>(lhs: Where<O>.Expression<T, V?>, rhs: V) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType


                    
                    
                    !=(_:_:)

Creates a Where clause by comparing if an expression is equal to a value

let dog = dataStack.fetchOne(From<Dog>().where((\.master ~ \.name) != "John"))

Declaration

Swift

public func != <O, T, V>(lhs: Where<O>.Expression<T, V?>, rhs: V?) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType


                    
                    
                    ~=(_:_:)

Creates a Where clause by checking if a sequence contains a value

let dog = dataStack.fetchOne(From<Dog>().where(["John", "Joe"] ~= (\.master ~ \.name))

Declaration

Swift

public func ~= <O, T, V, S>(sequence: S, expression: Where<O>.Expression<T, V?>) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType, V == S.Element, S : Sequence

Where.Expression where V: Optional


                    
                    
                    <(_:_:)

Creates a Where clause by comparing if an expression is less than a value

let childsPet = dataStack.fetchOne(From<Dog>().where((\.master ~ \.age) < 10))

Declaration

Swift

public func < <O, T, V>(lhs: Where<O>.Expression<T, V?>, rhs: V) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType, V : Comparable


                    
                    
                    <=(_:_:)

Creates a Where clause by comparing if an expression is less than or equal to a value

let childsPet = dataStack.fetchOne(From<Dog>().where((\.master ~ \.age) <= 10))

Declaration

Swift

public func <= <O, T, V>(lhs: Where<O>.Expression<T, V?>, rhs: V?) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType, V : Comparable


                    
                    
                    >(_:_:)

Creates a Where clause by comparing if an expression is greater than a value

let teensPet = dataStack.fetchOne(From<Dog>().where((\.master ~ \.age) > 10))

Declaration

Swift

public func > <O, T, V>(lhs: Where<O>.Expression<T, V?>, rhs: V) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType, V : Comparable


                    
                    
                    >=(_:_:)

Creates a Where clause by comparing if an expression is greater than or equal to a value

let teensPet = dataStack.fetchOne(From<Dog>().where((\.master ~ \.age) >= 10))

Declaration

Swift

public func >= <O, T, V>(lhs: Where<O>.Expression<T, V?>, rhs: V?) -> Where<O> where O : DynamicObject, T : WhereExpressionTrait, V : QueryableAttributeType, V : Comparable