Tipos suportados - Swift SDK

Resultados e resultados seccionados

Os resultados da coleção Swift SDK é uma classe que representa objetos recuperados de queries. Uma coleção de resultados representa os resultados avaliados displicentemente de uma operação de query. Os resultados são imutáveis: você não pode adicionar ou remover elementos da coleção de resultados. Os resultados têm uma query associada que determina seu conteúdo.

O Swift SDK também fornece SectionedResults, uma coleção segura por tipo que mantém ResultsSection como seus elementos. Cada ResultSection é uma coleção de resultados que contém apenas objetos que pertencem a uma determinada chave de seção.

Por exemplo, um aplicativo que inclui uma lista de contatos pode usar SectionedResults para exibir uma lista de contatos dividida em seções, onde cada seção contém todos os contatos cujo nome começa com a letra fornecida. O ResultsSection cuja chave é "L" conteria "Larry", "Liam" e "Lisa".

Coleções como propriedades

O Swift SDK também oferece vários tipos de coleção que você pode usar como propriedades em seu modelo de dados:

1. Lista, uma classe que representa relacionamentos entre muitos em modelos.

2. LinkingObjects, uma classe que representa relacionamentos inversos em modelos.

3. MutableSet, uma classe que representa um relacionamento para muitos.

4. Map, uma classe que representa uma array associativa de pares de valores-chave com chaves exclusivas.

5. AnyRealmCollection, um tipo apagado classe que pode encaminhar chamadas para uma coleção de Realm concreta, como Resultados, Lista ou LinkingObjects.

As coleções estão ativas

Como os objetos ativos, as collections do Realm geralmente são ativas:

• Coleções de resultados em tempo real sempre refletem os resultados atuais da query associada.

• Listas ativas sempre refletem o estado atual do relacionamento na instância de domínio.

Há dois casos em que uma coleção não está ativa:

• A coleção não está gerenciada. Por exemplo, uma propriedade List de um Objeto de domínio que ainda não tenha sido adicionado a um domínio ou que tenha sido copiado de um domínio não está ativo.

• A coleção está congelada.

Combinadas com notificações de coleção, as coleções dinâmicas permitem código limpo e reativo. Por exemplo, suponha que sua visualização exiba os resultados de uma query. Você pode manter uma referência à coleção de resultados em sua classe de exibição e, em seguida, ler a coleção de resultados conforme necessário sem precisar atualizá-la ou validar se ela está atualizada.

Folha de referências de propriedades

Identificadores únicos

ObjectId é um valor exclusivo de 12 bytes específico do MongoDB. O UUID é um valor global exclusivo de 16 bytes. Você pode indexar os dois tipos e usar qualquer um deles como chave primária.

Limitações de tamanho

As propriedades de dados e string não podem ter mais de 16MB. Para armazenar quantidades maiores de dados:

• Divida os dados em pedaços de 16MB, ou

• Armazene dados diretamente no sistema de arquivos e armazene caminhos para os arquivos no domínio.

O Realm apresenta uma exceção de tempo de execução se o seu aplicativo tentar armazenar mais de 16MB em uma única propriedade.

Para evitar limitações de tamanho e um impacto no desempenho, é melhor não armazenar blobs grandes, como arquivos de imagem e vídeo, diretamente em um território. Em vez disso, salve o arquivo em um armazenamento de arquivos e mantenha apenas o local do arquivo e quaisquer metadados relevantes no domínio.

AnyRealmCollection

Para armazenar uma coleção como uma propriedade ou variável sem precisar conhecer o tipo concreto da coleção, o sistema de tipos do Swift requer um wrapper sem tipo, como AnyRealmCollection:

class ViewController {
//    let collection: RealmCollection
//                    ^
//                    error: protocol 'RealmCollection' can only be used
//                    as a generic constraint because it has Self or
//                    associated type requirements
//
//    init<C: RealmCollection>(collection: C) where C.ElementType == MyModel {
//        self.collection = collection
//    }
    let collection: AnyRealmCollection<MyModel>
    init<C: RealmCollection & _ObjcBridgeable>(collection: C) where C.ElementType == MyModel {
        self.collection = AnyRealmCollection(collection)
    }
}

Conjunto mutável

Uma coleção MutableSet representa um relacionamento entre muitos contendo valores distintos. Um MutableSet suporta os seguintes tipos (e suas versões opcionais):

• Bool

• Dados

• Data

• Decimal128

• Duplo

• Flutuador

• Int

• Int8

• Int16

• Int32

• Int64

• Objeto

• ObjectId

• String

• UUID

Como o conjunto de Swift , MutableSet é um tipo genérico que é parametrizado no tipo que armazena. Ao contrário das coleçõesnativas do Swift, Os conjuntos mutáveis de realm são tipos de referência, em oposição aos tipos de valor (structs).

Você só pode chamar os métodos de mutação MutableSets durante uma transação de gravação. Como resultado, o MutableSets é imutável se você abrir o domínio de gerenciamento como um domínio somente para leitura.

Você pode filtrar e classificar um MutableSet com os mesmos predicados de Results. Como outras coleções do Realm, você pode registrar um ouvinte de alterações em um MutableSet.

Por exemplo, um modelo de classe Dog pode conter um MutableSet para citiesVisited:

class Dog: Object {
    @Persisted var name = ""
    @Persisted var currentCity = ""
    @Persisted var citiesVisited: MutableSet<String>
}

Mapa/Dicionário

O Map é uma array associativa que contém pares de valores-chave com chaves exclusivas.

Como o dicionário do Swift , Map é um tipo genérico que é parametrizado em seus tipos de chave e valor. Ao contrário das coleçõesnativas do Swift, Realm Maps são tipos de referência (classes), em oposição aos tipos de valor (structs).

Você pode declarar um Mapa como uma propriedade de um objeto:

class Dog: Object {
    @Persisted var name = ""
    @Persisted var currentCity = ""
    // Map of city name -> favorite park in that city
    @Persisted var favoriteParksByCity: Map<String, String>
}

O Realm não permite o uso de . ou $ caracteres em chaves de mapa. Você pode usar a codificação e a decodificação percentual para armazenar uma chave de mapa que contenha um desses caracteres não permitidos.

// Percent encode . or $ characters to use them in map keys
let mapKey = "New York.Brooklyn"
let encodedMapKey = "New York%2EBrooklyn"

AnyRealmValue

AnyRealmValue é um tipo de propriedade Realm que pode manter diferentes tipos de dados. Os tipos de dados do AnyRealmValue suportados incluem:

• Int

• Flutuador

• Duplo

• Decimal128

• ObjectId

• UUID

• Bool

• Data

• Dados

• String

• Objeto

Este tipo de dados misto é indexável, mas você não pode usá-lo como uma chave primária. Como null é um valor permitido, você não pode declarar um AnyRealmValue como opcional.

class Dog: Object {
    @Persisted var name = ""
    @Persisted var currentCity = ""
    @Persisted var companion: AnyRealmValue
}

Dados geoespaciais

Os dados geoespaciais, ou "geodados", especificam pontos e objetos geométricos na superfície da Terra.

Se você deseja persistir os dados geoespaciais, eles devem estar em conformidade com a especificação GeoJSON.

Para persistir dados geoespaciais com o Swift SDK, crie uma classe incorporada compatível com GeoJSONV que você pode usar em seu modelo de dados.

O objeto embarcado personalizado deve conter os dois campos exigidos pela especificação GeoJSON:

• Um campo de propriedade de tipo String que mapeia para uma propriedade type com o valor de "Point": @Persisted var type: String = "Point"

• Um campo de tipo List<Double> que mapeia para uma propriedade coordinates contendo um par de latitude/longitude: @Persisted private var coordinates: List<Double>

class CustomGeoPoint: EmbeddedObject {
    @Persisted private var type: String = "Point"
    @Persisted private var coordinates: List<Double>
    public var latitude: Double { return coordinates[1] }
    public var longitude: Double { return coordinates[0] }
    convenience init(_ latitude: Double, _ longitude: Double) {
        self.init()
        // Longitude comes first in the coordinates array of a GeoJson document
        coordinates.append(objectsIn: [longitude, latitude])
    }
}

Declarar projeções de tipo

Para usar a projeção de tipo com o Realm:

1. Use um dos protocolos de tipo personalizado do Realm para mapear um tipo de dados não suportado para um tipo compatível com o Realm

2. Use os tipos projetados como propriedades persistentes no modelo de objeto Realm

// Extend a type as a CustomPersistable if if is impossible for
// conversion between the mapped type and the persisted type to fail.
extension CLLocationCoordinate2D: CustomPersistable {
    // Define the storage object that is persisted to the database.
    // The `PersistedType` must be a type that Realm supports.
    // In this example, the PersistedType is an embedded object.
    public typealias PersistedType = Location
    // Construct an instance of the mapped type from the persisted type.
    // When reading from the database, this converts the persisted type to the mapped type.
    public init(persistedValue: PersistedType) {
        self.init(latitude: persistedValue.latitude, longitude: persistedValue.longitude)
    }
    // Construct an instance of the persisted type from the mapped type.
    // When writing to the database, this converts the mapped type to a persistable type.
    public var persistableValue: PersistedType {
        Location(value: [self.latitude, self.longitude])
    }
}
// Extend a type as a FailableCustomPersistable if it is possible for
// conversion between the mapped type and the persisted type to fail.
// This returns nil on read if the underlying column contains nil or
// something that can't be converted to the specified type.
extension URL: FailableCustomPersistable {
    // Define the storage object that is persisted to the database.
    // The `PersistedType` must be a type that Realm supports.
    public typealias PersistedType = String
    // Construct an instance of the mapped type from the persisted type.
    // When reading from the database, this converts the persisted type to the mapped type.
    // This must be a failable initilizer when the conversion may fail.
    public init?(persistedValue: String) { self.init(string: persistedValue) }
    // Construct an instance of the persisted type from the mapped type.
    // When writing to the database, this converts the mapped type to a persistable type.
    public var persistableValue: String { self.absoluteString }
}

extension URL: FailableCustomPersistable {
   // The `PersistedType` cannot be an optional, so this is not a valid
   // conformance to the FailableCustomPersistable protocol.
   public typealias PersistedType = String?
   ...
}
class Club: Object {
   @Persisted var id: ObjectId
   @Persisted var name: String
   // Although the `PersistedType` cannot be optional, you can use the
   // custom-mapped type as an optional in your object model.
   @Persisted var url: URL?
}

Usar Projeção de Tipo no Modelo

Um tipo que esteja em conformidade com um dos protocolos de projeção de tipos pode ser usado com a sintaxe de declaração de propriedade @Persisted introduzida no Swift SDK versão 10.10.0. Não funciona com a sintaxe @objc dynamic.

Você pode usar tipos projetados para:

• Tipos de nível superior

• Versões opcionais do tipo

• Os tipos de uma coleção

Ao utilizar um FailableCustomPersistable como uma propriedade, defina-o como uma propriedade opcional. Quando é opcional, o protocolo FailableCustomPersistable mapeia valores inválidos para nil. Quando é uma propriedade obrigatória, ela é desembrulhada à força. Se você tiver um valor que não possa ser convertido para o tipo projetado, a leitura dessa propriedade lançará uma exceção de falha não envolvida.

class Club: Object {
    @Persisted var id: ObjectId
    @Persisted var name: String
    // Since we declared the URL as a FailableCustomPersistable,
    // it must be optional.
    @Persisted var url: URL?
    // Here, the `location` property maps to an embedded object.
    // We can declare the property as required.
    // If the underlying field contains nil, this becomes
    // a default-constructed instance of CLLocationCoordinate
    // with field values of `0`.
    @Persisted var location: CLLocationCoordinate2D
}
public class Location: EmbeddedObject {
    @Persisted var latitude: Double
    @Persisted var longitude: Double
}

Quando o modelo contém tipos projetados, você pode criar o objeto com valores usando o tipo persistente ou atribuindo às propriedades de campo de um objeto inicializado usando os tipos projetados.

// Initialize objects and assign values
let club = Club(value: ["name": "American Kennel Club", "url": "https://akc.org"])
let club2 = Club()
club2.name = "Continental Kennel Club"
// When assigning the value to a type-projected property, type safety
// checks for the mapped type - not the persisted type.
club2.url = URL(string: "https://ckcusa.com/")!
club2.location = CLLocationCoordinate2D(latitude: 40.7509, longitude: 73.9777)

Projeção de tipo no esquema

Quando você declara que seu tipo está em conformidade com um protocolo de projeção de tipo, você especifica o tipo que deve ser mantido no domínio. Por exemplo, se você mapear um tipo personalizado URL para um tipo persistente de String, uma propriedade URL aparecerá como um String no esquema e o acesso dinâmico à propriedade atuará em cadeias de caracteres.

O esquema não representa diretamente os tipos mapeados. Alterar uma propriedade de seu tipo persistente para seu tipo mapeado, ou vice-versa, não exige uma migração.