Estruturas

Essa estrutura permite a enumeração em estilo de sequência para RLMObjects no Swift por meio de RLMCollection.makeIterator

Essa estrutura permite a enumeração em estilo de sequência para RLMDictionary no Swift por meio RLMDictionary.makeIterator

Uma instância Realm (também conhecida como "um Realm") representa um reconhecimento de data center Realm.

Os domínios podem ser armazenados no disco (consulte init(path:)) ou na memória (consulte Configuration).

Realm as instâncias são armazenadas em cache internamente e a construção de objetos Realm equivalentes (por exemplo, usando o mesmo caminho ou identificador) produz uma sobrecarga limitada.

Se você quiser especificamente garantir que uma instância Realm seja destruída (por exemplo, se você deseja abrir um Realm, verificar algumas propriedades e, em seguida, possivelmente excluir o arquivo Realm e reabri-lo), coloque o código que usa o Realm dentro de um autoreleasepool {} e certifique-se de que você não tenha outras referências fortes para ele.

LinkingObjects é um tipo de contêiner de atualização automática. Representa zero ou mais objetos que estão vinculados ao objeto modelo de sua propriedade por meio de um relacionamento de propriedade.

LinkingObjects pode ser query com os mesmos predicados que List<Element> e Results<Element>.

LinkingObjects sempre reflete o estado atual do Realm na thread atual, inclusive durante transação de escrita na thread atual. A única exceção a isso é ao usar a enumeração for...in , que sempre enumerará sobre os objetos de vinculação que estavam presentes quando a enumeração for iniciada, mesmo que alguns deles sejam excluídos ou modificados para não serem mais vinculados ao objeto de destino durante a enumeração .

LinkingObjects só pode ser usado como propriedade em modelos Object .

Results é um tipo de container de atualização automática no Realm retornado de query de objeto.

Results pode ser consultada com os mesmos predicados de List<Element>, e você pode encadear queries para filtrar ainda mais os resultados da query.

Results sempre refletem o estado atual do Realm na thread atual, inclusive durante transação de escrita na thread atual. A única exceção a isso é ao usar a enumeração for...in , que sempre enumerará os objetos que corresponderam à query quando a enumeração for iniciada, mesmo que alguns deles sejam excluídos ou modificados para serem excluídos pelo filtro durante a enumeração.

Results são avaliados preguiçosamente na primeira vez que são acessados; eles só executam query quando o resultado da query é solicitado. Isso significa que o encadeamento de vários Results temporários para classificar e filtrar seus dados não executa nenhum trabalho desnecessário processando o estado intermediário.

Depois que os resultados são avaliados ou um bloco de notificação é adicionado, os resultados são mantidos atualizados, com o trabalho feito para mantê-los atualizados em um thread em segundo plano, sempre que possível.

As instâncias de resultados não podem ser diretamente instanciadas.

SectionedResults é uma collection segura de tipos que contém ResultsSections individuais como seus elementos. O container é avaliado preguiçosamente, o que significa que, se a collection subjacente tiver sido alterada, ocorrerá um novo cálculo completo das chaves de seção. Uma instância SectionedResults pode ser observada e também está em conformidade com ThreadConfined.

ResultsSection é uma collection que permite acesso a objeto que pertencem a uma determinada chave de seção. A collection é avaliada preguiçosamente, o que significa que, se a collection subjacente tiver sido alterada, ocorrerá um novo cálculo completo das chaves de seção. Uma instância ResultsSection pode ser observada e também está em conformidade com ThreadConfined.

Um RealmCollection apagado por tipo.

Instâncias de RealmCollection operações diretas para uma collection subjacente opaca com o mesmo tipo Element . Esse tipo pode ser usado para escrever código não genérico que pode operar ou armazenar vários tipos de collection do Realm. Ela não tem nenhuma sobrecarga de tempo de execução sobre o uso direto da collection original.

ProjectedCollection é um tipo especial de collection para as propriedade de projeção que deve ser usado quando você deseja projeto um List de Objeto de Realm em uma lista de valores. Você não precisa instanciar esse tipo manualmente. Use-o chamando projectTo em uma propriedade List :

class PersistedListObject: Object {
    @Persisted public var people: List<CommonPerson>
}

class ListProjection: Projection<PersistedListObject> {
    @Projected(\PersistedListObject.people.projectTo.firstName) var strings: ProjectedCollection<String>
}

CollectionElementMapper transforma o objeto de collection reais em um ProjectedCollection.

Por exemplo:

 class Person: Object {
     @Persisted var dogs: List<Dog>
 }
 class PersonProjection: Projection<Person> {
     @Projected(\Person.dogs.projectTo.name) var dogNames: ProjectedCollection<String>
 }

Neste código, a lista de cães de Personserá enviada para a lista de nomes de cães via projectTo

Schema instâncias representam coleções de esquemas de objetos de modelo gerenciados por um Realm.

Ao usar o Realm, as instâncias do Schema permitem realizar migrações e introspecção do esquema do banco de dados.

Mapa de esquemas para collection de tabelas no reconhecimento de data center principal.

Um iterador para uma instância do SectionedResults .

Um iterador para uma instância do Section .

Um SortDescriptor armazena um caminho principal e uma ordem de classificação para uso com sorted(sortDescriptors:). É semelhante ao NSSortDescriptor, mas suporta somente o subconjunto de funcionalidades que pode ser executado com eficiência pelo mecanismo de query do Realm.

Uma assinatura que envolve uma notificação do Realm.

Uma assinatura que envolve um Realm AsyncOpenTask.

Realm event recording can be used to record all reads and writes performed on a Realm and report them to the server. Habilite a gravação de eventos definindo a propriedade eventConfiguration do Realm.Configuration usado para abrir um Realm e, em seguida, obtenha uma instância Events com a propriedade events no Realm.

Parâmetros de configuração para gravação de eventos do Realm.

A ativação da gravação de eventos do Realm é feita com a configuração de Realm.Configuration.eventConfiguration para qualquer EventConfiguration não nulo. Uma configuração inicializada por padrão é válida, mas algumas propriedades podem precisar ser personalizadas.

O uso da gravação de evento do Realm requer a inclusão da collection AuditEvent em seu esquema definido no servidor do aplicativo para o qual você gravará evento. O esquema deve conter os seguintes campos:

• _id: ObjectId
• activity: String
• event: String?
• data: String?
• timestamp: Date Além disso, deve haver um campo String? para cada chave de metadados utilizada.

Tipo de container que mantém o deslocamento do elemento no Mapa.

container para manter uma única entrada de valor-chave em um Mapa. This is used where a tuple cannot be expressed as a generic argument.

Informações sobre uma propriedade específica que foi alterada em uma notificação de alteração Object .

Esta classe representa esquemas de objeto de modelo Realm.

Ao usar o Realm, as instâncias do ObjectSchema permitem realizar migrações e introspecção do esquema do banco de dados.

O esquema de objetos é mapeado para tabelas no reconhecimento de data center principal.

@Persisted é usado para declarar propriedade em subclasses de objeto que devem ser managed pelo Realm.

Exemplo de uso:

class MyModel: Object {
    // A basic property declaration. A property with no
    // default value supplied will default to `nil` for
    // Optional types, zero for numeric types, false for Bool,
    // an empty string/data, and a new random value for UUID
    // and ObjectID.
    @Persisted var basicIntProperty: Int

    // Custom default values can be specified with the
    // standard Swift syntax
    @Persisted var intWithCustomDefault: Int = 5

    // Properties can be indexed by passing `indexed: true`
    // to the initializer.
    @Persisted(indexed: true) var indexedString: String

    // Properties can set as the class's primary key by
    // passing `primaryKey: true` to the initializer
    @Persisted(primaryKey: true) var _id: ObjectId

    // List and set properties should always be declared
    // with `: List` rather than `= List()`
    @Persisted var listProperty: List<Int>
    @Persisted var setProperty: MutableSet<MyObject>

    // LinkingObjects properties require setting the source
    // object link property name in the initializer
    @Persisted(originProperty: "outgoingLink")
    var incomingLinks: LinkingObjects<OtherModel>

    // Properties which are not marked with @Persisted will
    // be ignored entirely by Realm.
    var ignoredProperty = true
}

As propriedades Int, Bool, String, ObjectId e Date podem ser indexadas passando indexed: true para o inicializador. A indexação de uma propriedade melhora o desempenho das query de igualdade nessa propriedade, ao custo de um desempenho de gravação um pouco pior. Nenhuma outra operação usa o índice atualmente.

Uma propriedade pode ser definida como a chave primária da classe passando primaryKey: true para o inicializador. Chaves primárias compostas não são suportadas, e definir mais de uma propriedade como chave primária lançará uma exceção no tempo de execução. Somente a propriedade Int, String, UUID e ObjectId podem se tornar a chave primária e, ao usar o Atlas App Services, a chave primária deve ser denominada _id. A propriedade de chave primária só pode ser mutada em objetos não gerenciados, e modificá-la em um objeto que foi adicionado a um Realm lançará uma exceção.

Opcionalmente, as propriedades podem receber um valor padrão usando a sintaxe Swift padrão. Se nenhum valor padrão for fornecido, um valor será gerado no primeiro acesso: nil para todos os tipos opcionais, zero para tipos numéricos, false para Bool, uma string/dados vazios e um novo valor aleatório para UUID e ObjectId. As propriedades List e MutableSet não devem ser definidas definindo-as para um valor padrão de um List/MutableSet vazio. Isso funcionará, mas resultará em um desempenho pior ao acessar objeto managed por um Realm. Da mesma forma, a propriedade ObjectId não devem ser inicializadas com ObjectID.generate(), pois isso resultará na geração de ObjectId extras e, em seguida, descartados ao ler de um Realm.

Se uma classe tiver pelo menos uma propriedade @Persisted, todas as outras propriedades serão ignoradas pelo Realm. Isso significa que eles não serão persistentes e não poderão ser usados em queries e outras operações, como classificação e agregados, que exigem uma propriedade gerenciada.

@Persisted não pode ser usado em nenhum lugar que não seja como uma propriedade em um objeto ou subclasse EmbeddedObject, e tentar usá-lo em outros locais resultará em erros de tempo de execução.

@Projected é usado para declarar propriedades em protocolos Projection que devem ser gerenciados pelo Realm.

Exemplo de uso:

public class Person: Object {
    @Persisted var firstName = ""
    @Persisted var lastName = ""
    @Persisted var address: Address?
    @Persisted var friends: List<Person>
    @Persisted var reviews: List<String>
}

class PersonProjection: Projection<Person> {
    @Projected(\Person.firstName) var firstName
    @Projected(\Person.lastName.localizedUppercase) var lastNameCaps
    @Projected(\Person.address.city) var homeCity
    @Projected(\Person.friends.projectTo.firstName) var firstFriendsName: ProjectedCollection<String>
}

let people: Results<PersonProjection> = realm.objects(PersonProjection.self)

Informações sobre uma propriedade específica que foi alterada em uma notificação de alteração Object .

Property instâncias representam propriedade managed por um Realm no contexto de um esquema de objetos. Essas propriedade podem ser persistentes em um Arquivo de Realm ou computadas a partir de outros dados no Realm.

Ao usar o Realm, as instâncias de propriedade permitem realizar migrações e introspecção do esquema do banco de dados.

As instâncias de propriedade são mapeadas para colunas no reconhecimento de data center principal.

enumeração representando uma opção para query do String .

Query é uma classe usada para criar predicados de query seguros por tipo.

Com o Query , você tem a capacidade de criar uma expressão de query no estilo Swift que será construída em um NSPredicate. A classe Query não deve ser instanciada diretamente e deve ser usada somente como parâmetro dentro de um fechamento que receba uma expressão de query como argumento. Exemplo:

public func where(_ query: ((Query<Element>) -> Query<Element>)) -> Results<Element>

Você usaria então a função acima da seguinte forma:

let results = realm.objects(Person.self).query {
   $0.name == "Foo" || $0.name == "Bar" && $0.age >= 21
}

Tipos de predicados suportados

Prefixo

• NÃO ! swift let results = realm.objects(Person.self).query { !$0.dogsName.contains("Fido") || !$0.name.contains("Foo") }

Comparações

• Iguais ==
• Não é igual a !=
• Maior que >
• menos de <
• GreaterThanOrEqual >=
• LessThanOrEqual <=
• entre .contains(_ range:)

Collections

• Em .contains(_ element:)
• entre .contains(_ range:)

Map

• @allKeys .keys
• @allValues .values

composto

• e a &&
• ou ||

aggregation de collection

• @avg .avg
• @min .min
• @max .max
• @sum .sum
• @count .count swift let results = realm.objects(Person.self).query { !$0.dogs.age.avg >= 0 || !$0.dogsAgesArray.avg >= 0 }

Outro

• NÃO !
• subquery ($0.fooList.intCol >= 5).count > n

Um iterador para uma instância do RealmCollection .

Um iterador para uma instância do RealmKeyedCollection .

Um iterador para Map<Key, Value> que produz (key: Key, value: Value) pares para cada entrada no mapa.

Um tipo de invólucro de propriedade que instancia um objeto observável.

Crie um Objeto de Realm em um SwiftUI/View, SwiftUI/App ou SwiftUI/Scene aplicando o atributo @StateRealmObject a uma declaração de propriedade e fornecendo um valor inicial que esteja em conformidade com o doc://com.apple.documentation/documentation /Combine/ObservableObject protocolo:

@StateRealmObject var model = DataModel()

O SwiftUI cria uma nova instância do objeto apenas uma vez para cada instância da estrutura que declara o objeto. Quando as propriedades publicadas do objeto de domínio observável são alteradas, o SwiftUI atualiza as partes de qualquer visualização que dependa dessas propriedades. Se não for gerenciada, a propriedade será lida do próprio objeto, caso contrário, será lida do Realm subjacente. As alterações no valor atualizarão a visualização de forma assíncrona:

Text(model.title) // Updates the view any time `title` changes.

Você pode passar o objeto de estado para uma propriedade que tenha o atributo SwiftUI/ObservedRealmObject .

Obtenha um SwiftUI/Binding em uma das propriedades do objeto de estado usando o operador $ . Use uma associação quando quiser criar uma conexão bidirecional com uma das propriedades do objeto. Por exemplo, você pode permitir que um SwiftUI/Toggle controle um valor booleano chamado isEnabled armazenado no modelo:

Toggle("Enabled", isOn: $model.isEnabled)

Isso gravará a propriedade isEnabled modificada no Realm do objeto model .

Um tipo de wrapper de propriedade que representa os resultados de uma query em um Realm.

Os resultados utilizam a configuração de Realm fornecida pelo valor de ambiente realmConfiguration.

Ao contrário da collection de resultados que não são do SwiftUI, o ObservedResults é mutável. As gravações em uma collection ObservedResults executam implicitamente uma transação de escrita. Se você adicionar um objeto ao ObservedResults que a query associada filtraria, o objeto será adicionado ao Realm, mas não incluído nos ObservedResults.

Dado @ObservedResults var v na SwiftUI, $v refere-se a um BoundCollection.

Um tipo de invólucro de propriedade que representa uma collection de resultados seccionada.

Os resultados seccionados usam a configuração de Realm fornecida pelo valor de ambiente realmConfiguration se configuration não estiver definido no inicializador.

Dado @ObservedSectionedResults var v na SwiftUI, $v refere-se a um BoundCollection.

Um tipo de wrapper de propriedade que se inscreve em um Realm observável Object ou List e invalida uma visualização sempre que o objeto observável é alterado.

Um tipo de wrapper de propriedade que inicia um Realm.asyncOpen() para o usuário atual, que abre um Realm de forma assíncrona e notifica os estados para o processo fornecido

Adicione o AsyncOpen ao seu SwiftUI/View ou SwiftUI/App depois que um usuário já estiver conectado ou se um usuário estiver conectado

@AsyncOpen(appId: "app_id", partitionValue: <partition_value>) var asyncOpen

Isso iniciará imediatamente uma operação Realm.asyncOpen() que executará todo o trabalho necessário para colocar o Realm em um estado utilizável. (consulte a documentação do Realm.asyncOpen())

Este invólucro de propriedade publicará estados do processo atual Realm.asyncOpen() , como progresso, erros e um Realm aberto, que pode ser usado para atualizar a visualização

struct AsyncOpenView: View {
    @AsyncOpen(appId: "app_id", partitionValue: <partition_value>) var asyncOpen

    var body: some View {
       switch asyncOpen {
       case .notOpen:
           ProgressView()
       case .open(let realm):
           ListView()
              .environment(\.realm, realm)
       case .error(_):
           ErrorView()
       case .progress(let progress):
           ProgressView(progress)
       }
    }
}

Esse realm aberto pode ser injetado posteriormente na visualização como um valor de ambiente que será usado por nossos wrappers de propriedade para preencher a visualização com dados do Realm aberto

ListView()
   .environment(\.realm, realm)

AutoOpen tentará uma vez abrir um Realm de forma assíncrona, mas, no caso de não haver conexão com a Internet, retornará um realm aberto para o appId e partitionValue fornecidos, que podem ser usados em nossa visualização. Adicione o AutoOpen ao seu SwiftUI/View ou SwiftUI/App, depois que um usuário já estiver conectado ou se um usuário estiver conectado

@AutoOpen(appId: "app_id", partitionValue: <partition_value>, timeout: 4000) var autoOpen

Isso iniciará imediatamente uma operação Realm.asyncOpen() que executará todo o trabalho necessário para colocar o Realm em um estado utilizável. (consulte a documentação do Realm.asyncOpen())

Este invólucro de propriedade publicará estados do processo atual Realm.asyncOpen() , como progresso, erros e um Realm aberto, que pode ser usado para atualizar a visualização

struct AutoOpenView: View {
    @AutoOpen(appId: "app_id", partitionValue: <partition_value>) var autoOpen

    var body: some View {
       switch autoOpen {
       case .notOpen:
           ProgressView()
       case .open(let realm):
           ListView()
              .environment(\.realm, realm)
       case .error(_):
           ErrorView()
       case .progress(let progress):
           ProgressView(progress)
       }
    }
}

Esse realm aberto pode ser injetado posteriormente na visualização como um valor de ambiente que será usado por nossos wrappers de propriedade para preencher a visualização com dados do Realm aberto

ListView()
   .environment(\.realm, realm)

Esse invólucro de propriedades se comporta de forma semelhante a AsyncOpen e, em termos de declaração e uso, é completamente idêntico, mas com a diferença de uma abordagem offline-first.

Um SyncConfiguration representa os parâmetros de configuração dos Realms que pretendem sincronizar com o Atlas App Services.

Estrutura que fornece uma interface para chamar uma função do Atlas App Services com o nome e os argumentos fornecidos.

user.functions.sum([1, 2, 3, 4, 5]) { sum, error in
    guard case let .int64(value) = sum else {
        print(error?.localizedDescription)
    }

    assert(value == 15)
}

O nome do membro dinâmico (sum no exemplo acima) está diretamente associado ao nome da função. O primeiro argumento é o BSONArray dos argumentos a serem fornecidos à função. O segundo e último argumento é o manipulador de conclusão a ser chamado quando a chamada de função estiver concluída. Este manipulador é executado em um DispatchQueue global não principal.

Estrutura que habilita o seguinte açúcar sintático para funções do usuário:

guard case let .int32(sum) = try await user.functions.sum([1, 2, 3, 4, 5]) else {
   return
}

O nome do membro dinâmico (sum no exemplo acima) é fornecido por @dynamicMemberLookup que está diretamente associado ao nome da função.

SyncSubscription é usado para definir uma assinatura Flexible Sync obtida da query de um conjunto de assinaturas, que pode ser usado para ler ou remover/atualizar uma assinatura confirmada.

SubscriptionQuery é usado para definir uma query de assinatura de query nomeada/sem nome, que pode ser adicionada/removida ou atualizada em uma transação de assinatura de escrita.

SyncSubscriptionSet é uma collection de SyncSubscriptions. Este é o ponto de entrada para adicionar e remover SyncSubscriptions.

Esta estrutura habilita a enumeração de estilo de sequência para SyncSubscriptionSet.

Um objeto destinado a ser passado entre threads contendo uma referência segura para threads ao seu objeto confinado pela thread.

Para resolver uma referência segura de thread em um Realm de destino em uma thread diferente, passe para Realm.resolve(_:).