Functions

The following functions are available globally.

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

    let person = CoreStore.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 = CoreStore.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 = CoreStore.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
  • Creates a Where clause by comparing if a property is equal to a value

    let person = CoreStore.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 = CoreStore.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 = CoreStore.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
  • Creates a Where clause by comparing if a property is less than a value

    let person = CoreStore.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 = CoreStore.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 = CoreStore.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 = CoreStore.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 a value

    let person = CoreStore.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 = CoreStore.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 = CoreStore.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 = CoreStore.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 equal to a value

    let dog = CoreStore.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 = CoreStore.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 = CoreStore.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 = CoreStore.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 = CoreStore.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 checking if a sequence contains a value of a property

    let dog = CoreStore.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
  • Creates a Where clause by comparing if a property is equal to a value

    let dog = CoreStore.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 = CoreStore.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 checking if a sequence contains a value of a property

    let dog = CoreStore.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 = CoreStore.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 = CoreStore.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 = CoreStore.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
  • Connects multiple DynamicKeyPaths to create a type-safe chain usable in query/fetch expressions

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

    Declaration

    Swift

    public func ~ <D, O, V>(lhs: KeyPath<D, O>, rhs: KeyPath<O, V>) -> Where<D>.Expression<Where<D>.SingleTarget, V> where D : NSManagedObject, O : NSManagedObject, V : AllowedObjectiveCKeyPathValue
  • Connects multiple DynamicKeyPaths to create a type-safe chain usable in query/fetch expressions

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

    Declaration

    Swift

    public func ~ <D, O, V>(lhs: KeyPath<D, O?>, rhs: KeyPath<O, V>) -> Where<D>.Expression<Where<D>.SingleTarget, V> where D : NSManagedObject, O : NSManagedObject, V : AllowedObjectiveCKeyPathValue
  • Connects multiple DynamicKeyPaths to create a type-safe chain usable in query/fetch expressions

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

    Declaration

    Swift

    public func ~ <D, O, V>(lhs: KeyPath<D, O>, rhs: KeyPath<O, V>) -> Where<D>.Expression<Where<D>.CollectionTarget, V> where D : NSManagedObject, O : NSManagedObject, V : AllowedObjectiveCCollectionKeyPathValue
  • Connects multiple DynamicKeyPaths to create a type-safe chain usable in query/fetch expressions

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

    Declaration

    Swift

    public func ~ <D, O, V>(lhs: KeyPath<D, O?>, rhs: KeyPath<O, V>) -> Where<D>.Expression<Where<D>.CollectionTarget, V> where D : NSManagedObject, O : NSManagedObject, V : AllowedObjectiveCCollectionKeyPathValue
  • Connects multiple DynamicKeyPaths to create a type-safe chain usable in query/fetch expressions

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

    Declaration

    Swift

    public func ~ <D, O, T, V>(lhs: Where<D>.Expression<T, O>, rhs: KeyPath<O, V>) -> Where<D>.Expression<T, V> where D : NSManagedObject, O : NSManagedObject, T : WhereExpressionTrait, V : AllowedObjectiveCKeyPathValue
  • Connects multiple DynamicKeyPaths to create a type-safe chain usable in query/fetch expressions

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

    Declaration

    Swift

    public func ~ <D, O, T, V>(lhs: Where<D>.Expression<T, O?>, rhs: KeyPath<O, V>) -> Where<D>.Expression<T, V> where D : NSManagedObject, O : NSManagedObject, T : WhereExpressionTrait, V : AllowedObjectiveCKeyPathValue
  • Connects multiple DynamicKeyPaths to create a type-safe chain usable in query/fetch expressions

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

    Declaration

    Swift

    public func ~ <D, O, T, V>(lhs: Where<D>.Expression<T, O>, rhs: KeyPath<O, V>) -> Where<D>.Expression<Where<D>.CollectionTarget, V> where D : NSManagedObject, O : NSManagedObject, T : WhereExpressionTrait, V : AllowedObjectiveCCollectionKeyPathValue
  • Connects multiple DynamicKeyPaths to create a type-safe chain usable in query/fetch expressions

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

    Declaration

    Swift

    public func ~ <D, O, T, V>(lhs: Where<D>.Expression<T, O?>, rhs: KeyPath<O, V>) -> Where<D>.Expression<Where<D>.CollectionTarget, V> where D : NSManagedObject, O : NSManagedObject, T : WhereExpressionTrait, V : AllowedObjectiveCCollectionKeyPathValue
  • Connects multiple DynamicKeyPaths to create a type-safe chain usable in query/fetch expressions

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

    Declaration

    Swift

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