学习主要内容
（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)