ArangoDB 学习笔记（2）数据模型

本文转载自查看原文 2018-09-15 14:33 2036

学习主要内容

（1）数据模型

（2）相关的专业术语

（3）建造数据模型时的考虑，以使得在自然数据结构和性能之间平衡。

（4）使用arangosh来进行数据库的操作，权限设定，增加，删除等设置。

（5）如何操作collections和document,增删改查。使用web界面Aardvark来进行操作。

1、相关概念

（1）数据库交互

arangodb是一个服务器数据库，他是用tcp连接，http协议来以json形式传输document。数据库提供了一个REST API来与数据库交互。

有一个web界面可以连接数据库，叫做Aardvark；有一个shell可以连接数据库叫做arangosh。另外还有很多的驱动程序(drivers)供不同大的语言来使用arangodb.所有的这些连接都有http接口，以使得不用再去实现底层的链接功能。

（2）数据模型

存储在arangodb中的文件严格遵循json格式，虽然实际是以二进制存储的（VelocyPack）

document:可以有0个或者多个属性，每个属性都有一个属性值。值可以是原子类型，即数字，字符串，布尔值或空值，也可以是复合类型，即数组或另一个document对象。我们可以任意的嵌套数据结构以代表实际情况。

collections:是有多个documents组成的。一个collection包含0个或多个document.colletions相当于数据库的表，document相当于一条条的记录。只是collections没有自己的列标题，每个documetn可以有不同的结构，都以键值对的形式来包含所有信息。collection并不要求所有的document都有相同的结构。

有两种collections:document collection(在graph中也被称为vertex collections）和edge collection。edge collection也是存储document的，只不过document中有两个特殊的属性，分别是_from和_to

可以用来在documetn中创建连接。通常情况下，在document colleciton当中的两个document会被edge collection中的一个document连接起来。这就是arangodb graph的数据模型。这个数据模型也遵循了一般的图数据模型规则，有方向_from _to，有label来指明关系的性质，只是除此之外，edge在arangodb中还是一个完整的document,可以有document的所有属性定义。

databases:collections必须在数据库中。可以有多个数据库，不同数据库之间的数据是完全隔离的。有一个特殊的数据库_system,这个数据库不可以删除，它可以用来管理数据库用户。

（3）数据提取

Queries:用来增删改查documetns,查询语言使用AQL

cursors:可以用来迭代查询结果，不至于使得太大的查询结果一下加载到内存。

Indexes ：可以用来加速查询。有很多种类型的索引，如hash index,geo index

2、数据库操作

数据库操作都是在arangosh中进行

连接数据库：

arangosh --server.database test

　　注意，在arangodb中仅支持连接一个数据库。因此在命令、脚本中所有的操作要针对同一个数据库。

我们可以使用js来操作数据库。下面的操作有些只能在_system数据库中进行。

获取数据库名称：db._name

require("@arangodb").db._name()

获取数据库id

require("@arangodb").db._id()

获取数据库路径

require("@arangodb").db._path()

检查数据库是否为_system数据库

db._isSystem()

切换使用数据库

db._useDatabase(name)

　　当然当前用户要有操作该数据库的权限，且该数据库存在。

列出所有的数据库

db._databases()

创建数据库

db._createDatabase(name, options, users)

　　注意，创建数据库并没有改变数据库，如果要改变使用过的数据库还是要使用db._useDatabase。现在options还没有作用，因此写为空{}就行了。name指定数据库名称，users指定可以操作该数据库的用户信息。如果不声明users，默认就是root用户，密码为空。

users包含下面一些信息：

username：用户名作为字符串。该属性是必需的。
passwd：用户密码为字符串。如果未指定，则默认为空字符串。
active：一个布尔标志，指示用户帐户是否应该处于活动状态。默认值为true。
extra：带有额外用户信息的可选JSON对象。extra中包含的数据将为用户存储，但ArangoDB不会进一步解释。

用户操作

  require("@arangodb/users").save(username, password, true);
  require("@arangodb/users").update(username, password, true);
  require("@arangodb/users").remove(username);

示例，创建数据库

  db._createDatabase("newDB", {}, [{ username: "newUser", passwd: "123456", active: true}])

删除数据库

db._dropDatabase(name)

　　注意删除数据库尽可以在_system数据库中进行操作。

数据库引擎运行信息

db._engineStats()

使用数据库注意事项：

复制数据库配置在每一个数据库层面，用来记录复制的日志信息。

Foxx应用必须声明一个对应的数据库。

3、collections

在arangodb中每一个collection都必须有唯一的名字和标识符。

连接到collections

db._collection(collection-name)

查看collection的名字

db.collection-name

　　这将要返回一个名字为collection_name的collection，如果没有的话讲创建一个collection_name的collection,这种创建行为是不被推荐的。

创建collection

db._create(collection-name)

同步复制

从arangodb3.0开始，增加了一个在arangodb 集群中自动复制所有数据的功能。每一个collection可以在创建的时候配置‘复制因子’以便能够实现共享。复制因子k的意思是在集群中的k的服务器上保持了k个副本，每个colloction操作自动添加到每个副本上，保持同步。

这是使用leader/followers模型组织的。在所有的时刻，所有的服务器总有一个是leader(正在持有“replicas”）,其他的都是followers，这个配置是被保存在Agence当中。

每个写操作都会被代理自动发送到leader，然后所有的followers都会自动复制该操作，直到所有的复制成功后才会返回写成功状态。leader服务器保存了一个记录，那些followers现在是同步的。如果一个follower由于网络状态掉线了，那么leader将会暂时的删除该follower的状态，以便可以恢复服务。当网路恢复后，follower将会自动连接leader并更新到最新状态。

如果这个leader挂了，那么Agence将会在大约15秒内启动失败处理方案，将其中一个follower提升为leader.其他的followers将会自动和新的leader保持同步，如果原先的leader重新连接了，那么他将会被作为follower自动连接到新leader.通常情况下这个处理方案是协调器自动解决的，用户不会看到任何的错误代码。

显然，这种容错是以增加延迟为代价的。每个写入操作都需要额外的网络往返来进行跟随者的同步复制，但是对所有关注者的所有复制操作都会同时发生。这就是默认复制因子为1的原因，这意味着没有复制

有关如何为集合打开同步复制的详细信息，请参阅“数据库方法db._create(collection-name)”一节中的数据库方法。

（1）collection method

删除操作：drop

collection.drop(options)

　　删除一个collection内的所有index和data.

　　如果想要删除一个_system内的collection，需要在options中指定isSystem 为true

　　在集群中删除一个被其他colletion共享的collection是被禁止的，除非先删除所有的依赖collection

示例：

arangosh> col = db.example;
[ArangoCollection 15512, "example" (type document, status loaded)]
arangosh> col.drop();
arangosh> col;
[ArangoCollection 15512, "example" (type document, status deleted)]
arangosh> col = db._example;
[ArangoCollection 15516, "_example" (type document, status loaded)]
arangosh> col.drop({ isSystem: true });
arangosh> col;
[ArangoCollection 15516, "_example" (type document, status deleted)]

截断操作：truncate

删除collection中的所有documetns但是保持所有的indexes

arangosh> col = db.example;
[ArangoCollection 15674, "example" (type document, status loaded)]
arangosh> col.save({ "Hello" : "World" });
{ 
  "_id" : "example/15678", 
  "_key" : "15678", 
  "_rev" : "_XaSNdV---_" 
}
arangosh> col.count();
1
arangosh> col.truncate();
arangosh> col.count();
0

属性方法：properties

获取或设置collection的properties属性。

返回包含所有集合属性的对象。collection.properties()

waitForSync：如果为true，则只有在将数据同步到磁盘后才会返回创建文档。
journalSize：日志的大小（以字节为单位）。此选项仅对MMFiles存储引擎有意义。
isVolatile：如果为true，则集合数据将仅保留在内存中，ArangoDB不会将数据写入或同步到磁盘。此选项仅对MMFiles存储引擎有意义。
keyOptions（可选）用于密钥生成的其他选项。这是一个包含以下属性的JSON数组（注意：某些属性是可选的）：
- type：用于集合的密钥生成器的类型。
- allowUserKeys：如果设置为true，则允许在文档的_key属性中提供自己的键值。如果设置为false，则密钥生成器将仅负责生成密钥，并且在文档的_key属性中提供自己的密钥值被视为错误。
- increment：自动增量密钥生成器的增量值。不用于其他密钥生成器类型。
- offset：自动增量密钥生成器的初始偏移值。不用于其他密钥生成器类型。
indexBuckets：分割使用哈希表的索引的桶数。默认值为16，此数字必须是2的幂且小于或等于1024.此选项仅对MMFiles存储引擎有意义。

对于非常大的集合，应该增加这一点以避免在最初构建或调整哈希表时长时间暂停，因为存储桶单独调整大小并且最初可以并行构建。例如，64可能是具有100 000 000个文档的集合的合理值。目前，只有边缘索引尊重此值，但在将来的ArangoDB版本中可能会遵循其他索引类型。下次加载集合时将应用更改（见下文）。

在群集设置中，结果还将包含以下属性：

numberOfShards：集合的分片数。
shardKeys：包含用于确定文档的目标分片的文档属性的名称。
replicationFactor：确定每个分片在不同DBServer上保留的副本数。

collection.properties(properties)

更改集合属性。属性必须是具有以下一个或多个属性的对象：

waitForSync：如果为true，则只有在将数据同步到磁盘后才会返回创建文档。
journalSize：日志的大小（以字节为单位）。此选项仅对MMFiles存储引擎有意义。
indexBuckets：如上所述，更改仅在下次加载集合时应用。此选项仅对MMFiles存储引擎有意义。
replicationFactor：更改保留在不同DBServer上的分片副本数，有效值为1-10范围内的整数（仅限集群）

注意：在创建日志或数据文件后，无法更改日志大小。更改此参数只会影响新创建的日记帐。另请注意，您不能将日志大小降低到小于已存储在集合中的最大文档的大小。

注意：创建集合后，某些其他集合属性（如type，isVolatile或keyOptions）无法更改。

示例

arangosh> db.example.properties（）;
{ 
  “doCompact”：true， 
   “journalSize”：33554432， 
   “isSystem”：false， 
   “isVolatile”：false， 
   “waitForSync”：false， 
   “keyOptions”：{ 
     “type”：“traditional”， 
     “allowUserKeys”：true， 
     “ lastValue“：0 
  }， 
  “indexBuckets”：8 
}

arangosh> db.example.properties（{ waitForSync：true }）;
{ 
  “doCompact”：true， 
   “journalSize”：33554432， 
   “isSystem”：false， 
   “isVolatile”：false， 
   “waitForSync”：true， 
   “keyOptions”：{ 
     “type”：“traditional”， 
     “allowUserKeys”：true， 
     “ lastValue“：0 
  }， 
  “indexBuckets”：8 
}

Figures

返回collection的统计信息

collection.figures()，注意显示统计信息，将会把collection加载到内存中。

alive.count：集合的所有数据文件和日志中当前活动文档的数量。此图中未报告仅包含在预写日志中的文档。
alive.size：集合的所有活动文档使用的总大小（以字节为单位）。此图中未报告仅包含在预写日志中的文档。
dead.count：死文件的数量。这包括已删除或替换为较新版本的文档版本。仅在预读日志中包含的已删除或替换的文档不会在此图中报告。
dead.size：所有死文档使用的总大小（以字节为单位）。
dead.deletion：删除标记的总数。仅包含在预写日志中的删除标记未在此图中报告。
datafiles.count：数据文件的数量。
datafiles.fileSize：数据文件的总文件大小（以字节为单位）。
journals.count：日志文件的数量。
journals.fileSize：日志文件的总文件大小（以字节为单位）。
compactors.count：压缩文件的数量。
compactors.fileSize：压缩文件的总文件大小（以字节为单位）。
shapefiles.count：形状文件的数量。仅出于兼容性原因，不推荐使用此值。自ArangoDB 2.0及更高版本以来，该值始终为0。
shapefiles.fileSize：形状文件的总文件大小。仅出于兼容性原因，不推荐使用此值。ArangoDB 2.0及更高版本中的值始终为0。
shapes.count：集合中使用的形状总数。这包括不再使用的形状。此图中不报告预写日志中包含的形状。
shapes.size：所有形状的总大小（以字节为单位）。这包括不再使用的形状。此图中不报告预写日志中包含的形状。
attributes.count：集合中使用的属性总数。注意：该值包括不再使用的属性数据。此图中未报告仅包含在预写日志中的属性。
attributes.size：属性数据的总大小（以字节为单位）。注意：该值包括不再使用的属性数据。此图中未报告仅包含在预写日志中的属性。
indexes.count：为集合定义的索引总数，包括预定义的索引（例如主索引）。
indexes.size：为索引分配的总内存（以字节为单位）。
lastTick：存储在集合日志中的最后一个标记的刻度。如果集合还没有日记，则可能为0。
uncollectedLogfileEntries：此集合的预写日志中尚未传输到日记帐或数据文件的标记数。
documentReferences：JavaScript代码当前包含的数据文件中对文档的引用数。此信息可用于调试压缩和卸载问题。
waitingFor：一个可选的字符串值，包含有关哪个对象类型位于集合清理队列头部的信息。此信息可用于调试压缩和卸载问题。
compactionStatus.time：上次执行集合压缩的时间点。此信息可用于调试压缩问题。
compactionStatus.message：上次为集合运行压缩时执行的操作。此信息可用于调试压缩问题。

注意：仅在结果中不报告存储在预写日志中的收集数据。收集预写日志时，可能会将文档添加到集合的日志和数据文件中，这可能会修改集合的数字。还要注意的是waitingFor，并compactionStatus 在集群中的协调调用时可能是空的。

此外，不报告集合和索引参数JSON文件的文件大小。这些文件通常应该具有每个字节的大小。另请注意，fileSize值以字节为单位报告，并反映逻辑文件大小。某些文件系统可能使用优化（例如稀疏文件），因此实际的物理文件大小有些不同。目录和子目录可能还需要文件系统中的空间，但fileSize结果中不会报告此空间。

这意味着所报告的数字并不能真实地反映集合的实际磁盘使用情况。集合的实际磁盘使用量通常略高于报告的fileSize值的总和。仍然可以将fileSize值的总和用作磁盘使用的下限近似值。

示例

arangosh> db.demo.figures()
{ 
  "indexes" : { 
    "count" : 1, 
    "size" : 32128 
  }, 
  "documentReferences" : 0, 
  "waitingFor" : "-", 
  "alive" : { 
    "count" : 1, 
    "size" : 184 
  }, 
  "dead" : { 
    "count" : 0, 
    "size" : 0, 
    "deletion" : 0 
  }, 
  "compactionStatus" : { 
    "message" : "skipped compaction because collection has no datafiles", 
    "time" : "2018-09-10T19:57:24Z", 
    "count" : 0, 
    "filesCombined" : 0, 
    "bytesRead" : 0, 
    "bytesWritten" : 0 
  }, 
  "datafiles" : { 
    "count" : 0, 
    "fileSize" : 0 
  }, 
  "journals" : { 
    "count" : 1, 
    "fileSize" : 33554432 
  }, 
  "compactors" : { 
    "count" : 0, 
    "fileSize" : 0 
  }, 
  "revisions" : { 
    "count" : 1, 
    "size" : 48192 
  }, 
  "lastTick" : 97, 
  "uncollectedLogfileEntries" : 0 
}

Load

collection.load()将collection加载到内存中。

集群中的collection是始终加载的。

Revision

返回collection发生修改后的id collection.revision()

Path

返回集合的物理路径 collection.path()

在集群中，这个是没有意义的。

Checksum

collection.checksum(withRevisions, withData)

这个checksum会为collection中的所有documents 的keys计算一个hash码。

如果可选参数withRevisions设置为true，则文档的修订ID也包含在哈希计算中。

如果可选参数withData设置为true，则所有用户定义的文档属性也会进行校验和。在校验和中包括文档数据将使计算更慢，但更准确。

得出的hash吗可以校验两个collection是否完全一致。

此方法在集群中不可用

Unload

collection.unload()从内存中卸载collection

在集群中无法卸载

示例

arangosh> col = db.example;
[ArangoCollection 7427，“示例”（类型文档，已加载状态）]
arangosh> col.unload（）;
arangosh> col;
[ArangoCollection 7427，“示例”（类型文档，状态卸载）]

Rename

重命名集合 collection.rename(new-name)

使用新名称重命名集合。该新名称不能已被用于不同的集合。新名称也必须是有效的集合名称。有关有效集合名称的更多信息，请参阅命名约定。

如果由于任何原因重命名失败，则会引发错误。如果重命名集合成功，则还会_graphs在当前数据库中集合内的所有图形定义中重命名集合。

注意：此方法在群集中不可用。

arangosh> c = db.example;
[ArangoCollection 15668, "example" (type document, status loaded)]
arangosh> c.rename("better-example");
arangosh> c;
[ArangoCollection 15668, "better-example" (type document, status loaded)]

Rotate

collection.rotate()使集合的当前日志成为只读数据文件。此方法特定于MMFiles存储引擎，并且在群集中不可用

　（2）Database Methods

获取collection

db._collection(collection-name)

　　示例

arangosh> db._collection("demo");
[ArangoCollection 92, "demo" (type document, status loaded)]

create

db._create(collection-name, properties)
db._create(collection-name, properties, type)
db._createEdgeCollection
db._createDocumentCollection

All Collections

返回所有集合 db._collections()

Collection Name

db.collection-name

4、documents

每个document有唯一的主键在collection中，另外document通过加上collection前缀生成文档句柄（document handle ），在所有的collections中也是全局唯一的。文档的每次修改，都可以通过document revision。任何事务只能看到文档的单个修订。例如：

{
  "_id" : "myusers/3456789",
  "_key" : "3456789",
  "_rev" : "14253647",
  "firstName" : "John",
  "lastName" : "Doe",
  "address" : {
    "street" : "Road To Nowhere 1",
    "city" : "Gotham"
  },
  "hobbies" : [
    {name: "swimming", howFavorite: 10},
    {name: "biking", howFavorite: 6},
    {name: "programming", howFavorite: 4}
  ]
}

　　_id是文档句柄：document handle ，由集合名/_key组成，在整个数据库中是惟一的。

　　_key：是primary key，在collection中是惟一的，可以自定义。

　　_rev:是 document revision 。由于arangodb支持mvvc（多版本并发控制），document可以有多个版本。他是唯一的在document文档中。在3.1版本后它实际是一个时间搓。在一个分片中，保证两个不同的文档修订版具有不同的_rev字符串，即使它们以相同的毫秒写入，并且这些标记是升序的。但请注意，群集中的不同服务器可能具有时钟偏差，因此在不同的分片之间甚至在不同的集合之间，时间戳不能保证具有可比性。混合逻辑时钟功能可以解决此问题：无论何时从群集中的某个服务器A向另一个B发送消息，都可以确保在消息到达后在B上获取的任何时间戳大于任何时间戳。文档修订可用于有条件地查询，更新，替换或删除数据库中的文档。要查找文档的特定修订版，您需要document handle或key以及document revesion。

创建文档时，用户可以指定属性的值。一旦创建了文档_id，_key值就不可变。该_rev值由ArangoDB自动维护。

Multiple Documents in a single Command

一条命令操作多个documents。解决方法使用该数组来代替单个document。多文档操作仅限于单个文档或边缘collection.

collection.all()

　　返回的结果是一个可迭代的所有的documents.您可以使用 toArray，next或hasNext来访问结果。可以使用skip和limit运算符限制结果

示例

arangosh> db.five.save（{ name：“one” }）;
arangosh> db.five.save（{ name：“two” }）;
arangosh> db.five.save（{ name：“three” }）;
arangosh> db.five.save（{ name：“four” }）;
arangosh> db.five.save（{ name：“five” }）;
arangosh> db.five.all（）.limit（2）.toArray（）;

Query by example

collection.byExample(example)

根据示例返回一个documents的迭代器。

示例：

arangosh> db.users.save({ name: "Gerhard" });
{ 
  "_id" : "users/166", 
  "_key" : "166", 
  "_rev" : "_XaSNNa---_" 
}
arangosh> db.users.save({ name: "Helmut" });
{ 
  "_id" : "users/170", 
  "_key" : "170", 
  "_rev" : "_XaSNNa---B" 
}
arangosh> db.users.save({ name: "Angela" });
{ 
  "_id" : "users/173", 
  "_key" : "173", 
  "_rev" : "_XaSNNa---D" 
}
arangosh> var a = db.users.byExample( {"name" : "Angela" } );
arangosh> while (a.hasNext()) print(a.next());
{ 
  "_key" : "173", 
  "_id" : "users/173", 
  "_rev" : "_XaSNNa---D", 
  "name" : "Angela" 
}

First Example

返回符合指定示例的第一个document

arangosh> db.users.firstExample("name", "Angela");
{ 
  "_key" : "15547", 
  "_id" : "users/15547", 
  "_rev" : "_XaSNdGa--D", 
  "name" : "Angela" 
}

Any

collection.any()返回随机的一个document

Count

返回集合中的活动文档数

toArray

collection.toArray()将集合转换为文档数组。切勿在生产环境中使用此调用，因为它基本上会在RAM中创建集合的副本，该副本将根据集合中文档的数量和大小使用资源。

Document

collection.document(object)返回一个document通过id或key

如果从服务器上运行改命令得到的document将是一个不可变对象。如果需要修改，则需要先将结果复制为一个js对象。如果从arangosh或客户端运行，可以不必理会。

collection.document(document-handle)
collection.document(document-key)
collection.document(array)

　　示例

id:

arangosh> db.example.document("example/2873916");
{ 
  "_key" : "2873916", 
  "_id" : "example/2873916", 
  "_rev" : "_XaSNdqi--_" 
}

　或者

arangosh> db.example.document({_id: "example/2873916"});
{ 
  "_key" : "2873916", 
  "_id" : "example/2873916", 
  "_rev" : "_XaSNdoe--_" 
}

key:

arangosh> db.example.document("2873916");
{ 
  "_key" : "2873916", 
  "_id" : "example/2873916", 
  "_rev" : "_XaSNdna--_" 
}

使用数组

arangosh> db.example.document(["2873916","2873917"]);
[ 
  { 
    "_key" : "2873916", 
    "_id" : "example/2873916", 
    "_rev" : "_XaSNdpi--_" 
  }, 
  { 
    "_key" : "2873917", 
    "_id" : "example/2873917", 
    "_rev" : "_XaSNdpi--B" 
  } 
]

Exists

collection.exists(object)检查一个document是否存在。参数同document.返回结果为id,key或者null

使用keys查找

collection.documents(keys)

arangosh> keys = [];
arangosh> for（var i = 0 ; i < 10 ; ++ i）{
........> db.example.insert（{_ key：“test” + i，value：i}）;
........> keys.push（“test” + i）;
........>}
arangosh> db.example.documents（keys）;

Insert

collection.insert(data)

根据给定的data在collection中创建新的document.如果不指定key，那么将自动生成key,和rev.如果指定key，文件中必须不能由key .

该方法将要返回一个docuemnt

collection.insert(data, options)

options必须是对象

waitForSync：即使在整个集合中禁用了waitForSync标志的情况下，也可以强制将文档创建操作同步到磁盘。因此，waitForSync选项可用于强制仅特定操作的同步。要使用它，请将waitForSync参数设置为true。如果未指定waitForSync参数或将其设置为false，则应用集合的默认 waitForSync行为。该waitForSync参数不能用于关闭有一个默认集合同步waitForSync的价值真。
silent：如果此标志设置为true，则该方法不返回任何输出。
returnNew：如果这个标志被设置为真实，完整的新文档的属性下的输出返回新。

collection.insert(array)

collection.insert(array, options)

这两个变体允许对整个参数数组执行操作。行为就像是分别在数组的所有成员上调用insert，并且所有结果都在数组中返回

示例

arangosh> db.example.insert({ Hello : "World" });
{ 
  "_id" : "example/15885", 
  "_key" : "15885", 
  "_rev" : "_XaSNdjG--_" 
}
arangosh> db.example.insert({ Hello : "World" }, {waitForSync: true});
{ 
  "_id" : "example/15889", 
  "_key" : "15889", 
  "_rev" : "_XaSNdjG--B" 
}

arangosh> db.example.insert（[{ Hello：“World” }，{ Hello：“there” }]） [  {  “_id”：“example / 15865”， “_ key”：“15865”， “_ rev”：“_ XaSNdhi --_”  }，  {  “_id”：“example / 15869”， “_ key”：“15869”， “_ rev”：“_ XaSNdhi - B”  }  ] arangosh> db.example.insert（[{ Hello：“World” }，{}]，{ waitForSync：true }）; [  {  “_id”：“example / 15873”， “_ key”：“15873”， “_ rev”：“_ XaSNdhi - D”  }，  {  “_id”：“example / 15877”， “_ key”：“15877”， “_ rev”：“_ XaSNdhm --_”  }  ]

Replace

collection.replace(selector, data)

selector可以是key或者id，或者数组,data是要修改的数据

返回一个document

collection.replace(selector, data, options)

waitForSync：即使在整个集合中禁用了waitForSync标志的情况下，也可以强制将文档创建操作同步到磁盘。因此，waitForSync选项可用于强制仅特定操作的同步。要使用它，请将waitForSync参数设置为true。如果未指定waitForSync参数或将其设置为false，则应用集合的默认 waitForSync行为。该waitForSync参数不能用于关闭有一个默认集合同步waitForSync的价值真。
overwrite：如果此标志设置为true，则忽略选择器中的_rev属性。
returnNew：如果这个标志被设置为真实，完整的新文档的属性下的输出返回新。
returnOld：如果此标志设置为true，则在属性old下的输出中返回文档的完整先前版本。
silent：如果此标志设置为true，则不返回任何输出。

arangosh> a1 = db.example.insert({ a : 1 }); { "_id" : "example/15996", "_key" : "15996", "_rev" : "_XaSNdvu--_" } arangosh> a2 = db.example.replace(a1, { a : 2 }); { "_id" : "example/15996", "_key" : "15996", "_rev" : "_XaSNdvy--_", "_oldRev" : "_XaSNdvu--_" } arangosh> a3 = db.example.replace(a1, { a : 3 }); [ArangoError 1200: precondition failed]

使用id

arangosh> a1 = db.example.insert({ a : 1 });
{ 
  "_id" : "example/3903045", 
  "_key" : "3903045", 
  "_rev" : "_XaSNdw6--B" 
}
arangosh> a2 = db.example.replace("example/3903044", { a : 2 });
{ 
  "_id" : "example/3903044", 
  "_key" : "3903044", 
  "_rev" : "_XaSNdw6--D", 
  "_oldRev" : "_XaSNdw6--_" 
}

Update

collection.update(selector, data)

collection.update(selector, data, options)

示例

arangosh> a1 = db.example.insert({"a" : 1});
arangosh> a2 = db.example.update(a1, {"b" : 2, "c" : 3});
arangosh> a3 = db.example.update(a1, {"d" : 4});
arangosh> a4 = db.example.update(a2, {"e" : 5, "f" : 6 });
arangosh> db.example.document(a4);
arangosh> a5 = db.example.update(a4, {"a" : 1, c : 9, e : 42 });
arangosh> db.example.document(a5);

Remove

collection.remove(selector)

删除一个document，返回_id, _key and _rev

collection.remove(selector, options)

waitForSync：即使在整个集合中禁用了waitForSync标志的情况下，也可以强制将文档创建操作同步到磁盘。因此，waitForSync选项可用于强制仅特定操作的同步。要使用它，请将waitForSync参数设置为true。如果未指定waitForSync参数或将其设置为false，则应用集合的默认 waitForSync行为。该waitForSync参数不能用于关闭有一个默认集合同步waitForSync的价值真。
overwrite：如果此标志设置为true，则忽略选择器中的_rev属性。
returnOld：如果此标志设置为true，则在属性old下的输出中返回文档的完整先前版本。
silent：如果此标志设置为true，则不返回任何输出。

collection.removeByKeys(keys)

按key删除

该方法将返回一个对象，该对象包含已删除的子属性中已删除文档的数量，以及被忽略的子属性中未删除/忽略的文档的数量。

arangosh> keys = [ ];
[ ]
arangosh> for (var i = 0; i < 10; ++i) {
........>   db.example.insert({ _key: "test" + i, value: i });
........>   keys.push("test" + i);
........> }
arangosh> db.example.removeByKeys(keys);
{ 
  "removed" : 10, 
  "ignored" : 0 
}

Remove By Example

collection.removeByExample(example)

collection.removeByExample(document, waitForSync)

collection.removeByExample(document, waitForSync, limit)

arangosh> db.example.removeByExample（{ Hello：“world” }）;

Replace By Example

arangosh> db.example.save（{ Hello：“world” }）;
{ 
  “_id”：“example / 6595”， 
   “_ key”：“6595”， 
   “_ rev”：“_ XaSNN7u --_” 
}
arangosh> db.example.replaceByExample（{ Hello：“world” }，{ Hello：“mars” }，false，5）;
1

Update By Example

collection.updateByExample(example, newValue)

arangosh> db.example.save({ Hello : "world", foo : "bar" });
{ 
  "_id" : "example/6608", 
  "_key" : "6608", 
  "_rev" : "_XaSNN9K--_" 
}
arangosh> db.example.updateByExample({ Hello: "world" }, { Hello: "foo", World: "bar" }, false);
1
arangosh> db.example.byExample({ Hello: "foo" }).toArray()
[ 
  { 
    "_key" : "6608", 
    "_id" : "example/6608", 
    "_rev" : "_XaSNN9O--_", 
    "Hello" : "foo", 
    "foo" : "bar", 
    "World" : "bar" 
  } 
]

Collection type

collection.type()

Returns the type of a collection. Possible values are:

2: document collection
3: edge collection

Get the Version of ArangoDB

db._version()

Edges

arangosh> db._create("vertex");
[ArangoCollection 7451, "vertex" (type document, status loaded)]
arangosh> db._createEdgeCollection("relation");
[ArangoCollection 7454, "relation" (type edge, status loaded)]
arangosh> var myGraph = {};
arangosh> myGraph.v1 = db.vertex.insert({ name : "vertex 1" });
{ 
  "_id" : "vertex/7458", 
  "_key" : "7458", 
  "_rev" : "_XaSNOXe--_" 
}
arangosh> myGraph.v2 = db.vertex.insert({ name : "vertex 2" });
{ 
  "_id" : "vertex/7462", 
  "_key" : "7462", 
  "_rev" : "_XaSNOXe--B" 
}
arangosh> myGraph.e1 = db.relation.insert(myGraph.v1, myGraph.v2,
........> { label : "knows"});
{ 
  "_id" : "relation/7465", 
  "_key" : "7465", 
  "_rev" : "_XaSNOXe--D" 
}
arangosh> db._document(myGraph.e1);
{ 
  "_key" : "7465", 
  "_id" : "relation/7465", 
  "_from" : "vertex/7458", 
  "_to" : "vertex/7462", 
  "_rev" : "_XaSNOXe--D", 
  "label" : "knows" 
}
arangosh> db.relation.edges(myGraph.e1._id);
[ ]

　　from不包含在内，to包含在内，因此查找from为空

edge-collection.inEdges(vertex)

可以检查是否在edges中

arangosh> db._create("vertex");
[ArangoCollection 7472, "vertex" (type document, status loaded)]
arangosh> db._createEdgeCollection("relation");
[ArangoCollection 7475, "relation" (type edge, status loaded)]
arangosh> myGraph.v1 = db.vertex.insert({ name : "vertex 1" });
{ 
  "_id" : "vertex/7479", 
  "_key" : "7479", 
  "_rev" : "_XaSNOaC--_" 
}
arangosh> myGraph.v2 = db.vertex.insert({ name : "vertex 2" });
{ 
  "_id" : "vertex/7483", 
  "_key" : "7483", 
  "_rev" : "_XaSNOaC--B" 
}
arangosh> myGraph.e1 = db.relation.insert(myGraph.v1, myGraph.v2,
........> { label : "knows"});
{ 
  "_id" : "relation/7486", 
  "_key" : "7486", 
  "_rev" : "_XaSNOaG--_" 
}
arangosh> db._document(myGraph.e1);
{ 
  "_key" : "7486", 
  "_id" : "relation/7486", 
  "_from" : "vertex/7479", 
  "_to" : "vertex/7483", 
  "_rev" : "_XaSNOaG--_", 
  "label" : "knows" 
}
arangosh> db.relation.inEdges(myGraph.v1._id);
[ ]
arangosh> db.relation.inEdges(myGraph.v2._id);
[ 
  { 
    "_key" : "7486", 
    "_id" : "relation/7486", 
    "_from" : "vertex/7479", 
    "_to" : "vertex/7483", 
    "_rev" : "_XaSNOaG--_", 
    "label" : "knows" 
  } 
]

edge-collection.outEdges(vertex)

和inEdges正好相反

Database Methods

db._document(object)

db._exists(object)

db._replace(selector, data)

db._update(selector, data)

db._remove(selector)

免责声明！

本站转载的文章为个人学习借鉴使用，本站对版权不负任何法律责任。如果侵犯了您的隐私权益，请联系本站邮箱yoyou2525@163.com删除。

猜您在找 【TP5学习笔记一】数据模型操作 MVC笔记用Model创建数据模型数据中台学习笔记-元数据管理，指标管理，数据模型 Nacos数据模型数据模型分类 Hive之数据模型 ArangoDB 学习笔记（1）入门篇概念数据模型到逻辑数据模型的转化（转） laravel 数据模型方法 MySQL：常用的数据模型

ArangoDB 学习笔记 （2）数据模型