Docs 菜单
Docs 主页
/
MongoDB 阿特拉斯
/
Atlas Device SDKs
/
Swift SDK
/
模型数据

使用 Device Sync 对数据建模 - Swift SDK

在此页面上

  • Realm 对象模型
  • JSON schema
  • Realm 关系
  • 对一关系
  • 对多关系
  • 反向关系
  • 嵌入式对象模型
  • 创建对象模型和模式

Realm 对象模型

To define a Realm object, derive a class from Object. The models that you define each map to their own collection in MongoDB Atlas. In this example, both Dog and Person would map to separate collections in MongoDB Atlas.

class Dog: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   @Persisted var age = 0
}
class Person: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
}

JSON schema

当 Atlas App Services 中有相应的模式时，Device Sync 在同步到 Atlas 时会自动将 Realm Swift 数据类型转换为 BSON。 当客户端设备通过 Device Sync 从 App Services 向下同步数据时，SDK 会将 BSON 转换回 Swift 对象。 如果您通过直接访问 MongoDB Atlas 数据而不是使用 Device Sync 来同步数据来查询这些对象，则会获得 BSON 数据类型。 MongoDB 数据访问不会自动映射到 Swift 对象等效项。

App Services 中的 Dog 模式
{
  "title": "Dog",
  "bsonType": "object",
  "required": [
    "_id"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    },
    "age": {
      "bsonType": "long"
    }
  }
}
App Services 中的人员模式
{
  "title": "Person",
  "bsonType": "object",
  "required": [
    "_id"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    }
  }
}

Realm 关系

对一关系

使用上述示例中的对象，考虑Person可以有一个Dog的情况。 我们可以向Person模型添加一个dog属性，该属性是指向Dog对象的可选链接。 对一关系必须是可选的。

class Dog: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   @Persisted var age = 0
}
class Person: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   // To-one relationship
   @Persisted var dog: Dog?
}

JSON schema

在 App Services 模式中，我们看到新属性转换为字段dog 。 该字段不在required数组中，因为它是可选属性。 其类型为objectId DogDog，链接到单独的collection集合中的特定对象 。ObjectId 是Dog模型的主键，因此它是链接两个对象的字段。

与狗具有一对一关系的人
{
  "title": "Person",
  "bsonType": "object",
  "required": [
    "_id"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "dog": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    }
  }
}

Dog模式保持不变。 由于这是一种对一关系，因此是一种单向关系； Dog与Person没有关系。

提示

另请参阅：

有关对一关系的更多信息，请参阅：对一关系。

对多关系

使用上述示例中的对象，考虑一个Person可以有多个犬的情况。 我们可以将一个dogs属性添加到Person模型中，该模型是Dog对象的列表。 如果此人没有狗，则这是一个空列表。 当此人养狗时，我们可以创建新的狗对象并将它们附加到此人的dogs列表中。

class Dog: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   @Persisted var age = 0
}
class Person: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   // To-many relationship - a person can have many dogs
   @Persisted var dogs: List<Dog>
}

JSON schema

在 App Services 模式中，我们看到新属性转换为字段dogs 。 该字段的类型是数组，数组中项目的类型为objectId 。 这是因为我们将Dog模型上的主键定义为objectId 。 该字段是与Dog Person对象相关的所有 对象的主键数组。

与 Dog 具有对多关系的 Person
{
  "title": "Person",
  "bsonType": "object",
  "required": [
    "_id"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    },
    "dogs": {
      "bsonType": "array",
      "items": {
        "bsonType": "objectId"
      }
    }
  }
}

提示

另请参阅：

有关对多关系的更多信息，请参阅：对多关系。

反向关系

使用上述示例中的对象，考虑Dog对象与Person对象具有反向关系的情况。

class Dog: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   @Persisted var age = 0
   // The backlink to the `Person` who has this `Dog`.
   @Persisted(originProperty: "dogs") var person: LinkingObjects<Person>
}
class Person: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   // To-many relationship - a person can have many dogs
   @Persisted var dogs: List<Dog>
}

JSON schema

在 App Services 模式中，我们发现表示与Dog模型中的Person反向关系的person属性不存在。 您不能直接设置反向关系的值，并且 Atlas 中不存在该关系。 但是，Realm 会根据您的 Realm 对象模型在客户端应用程序中为您派生并更新这些关系。

与人有反向关系的狗
{
  "title": "Dog",
  "bsonType": "object",
  "required": [
    "_id"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    },
    "age": {
      "bsonType": "long"
    }
  }
}

提示

另请参阅：

有关反向关系的更多信息，请参阅：反向关系。

嵌入式对象模型

当您使用 Realm Swift SDK 定义嵌入式对象时，您会从EmbeddedObject派生一个类。 您可以像定义关系一样从父对象类型引用嵌入式对象类型：

class Person: Object {
    @Persisted(primaryKey: true) var id = 0
    @Persisted var name = ""
    // To-many relationship - a person can have many dogs
    @Persisted var dogs: List<Dog>
    // Inverse relationship - a person can be a member of many clubs
    @Persisted(originProperty: "members") var clubs: LinkingObjects<DogClub>
    // Embed a single object.
    // Embedded object properties must be marked optional.
    @Persisted var address: Address?
    convenience init(name: String, address: Address) {
        self.init()
        self.name = name
        self.address = address
    }
}
class DogClub: Object {
    @Persisted var name = ""
    @Persisted var members: List<Person>
    // DogClub has an array of regional office addresses.
    // These are embedded objects.
    @Persisted var regionalOfficeAddresses: List<Address>
    convenience init(name: String, addresses: [Address]) {
        self.init()
        self.name = name
        self.regionalOfficeAddresses.append(objectsIn: addresses)
    }
}
class Address: EmbeddedObject {
    @Persisted var street: String?
    @Persisted var city: String?
    @Persisted var country: String?
    @Persisted var postalCode: String?
}

JSON schema

嵌入式对象映射到父类型模式中的嵌入式文档。此行为与常规 Realm 对象不同，后者映射到自己的 MongoDB 集合。

{
  "title": "Person",
  "bsonType": "object",
  "required": ["id"],
  "properties": {
    "id": { "bsonType": "int" },
    "name": { "bsonType": "string" },
    "dogs": {
      "bsonType": "array",
      "items": {
        "bsonType": "objectId"
      }
    },
    "address": {
      "title": "Address",
      "bsonType": "object",
      "properties": {
        "street": { "bsonType": "string" },
        "city": { "bsonType": "string" },
        "country": { "bsonType": "string" },
        "postalCode": { "bsonType": "string" }
      }
    }
  }
}
{
  "title": "DogClub",
  "bsonType": "object",
  "required": ["_id", "name", "addresses"],
  "properties": {
    "_id": "objectId",
    "name": { "bsonType": "string" },
    "members": {
      "bsonType": "array",
      "items": {
        "bsonType": "objectId"
      }
    },
    "addresses": {
      "bsonType": "array",
      "items": {
        "title": "Address",
        "bsonType": "object",
        "properties": {
          "street": { "bsonType": "string" },
          "city": { "bsonType": "string" },
          "country": { "bsonType": "string" },
          "postalCode": { "bsonType": "string" }
        }
      }
    }
  }
}

创建对象模型和模式

要在 Atlas 中的 SDK 对象模型和 BSON 数据之间进行映射，您必须在 App Services中具有与您的SDK 对象模型匹配的模式。有几种方法可以生成匹配的模式和对象模型：

  • 在客户端应用程序中创建对象模型，并从中生成 App Services 模式。

  • 在 App Services 中创建模式，并从中生成 Realm 对象模型。

如果正在开发新的客户端应用程序，您可能希望迭代客户端应用程序中的数据模型。 在 中启用 开发模式 ，让后端根据客户端对象模型推断和更新模式。Atlas App Services开发模式不适用于重大模式更改，因此对 SDK 数据模型进行重大更改时，必须从服务器中删除现有模式。

如果您正在开发一个客户端应用程序，并且该应用程序需要处理 Atlas 中已存在的数据，则可以根据该数据生成模式。然后，您可以从服务器端模式生成 SDK 对象模型。

后退

更改对象模型

来年

CRUD

在此页面上