- OrientDB 教程
- OrientDB - 首页
- OrientDB - 概述
- OrientDB - 安装
- OrientDB - 基本概念
- OrientDB - 数据类型
- OrientDB - 控制台模式
- OrientDB 数据库命令
- OrientDB - 创建数据库
- OrientDB - 修改数据库
- OrientDB - 备份数据库
- OrientDB - 恢复数据库
- OrientDB - 连接数据库
- OrientDB - 断开数据库连接
- OrientDB - 数据库信息
- OrientDB - 列出数据库
- OrientDB - 冻结数据库
- OrientDB - 解冻数据库
- OrientDB - 配置数据库
- OrientDB - 导出数据库
- OrientDB - 导入数据库
- OrientDB - 提交数据库
- OrientDB - 回滚数据库
- OrientDB - 优化数据库
- OrientDB - 删除数据库
- OrientDB 记录命令
- OrientDB - 插入记录
- OrientDB - 显示记录
- OrientDB - 加载记录
- OrientDB - 重新加载记录
- OrientDB - 导出记录
- OrientDB - 更新记录
- OrientDB - 清空记录
- OrientDB - 删除记录
- OrientDB 类命令
- OrientDB - 创建类
- OrientDB - 修改类
- OrientDB - 清空类
- OrientDB - 删除类
- OrientDB 集群命令
- OrientDB - 创建集群
- OrientDB - 修改集群
- OrientDB - 清空集群
- OrientDB - 删除集群
- OrientDB 属性命令
- OrientDB - 创建属性
- OrientDB - 修改属性
- OrientDB - 删除属性
- OrientDB 顶点命令
- OrientDB - 创建顶点
- OrientDB - 移动顶点
- OrientDB - 删除顶点
- OrientDB 边命令
- OrientDB - 创建边
- OrientDB - 更新边
- OrientDB - 删除边
- OrientDB 高级概念
- OrientDB - 函数
- OrientDB - 序列
- OrientDB - 索引
- OrientDB - 事务
- OrientDB - 钩子
- OrientDB - 缓存
- OrientDB - 日志
- OrientDB - 性能调优
- OrientDB - 升级
- OrientDB - 安全性
- OrientDB - Studio
- OrientDB 接口
- OrientDB - Java 接口
- OrientDB - Python 接口
- OrientDB 有用资源
- OrientDB 快速指南
- OrientDB - 有用资源
- OrientDB - 讨论
OrientDB 快速指南
OrientDB - 概述
OrientDB 是一个开源 NoSQL 数据库管理系统。NoSQL 数据库提供了一种存储和检索非关系型数据的机制，这些数据指的是表格数据以外的数据，例如文档数据或图数据。NoSQL 数据库越来越多地用于大数据和实时 Web 应用程序。NoSQL 系统有时也被称为“不仅仅是 SQL”，以强调它们可能支持类似 SQL 的查询语言。
OrientDB 也属于 NoSQL 家族。OrientDB 是一个第二代分布式图数据库，在一个产品中兼具文档的灵活性和 Apache 2 许可证的开源特性。在 OrientDB 之前，市场上已经存在一些 NoSQL 数据库，其中之一是 MongoDB。
MongoDB vs OrientDB
MongoDB 和 OrientDB 包含许多共同的功能，但其引擎从根本上有所不同。MongoDB 是纯粹的文档数据库，而 OrientDB 是一个混合的文档和图引擎数据库。
| 特性 | MongoDB | OrientDB |
|---|---|---|
| 关系 | 使用 RDBMS JOIN 来创建实体之间的关系。它具有较高的运行时成本，并且在数据库规模增加时无法扩展。 | 像关系数据库一样嵌入和连接文档。它使用来自图数据库世界的直接、超快速的链接。 |
| 获取计划 | 代价高昂的 JOIN 操作。 | 轻松返回包含互连文档的完整图。 |
| 事务 | 不支持 ACID 事务，但支持原子操作。 | 支持 ACID 事务以及原子操作。 |
| 查询语言 | 拥有基于 JSON 的自身语言。 | 查询语言基于 SQL。 |
| 索引 | 对所有索引使用 B 树算法。 | 支持三种不同的索引算法，以便用户可以获得最佳性能。 |
| 存储引擎 | 使用内存映射技术。 | 使用存储引擎名称 LOCAL 和 PLOCAL。 |
OrientDB 是第一个多模型开源 NoSQL DBMS，它将图的强大功能和文档的灵活性能结合到一个可扩展的高性能操作数据库中。
OrientDB - 安装
OrientDB 安装文件有两种版本：
社区版 - OrientDB 社区版由 Apache 根据 0.2 许可证发布，作为一个开源项目。
企业版 - OrientDB 企业版作为一个专有软件发布，它构建在社区版的基础之上。它是社区版的扩展。
本章解释 OrientDB 社区版的安装过程，因为它是一个开源项目。
先决条件
社区版和企业版都可以在任何实现了 Java 虚拟机 (JVM) 的操作系统上运行。OrientDB 需要 Java 1.7 或更高版本。
请按照以下步骤将 OrientDB 下载并安装到您的系统中。
步骤 1 - 下载 OrientDB 二进制安装文件
OrientDB 带有内置安装文件，用于在您的系统上安装数据库。它为不同的操作系统提供不同的预编译二进制包（压缩包或 tar 包）。您可以从 下载 OrientDB 链接下载 OrientDB 文件。
下面的截图显示了 OrientDB 的下载页面。您可以通过单击相应操作系统图标来下载压缩包或 tar 包。
下载后，您将在您的下载文件夹中获得二进制包。
步骤 2 - 解压并安装 OrientDB
以下是针对不同操作系统的解压和安装 OrientDB 的过程。
在 Linux 中
下载后，您将在下载文件夹中获得orientdb-community-2.1.9.tar.gz文件。您可以使用以下命令解压 tar 包。
$ tar –zxvf orientdb-community-2.1.9.tar.gz
您可以使用以下命令将所有 OrientDB 库文件从orientdbcommunity-2.1.9移动到/opt/orientdb/目录。这里我们使用超级用户命令 (sudo)，因此您必须提供超级用户密码才能执行以下命令。
$ sudo mv orientdb-community-2.1.9 /opt/orientdb
您可以使用以下命令注册orientdb命令和 Orient 服务器。
$ export ORIENTDB_HoME = /opt/orientdb $ export PATH = $PATH:$ORIENTDB_HOME/bin
在 Windows 中
下载后，您将在下载文件夹中获得orientdb-community-2.1.9.zip文件。使用 zip 解压工具解压 zip 文件。
将解压后的文件夹移动到C:\目录。
创建两个环境变量 ORIENTDB_HOME 和 PATH，并使用以下值。
ORIENT_HOME = C:\orientdb-community-2.1.9 PATH = C:\orientdb-community-2.1.9\bin
步骤 3 - 将 OrientDB 服务器配置为服务
按照上述步骤，您可以使用 OrientDB 的桌面版本。您可以通过以下步骤将 OrientDB 数据库服务器启动为服务。具体步骤因操作系统而异。
在 Linux 中
OrientDB 提供了一个名为orientdb.sh的脚本文件来运行数据库作为守护进程。您可以在 OrientDB 安装目录的 bin/ 目录中找到它，即 $ORIENTDB_HOME/bin/orientdb.sh。
在运行脚本文件之前，您必须编辑orientdb.sh文件以定义两个变量。一个是ORIENTDB_DIR，它定义安装目录的路径（/opt/orientdb），另一个是ORIENTDB_USER，它定义您希望以其身份运行 OrientDB 的用户名，如下所示。
ORIENTDB_DIR = "/opt/orientdb" ORIENTDB_USER = "<username you want to run OrientDB>"
使用以下命令将orientdb.sh文件复制到/etc/init.d/目录中，以初始化和运行该脚本。这里我们使用超级用户命令 (sudo)，因此您必须提供超级用户密码才能执行以下命令。
$ sudo cp $ORIENTDB_HOME/bin/orientdb.sh /etc/init.d/orientdb
使用以下命令将 console.sh 文件从 OrientDB 安装目录（即$ORIENTDB_HOME/bin）复制到系统 bin 目录（即/usr/bin），以便访问 Orient DB 的控制台。
$ sudo cp $ ORIENTDB_HOME/bin/console.sh /usr/bin/orientdb
使用以下命令启动 ORIENTDB 数据库服务器作为服务。您必须在此处提供您在 orientdb.sh 文件中提到的相应用户的密码才能启动服务器。
$ service orientdb start
使用以下命令查看 OrientDB 服务器守护进程运行的 PID。
$ service orientdb status
使用以下命令停止 OrientDB 服务器守护进程。您必须在此处提供您在 orientdb.sh 文件中提到的相应用户的密码才能停止服务器。
$ service orientdb stop
在 Windows 中
OrientDB 是一个服务器应用程序，因此在启动和关闭 Java 虚拟机进程之前，它必须执行多个任务。如果您想手动关闭 OrientDB 服务器，则必须执行shutdown.bat文件。但是，当系统突然关闭而没有执行上述脚本时，服务器实例无法正确停止。在 Windows 中，由操作系统通过一组指定的信号控制的程序称为服务。
我们必须使用Apache Common Daemon，它允许 Windows 用户将 Java 应用程序包装为 Windows 服务。以下是下载和注册 Apache Common Daemon 的过程。
单击以下链接以获取 适用于 Windows 的 Apache Common Daemons。
单击common-daemon-1.0.15-bin-windows进行下载。
解压common-daemon-1.0.15-bin-windows目录。解压后，您将在目录中找到prunsrv.exe和prunmgr.exe文件。其中：
prunsrv.exe文件是一个服务应用程序，用于将应用程序作为服务运行。
prunmgr.exe文件是一个用于监控和配置 Windows 服务的应用程序。
转到 OrientDB 安装文件夹→创建一个新目录，并将其命名为 service。
复制prunsrv.exe和prunmgr.exe并将它们粘贴到 service 目录中。
为了将 OrientDB 配置为 Windows 服务，您必须执行一个简短的脚本，该脚本使用 prusrv.exe 作为 Windows 服务。
在定义 Windows 服务之前，您必须根据服务名称重命名 prunsrv 和 prunmgr。例如，分别为 OrientDBGraph 和 OrientDBGraphw。这里 OrientDBGraph 是服务名称。
将以下脚本复制到名为installService.bat的文件中，并将其放置到%ORIENTDB_HOME%\service\目录中。
:: OrientDB Windows Service Installation @echo off rem Remove surrounding quotes from the first parameter set str=%~1 rem Check JVM DLL location parameter if "%str%" == "" goto missingJVM set JVM_DLL=%str% rem Remove surrounding quotes from the second parameter set str=%~2 rem Check OrientDB Home location parameter if "%str%" == "" goto missingOrientDBHome set ORIENTDB_HOME=%str% set CONFIG_FILE=%ORIENTDB_HOME%/config/orientdb-server-config.xml set LOG_FILE = %ORIENTDB_HOME%/config/orientdb-server-log.properties set LOG_CONSOLE_LEVEL = info set LOG_FILE_LEVEL = fine set WWW_PATH = %ORIENTDB_HOME%/www set ORIENTDB_ENCODING = UTF8 set ORIENTDB_SETTINGS = -Dprofiler.enabled = true -Dcache.level1.enabled = false Dcache.level2.strategy = 1 set JAVA_OPTS_SCRIPT = -XX:+HeapDumpOnOutOfMemoryError rem Install service OrientDBGraphX.X.X.exe //IS --DisplayName="OrientDB GraphEd X.X.X" ^ --Description = "OrientDB Graph Edition, aka GraphEd, contains OrientDB server integrated with the latest release of the TinkerPop Open Source technology stack supporting property graph data model." ^ --StartClass = com.orientechnologies.orient.server.OServerMain -StopClass = com.orientechnologies.orient.server.OServerShutdownMain ^ --Classpath = "%ORIENTDB_HOME%\lib\*" --JvmOptions "Dfile.Encoding = %ORIENTDB_ENCODING%; Djava.util.logging.config.file = "%LOG_FILE%"; Dorientdb.config.file = "%CONFIG_FILE%"; -Dorientdb.www.path = "%WWW_PATH%"; Dlog.console.level = %LOG_CONSOLE_LEVEL%; -Dlog.file.level = %LOG_FILE_LEVEL%; Dorientdb.build.number = "@BUILD@"; -DORIENTDB_HOME = %ORIENTDB_HOME%" ^ --StartMode = jvm --StartPath = "%ORIENTDB_HOME%\bin" --StopMode = jvm -StopPath = "%ORIENTDB_HOME%\bin" --Jvm = "%JVM_DLL%" -LogPath = "%ORIENTDB_HOME%\log" --Startup = auto EXIT /B :missingJVM echo Insert the JVM DLL location goto printUsage :missingOrientDBHome echo Insert the OrientDB Home goto printUsage :printUsage echo usage: echo installService JVM_DLL_location OrientDB_Home EXIT /B
该脚本需要两个参数：
jvm.dll 的位置，例如 C:\ProgramFiles\java\jdk1.8.0_66\jre\bin\server\jvm.dll
OrientDB 安装的位置，例如 C:\orientdb-community-2.1.9
当您执行 OrientDBGraph.exe 文件（原始 prunsrv）并双击它时，服务将被安装。
使用以下命令将服务安装到 Windows 中。
> Cd %ORIENTDB_HOME%\service > installService.bat "C:\Program Files\Java\jdk1.8.0_66\jre\bin\server \jvm.dll" C:\orientdb-community-2.1.9
打开任务管理器服务，您将看到以下截图，其中包含已注册的服务名称。
步骤 4 - 验证 OrientDB 安装
此步骤使用以下步骤验证 OrientDB 数据库服务器安装。
- 运行服务器。
- 运行控制台。
- 运行 Studio。
这因操作系统而异。
在 Linux 中
请按照以下步骤在 Linux 中验证 OrientDB 安装。
运行服务器 - 您可以使用以下命令启动服务器。
$ cd $ORIENTDB_HOME/bin $ ./server.sh
或者，您可以使用以下命令将 OrientDB 服务器启动为 UNIX 守护进程。
$ service orientdb start
如果安装成功，您将收到以下输出。
.
.` `
, `:.
`,` ,:`
.,. :,,
.,, ,,,
. .,.::::: ```` ::::::::: :::::::::
,` .::,,,,::.,,,,,,`;; .: :::::::::: ::: :::
`,. ::,,,,,,,:.,,.` ` .: ::: ::: ::: :::
,,:,:,,,,,,,,::. ` ` `` .: ::: ::: ::: :::
,,:.,,,,,,,,,: `::, ,, ::,::` : :,::` :::: ::: ::: ::: :::
,:,,,,,,,,,,::,: ,, :. : :: : .: ::: ::: :::::::
:,,,,,,,,,,:,:: ,, : : : : .: ::: ::: :::::::::
` :,,,,,,,,,,:,::, ,, .:::::::: : : .: ::: ::: ::: :::
`,...,,:,,,,,,,,,: .:,. ,, ,, : : .: ::: ::: ::: :::
.,,,,::,,,,,,,: `: , ,, : ` : : .: ::: ::: ::: :::
...,::,,,,::.. `: .,, :, : : : .: ::::::::::: ::: :::
,::::,,,. `: ,, ::::: : : .: ::::::::: ::::::::::
,,:` `,,.
,,, .,`
,,. `, GRAPH DATABASE
`` `.
`` orientdb.com
`
2016-01-20 19:17:21:547 INFO OrientDB auto-config DISKCACHE = 1,
649MB (heap = 494MB os = 4, 192MB disk = 199, 595MB) [orientechnologies]
2016-01-20 19:17:21:816 INFO Loading configuration from:
/opt/orientdb/config/orientdb-server-config.xml... [OServerConfigurationLoaderXml]
2016-01-20 19:17:22:213 INFO OrientDB Server v2.1.9-SNAPSHOT
(build 2.1.x@r; 2016-01-07 10:51:24+0000) is starting up... [OServer]
2016-01-20 19:17:22:220 INFO Databases directory: /opt/orientdb/databases [OServer]
2016-01-20 19:17:22:361 INFO Port 0.0.0.0:2424 busy,
trying the next available... [OServerNetworkListener]
2016-01-20 19:17:22:362 INFO Listening binary connections on 0.0.0.0:2425
(protocol v.32, socket = default) [OServerNetworkListener]
...
2016-01-20 19:17:22:614 INFO Installing Script interpreter. WARN:
authenticated clients can execute any kind of code into the server
by using the following allowed languages:
[sql] [OServerSideScriptInterpreter]
2016-01-20 19:17:22:615 INFO OrientDB Server v2.1.9-SNAPSHOT
(build 2.1.x@r; 2016-01-07 10:51:24+0000) is active. [OServer]
运行控制台 - 您可以使用以下命令在控制台中运行 OrientDB。
$ orientdb
如果安装成功，您将收到以下输出。
OrientDB console v.2.1.9-SNAPSHOT (build 2.1.x@r; 2016-01-07 10:51:24+0000) www.orientdb.com Type 'help' to display all the supported commands. Installing extensions for GREMLIN language v.2.6.0 orientdb>
运行 Studio - 启动服务器后，您可以在浏览器中使用以下 URL（https://:2480/）。您将看到以下截图。
在 Windows 中
请按照以下步骤在 Windows 中验证 OrientDB 安装。
运行服务器 - 您可以使用以下命令启动服务器。
> cd %ORIENTDB_HOME%\bin > ./server.bat
如果安装成功，您将收到以下输出。
.
.` `
, `:.
`,` ,:`
.,. :,,
.,, ,,,
. .,.::::: ```` ::::::::: :::::::::
,` .::,,,,::.,,,,,,`;; .: :::::::::: ::: :::
`,. ::,,,,,,,:.,,.` ` .: ::: ::: ::: :::
,,:,:,,,,,,,,::. ` ` `` .: ::: ::: ::: :::
,,:.,,,,,,,,,: `::, ,, ::,::` : :,::` :::: ::: ::: ::: :::
,:,,,,,,,,,,::,: ,, :. : :: : .: ::: ::: :::::::
:,,,,,,,,,,:,:: ,, : : : : .: ::: ::: :::::::::
` :,,,,,,,,,,:,::, ,, .:::::::: : : .: ::: ::: ::: :::
`,...,,:,,,,,,,,,: .:,. ,, ,, : : .: ::: ::: ::: :::
.,,,,::,,,,,,,: `: , ,, : ` : : .: ::: ::: ::: :::
...,::,,,,::.. `: .,, :, : : : .: ::::::::::: ::: :::
,::::,,,. `: ,, ::::: : : .: ::::::::: ::::::::::
,,:` `,,.
,,, .,`
,,. `, GRAPH DATABASE
`` `.
`` orientdb.com
`
2016-01-20 19:17:21:547 INFO OrientDB auto-config DISKCACHE = 1,649MB
(heap = 494MB os = 4, 192MB disk = 199, 595MB) [orientechnologies]
2016-01-20 19:17:21:816 INFO Loading configuration from:
/opt/orientdb/config/orientdb-server-config.xml...
[OServerConfigurationLoaderXml]
...
2016-01-20 19:17:22:615 INFO OrientDB Server v2.1.9-SNAPSHOT
(build 2.1.x@r; 2016-01-07 10:51:24+0000) is active. [OServer]
运行控制台 - 您可以使用以下命令在控制台中运行 OrientDB。
> %ORIENTDB_HOME%\bin\console.bat
如果安装成功，您将收到以下输出。
OrientDB console v.2.1.9-SNAPSHOT (build 2.1.x@r; 2016-01-07 10:51:24+0000) www.orientdb.com Type 'help' to display all the supported commands. Installing extensions for GREMLIN language v.2.6.0 orientdb\>
运行 Studio - 启动服务器后，您可以在浏览器中使用以下 URL（https://:2480/）。您将看到以下截图。
OrientDB - 基本概念
OrientDB 的主要特性是支持多模型对象，即支持文档、图、键值对和真实对象等不同模型。它包含单独的 API 来支持这四种模型。
文档模型
术语“文档模型”属于 NoSQL 数据库。这意味着数据存储在文档中，文档的集合称为集合。从技术上讲，文档表示一组键值对，也称为字段或属性。
OrientDB 使用类、集群和链接等概念来存储、分组和分析文档。
下表说明了关系模型、文档模型和 OrientDB 文档模型之间的比较：
| 关系模型 | 文档模型 | OrientDB 文档模型 |
|---|---|---|
| 表 | 集合 | 类或集群 |
| 行 | 文档 | 文档 |
| 列 | 键值对 | 文档字段 |
| 关系 | 不可用 | 链接 |
图模型
图数据结构是一种数据模型，可以以顶点（节点）通过边（弧）互连的形式存储数据。OrientDB 图数据库的概念源于属性图。顶点和边是图模型的主要构成要素。它们包含属性，这使得它们看起来类似于文档。
下表显示了图模型、关系数据模型和 OrientDB 图模型之间的比较。
| 关系模型 | 图模型 | OrientDB 图模型 |
|---|---|---|
| 表 | 顶点和边类 | 扩展“V”（顶点）和“E”（边）的类 |
| 行 | 顶点 | 顶点 |
| 列 | 顶点和边属性 | 顶点和边属性 |
| 关系 | 边 | 边 |
键值模型
键值模型意味着数据可以以键值对的形式存储，其中值可以是简单类型和复杂类型。它可以支持文档和图元素作为值。
下表说明了关系模型、键值模型和 OrientDB 键值模型之间的比较。
| 关系模型 | 键值模型 | OrientDB 键值模型 |
|---|---|---|
| 表 | 桶 | 类或集群 |
| 行 | 键值对 | 文档 |
| 列 | 不可用 | 文档字段或顶点/边属性 |
| 关系 | 不可用 | 链接 |
对象模型
此模型继承自面向对象编程，支持类型之间的继承（子类型扩展超类型）、多态性（引用基类时）和编程语言中使用的对象之间的直接绑定。
下表说明了关系模型、对象模型和 OrientDB 对象模型之间的比较。
| 关系模型 | 对象模型 | OrientDB 对象模型 |
|---|---|---|
| 表 | 类 | 类或集群 |
| 行 | 对象 | 文档或顶点 |
| 列 | 对象属性 | 文档字段或顶点/边属性 |
| 关系 | 指针 | 链接 |
在详细介绍之前，最好了解与 OrientDB 相关的基本术语。以下是一些重要的术语。
记录
可以从数据库加载和存储的最小单位。记录可以存储在四种类型中。
- 文档
- 记录字节
- 顶点
- 边
记录 ID
当 OrientDB 生成记录时，数据库服务器会自动为记录分配一个唯一标识符，称为 RecordID (RID)。RID 的格式类似于 #<集群>:<位置>。<集群> 表示集群标识号，<位置> 表示记录在集群中的绝对位置。
文档
文档是 OrientDB 中最灵活的记录类型。文档是弱类型的，由具有定义约束的模式类定义，但您也可以在没有任何模式的情况下插入文档，即它也支持无模式模式。
文档可以轻松地以 JSON 格式导出和导入。例如，请查看以下 JSON 示例文档。它定义了文档详细信息。
{
"id" : "1201",
"name" : "Jay",
"job" : "Developer",
"creations" : [
{
"name" : "Amiga",
"company" : "Commodore Inc."
},
{
"name" : "Amiga 500",
"company" : "Commodore Inc."
}
]
}
记录字节
记录类型与 RDBMS 中的 BLOB 类型相同。OrientDB 可以加载和存储文档记录类型以及二进制数据。
顶点
OrientDB 数据库不仅是文档数据库，也是图数据库。诸如顶点和边之类的新的概念用于以图的形式存储数据。在图数据库中，最基本的的数据单元是节点，在 OrientDB 中称为顶点。顶点存储数据库信息。
边
有一种名为边的单独记录类型，用于连接一个顶点到另一个顶点。边是双向的，只能连接两个顶点。OrientDB 中有两种类型的边，一种是常规边，另一种是轻量级边。
类
类是一种数据模型类型，其概念源于面向对象编程范式。基于传统的文档数据库模型，数据以集合的形式存储，而在关系数据库模型中，数据存储在表中。OrientDB 遵循文档 API 和 OOP 范式。作为一个概念，OrientDB 中的类与关系数据库中的表关系最密切，但是（与表不同）类可以是无模式的、有模式的或混合的。类可以继承自其他类，创建类树。每个类都有自己的集群或集群（如果未定义，则默认创建）。
集群
集群是一个重要的概念，用于存储记录、文档或顶点。简单来说，集群是存储一组记录的地方。默认情况下，OrientDB 将为每个类创建一个集群。一个类的所有记录都存储在与类名称相同的集群中。您可以在数据库中创建多达 32,767 (2^15-1) 个集群。
CREATE class 是用于创建具有特定名称的集群的命令。创建集群后，您可以通过在创建任何数据模型时指定名称来使用该集群保存记录。
关系
OrientDB 支持两种关系：引用关系和嵌入关系。引用关系表示它存储指向关系目标对象的直接链接。嵌入关系表示它在嵌入它的记录内存储关系。这种关系比引用关系更强。
数据库
数据库是访问实际存储的接口。它理解诸如查询、模式、元数据、索引等高级概念。OrientDB 还提供多种数据库类型。有关这些类型的更多信息，请参见数据库类型。
OrientDB - 数据类型
OrientDB 原生支持多种数据类型。以下是关于这些类型的完整表格。
| 序号 | 类型 | 描述 |
|---|---|---|
| 1 | 布尔值 | 仅处理 True 或 False 值。 Java 类型：java.lang.Boolean 最小值: 0 最大值: 1 |
| 2 | 整数 | 32 位有符号整数。 Java 类型：java.lang.Integer 最小值: -2,147,483,648 最大值: +2,147,483,647 |
| 3 | 短整数 | 16 位有符号小整数。 Java 类型：java.lang.Short 最小值: -32,768 最大值: 32,767 |
| 4 | 长整数 | 64 位有符号大整数。 Java 类型：java.lang.Long 最小值：-263 最大值：+263-1 |
| 5 | 浮点数 | 十进制数。 Java 类型：java.lang.Float : 2-149 最大值：(2-2-23)*2127 |
| 6 | 双精度浮点数 | 高精度十进制数。 Java 类型：java.lang.Double 最小值：2-1074 最大值：(2-2-52)*21023 |
| 7 | 日期时间 | 任何日期，精度高达毫秒。 Java 类型：java.util.Date |
| 8 | 字符串 | 任何字符串，作为字符的字母数字序列。 Java 类型：java.lang.String |
| 9 | 二进制 | 可以包含任何字节数组值。 Java 类型：byte[] 最小值: 0 最大值: 2,147,483,647 |
| 10 | 嵌入式 | 记录包含在所有者内部。包含的记录没有 RecordId。 Java 类型：ORecord |
| 11 | 嵌入式列表 | 记录包含在所有者内部。包含的记录没有 RecordId，只能通过导航所有者记录访问。 Java 类型：List<objects> 最小值: 0 最大值：41,000,000 个项目 |
| 12 | 嵌入式集合 | 记录包含在所有者内部。包含的记录没有 RecordId，只能通过导航所有者记录访问。 Java 类型：Set<objects> 最小值: 0 最大值：41,000,000 个项目 |
| 13 | 嵌入式映射 | 记录作为条目的值包含在所有者内部，而键只能是字符串。包含的记录没有 RecordId，只能通过导航所有者记录访问。 Java 类型：Map<String, ORecord> 最小值: 0 最大值：41,000,000 个项目 |
| 14 | 链接 | 指向另一个记录的链接。这是一种常见的一对一关系 Java 类型：ORID，<? extends ORecord> 最小值: 1 最大值: 32767:2^63-1 |
| 15 | 链接列表 | 指向其他记录的链接。这是一种常见的一对多关系，其中只存储 RecordId。 Java 类型：List<? extends ORecord> 最小值: 0 最大值：41,000,000 个项目 |
| 16 | 链接集合 | 指向其他记录的链接。这是一种常见的一对多关系。 Java 类型：Set<? extends ORecord> 最小值: 0 最大值：41,000,000 个项目 |
| 17 | 链接映射 | 指向其他记录的链接，作为条目的值，而键只能是字符串。这是一种常见的一对多关系。只存储 RecordId。 Java 类型：Map<String, ? extends Record> 最小值: 0 最大值：41,000,000 个项目 |
| 18 | 字节 | 单个字节。用于存储 8 位有符号小整数。 Java 类型：java.lang.Byte 最小值: -128 最大值: +127 |
| 19 | 瞬态 | 任何未存储在数据库中的值。 |
| 20 | 日期 | 任何日期，如年、月和日。 Java 类型：java.util.Date |
| 21 | 自定义 | 用于存储提供 Marshal 和 Unmarshal 方法的自定义类型。 Java 类型：OSerializableStream 最小值: 0 最大值：x |
| 22 | 十进制 | 不进行舍入的十进制数。 Java 类型：java.math.BigDecimal |
| 23 | 链接包 | 作为特定 RidBag 的 RecordId 列表。 Java 类型：ORidBag |
| 24 | 任何 | 不确定类型，用于指定混合类型的集合和 null。 |
在接下来的章节中，将讨论如何在 OrientDB 中使用这些数据类型。
OrientDB - 控制台模式
OrientDB 控制台是一个 Java 应用程序，用于处理 OrientDB 数据库和服务器实例。OrientDB 支持多种控制台模式。
交互模式
这是默认模式。只需通过执行以下脚本bin/console.sh（或 MS Windows 系统中的bin/console.bat）来启动控制台。确保拥有其执行权限。
OrientDB console v.1.6.6 www.orientechnologies.com Type 'help' to display all the commands supported. orientdb>
完成后，控制台即可接受命令。
批处理模式
要在批处理模式下执行命令，请运行以下bin/console.sh（或 MS Windows 系统中的bin/console.bat）脚本，并使用分号“;”分隔所有命令。
orientdb> console.bat "connect remote:localhost/demo;select * from profile"
或者调用控制台脚本，传递包含要执行的命令列表的文本文件名。命令必须用分号“;”分隔。
示例
Command.txt 包含您想要通过 OrientDB 控制台执行的命令列表。以下命令从 command.txt 文件接收批处理命令。
orientdb> console.bat commands.txt
在批处理模式下，您可以忽略错误以让脚本继续执行，方法是将“ignoreErrors”变量设置为 true。
orientdb> set ignoreErrors true
启用回显
在管道中运行控制台命令时，您需要显示它们。通过在开头将其设置为属性来启用命令的“echo”。以下是启用OrientDB控制台中的echo属性的语法。
orientdb> set echo true
OrientDB - 创建数据库
OrientDB数据库的SQL参考提供了创建、更改和删除数据库的多个命令。
以下语句是创建数据库命令的基本语法。
CREATE DATABASE <database-url> [<user> <password> <storage-type> [<db-type>]]
以下是上述语法中选项的详细信息。
<database-url> − 定义数据库的URL。URL包含两部分，一部分是<mode>，另一部分是<path>。
<mode> − 定义模式，即本地模式或远程模式。
<path> − 定义数据库的路径。
<user> − 定义您要连接到的数据库的用户。
<password> − 定义连接到数据库的密码。
<storage-type> − 定义存储类型。您可以在PLOCAL和MEMORY之间进行选择。
示例
您可以使用以下命令创建一个名为demo的本地数据库。
Orientdb> CREATE DATABASE PLOCAL:/opt/orientdb/databses/demo
如果数据库成功创建，您将获得以下输出。
Database created successfully.
Current database is: plocal: /opt/orientdb/databases/demo
orientdb {db = demo}>
OrientDB - 修改数据库
数据库是重要的数据模型之一，具有您可以根据需要修改的不同属性。
以下语句是更改数据库命令的基本语法。
ALTER DATABASE <attribute-name> <attribute-value>
其中<attribute-name>定义您要修改的属性，而<attributevalue>定义您要为此属性设置的值。
下表定义了支持更改数据库的属性列表。
| 序号 | 属性名称 | 描述 |
|---|---|---|
| 1 | STATUS | 定义不同属性之间数据库的状态。 |
| 2 | IMPORTING | 设置导入状态。 |
| 3 | DEFAULTCLUSTERID | 使用ID设置默认集群。默认值为2。 |
| 4 | DATEFORMAT | 将特定日期格式设置为默认值。默认值为“yyyy-MM-dd”。 |
| 5 | DATETIMEFORMAT | 将特定日期时间格式设置为默认值。默认值为“yyyy-MM-dd HH:mm:ss”。 |
| 6 | TIMEZONE | 设置特定时区。默认值为Java虚拟机（JVM）的默认时区。 |
| 7 | LOCALECOUNTRY | 设置默认区域国家/地区。默认值为JVM的默认区域国家/地区。例如：“GB”。 |
| 8 | LOCALELANGUAGE | 设置默认区域语言。默认值为JVM的默认区域语言。例如：“en”。 |
| 9 | CHARSET | 设置字符集类型。默认值为JVM的默认字符集。例如：“utf8”。 |
| 10 | CLUSTERSELECTION | 设置用于选择集群的默认策略。这些策略是与类创建一起创建的。支持的策略包括default、roundrobin和balanced。 |
| 11 | MINIMUMCLUSTERS | 设置创建新类时自动创建的最小集群数。默认值为1。 |
| 12 | CUSTOM | 设置自定义属性。 |
| 13 | VALIDATION | 禁用或启用整个数据库的验证。 |
示例
从OrientDB-2.2版本开始，添加了新的SQL解析器，在某些情况下它不允许使用常规语法。因此，在某些情况下我们必须禁用新的SQL解析器（StrictSQL）。您可以使用以下更改数据库命令来禁用StrictSQL解析器。
orientdb> ALTER DATABASE custom strictSQL = false
如果命令执行成功，您将获得以下输出。
Database updated successfully
OrientDB - 备份数据库
与RDBMS一样，OrientDB也支持备份和恢复操作。执行备份操作时，它将使用ZIP算法将当前数据库的所有文件压缩成压缩的zip格式。此功能（备份）可以通过启用自动备份服务器插件自动获得。
数据库备份或数据库导出是相同的，但是，根据过程，我们必须知道何时使用备份以及何时使用导出。
在进行备份时，它将创建一个数据库的一致副本，所有后续的写入操作都将被锁定并等待备份过程完成。在此操作中，它将创建一个只读备份文件。
如果您需要在进行备份时进行并发读写操作，则必须选择导出数据库而不是备份数据库。导出不会锁定数据库，并允许在导出过程中进行并发写入。
以下语句是数据库备份的基本语法。
./backup.sh <dburl> <user> <password> <destination> [<type>]
以下是上述语法中选项的详细信息。
<dburl> − 数据库URL，数据库位于本地或远程位置。
<user> − 指定运行备份的用户名。
<password> − 提供特定用户的密码。
<destination> − 目标文件位置，指示存储备份zip文件的位置。
<type> − 可选备份类型。它有两个选项之一。
Default − 在备份期间锁定数据库。
LVM − 使用LVM复制写入快照在后台。
示例
备份位于本地文件系统/opt/orientdb/databases/demo中的名为demo的数据库，将其备份到名为sample-demo.zip的文件中，并将其放在当前目录中。
您可以使用以下命令备份demo数据库。
$ backup.sh plocal: opt/orientdb/database/demo admin admin ./backup-demo.zip
使用控制台
您可以使用OrientDB控制台执行相同的操作。在备份特定数据库之前，您必须首先连接到该数据库。您可以使用以下命令连接到名为demo的数据库。
orientdb> CONNECT PLOCAL:/opt/orientdb/databases/demo admin admin
连接后，您可以使用以下命令将数据库备份到当前目录中的名为“backup-demo.zip”的文件中。
orientdb {db=demo}> BACKUP DATABASE ./backup-demo.zip
如果此命令成功执行，您将获得一些成功通知以及以下消息。
Backup executed in 0.30 seconds
OrientDB - 恢复数据库
与RDBMS一样，OrientDB也支持恢复操作。您只能在控制台模式下成功执行此操作。
以下语句是恢复操作的基本语法。
orientdb> RESTORE DATABSE <url of the backup zip file>
示例
您必须仅在控制台模式下执行此操作。因此，您必须首先使用以下OrientDB命令启动OrientDB控制台。
$ orientdb
然后，连接到相应的数据库以恢复备份。您可以使用以下命令连接到名为demo的数据库。
orientdb> CONNECT PLOCAL:/opt/orientdb/databases/demo admin admin
成功连接后，您可以使用以下命令从“backup-demo.zip”文件恢复备份。在执行之前，请确保backup-demo.zip文件位于当前目录中。
Orientdb {db = demo}> RESTORE DATABASE backup-demo.zip
如果此命令成功执行，您将获得一些成功通知以及以下消息。
Database restored in 0.26 seconds
OrientDB - 连接数据库
本章解释如何从OrientDB命令行连接到特定数据库。它打开一个数据库。
以下语句是连接命令的基本语法。
CONNECT <database-url> <user> <password>
以下是上述语法中选项的详细信息。
<database-url> − 定义数据库的URL。URL包含两部分，一部分是<mode>，另一部分是<path>。
<mode> − 定义模式，即本地模式或远程模式。
<path> − 定义数据库的路径。
<user> − 定义您要连接到的数据库的用户。
<password> − 定义连接到数据库的密码。
示例
我们已经在前面的章节中创建了一个名为“demo”的数据库。在此示例中，我们将使用用户admin连接到该数据库。
您可以使用以下命令连接到demo数据库。
orientdb> CONNECT PLOCAL:/opt/orientdb/databases/demo admin admin
如果成功连接，您将获得以下输出：
Connecting to database [plocal:/opt/orientdb/databases/demo] with user 'admin'…OK
Orientdb {db = demo}>
OrientDB - 断开数据库连接
本章解释如何从OrientDB命令行断开与特定数据库的连接。它关闭当前打开的数据库。
以下语句是断开连接命令的基本语法。
DISCONNECT
注意 − 只有在连接到特定数据库后才能使用此命令，它只会关闭当前正在运行的数据库。
示例
在此示例中，我们将使用我们在上一章中创建的相同名为“demo”的数据库。我们将从demo数据库断开连接。
您可以使用以下命令断开数据库连接。
orientdb {db = demo}> DISCONNECT
如果成功断开连接，您将获得以下输出：
Disconnecting to database [plocal:/opt/orientdb/databases/demo] with user 'admin'…OK orientdb>
OrientDB - 数据库信息
本章解释如何从OrientDB命令行获取特定数据库的信息。
以下语句是Info命令的基本语法。
info
注意 − 只有在连接到特定数据库后才能使用此命令，它将仅检索当前正在运行的数据库的信息。
示例
在此示例中，我们将使用我们在上一章中创建的相同名为“demo”的数据库。我们将检索demo数据库的基本信息。
您可以使用以下命令断开数据库连接。
orientdb {db = demo}> info
如果成功断开连接，您将获得以下输出。
Current database: demo (url = plocal:/opt/orientdb/databases/demo) DATABASE PROPERTIES --------------------------------+---------------------------------------------+ NAME | VALUE | --------------------------------+---------------------------------------------+ Name | null | Version | 14 | Conflict Strategy | version | Date format | yyyy-MM-dd | Datetime format | yyyy-MM-dd HH:mm:ss | Timezone | Asia/Kolkata | Locale Country | IN | Locale Language | en | Charset | UTF-8 | Schema RID | #0:1 | Index Manager RID | #0:2 | Dictionary RID | null | --------------------------------+---------------------------------------------+ DATABASE CUSTOM PROPERTIES: +-------------------------------+--------------------------------------------+ | NAME | VALUE | +-------------------------------+--------------------------------------------+ | strictSql | true | +-------------------------------+--------------------------------------------+ CLUSTERS (collections) ---------------------------------+-------+-------------------+----------------+ NAME | ID | CONFLICT STRATEGY | RECORDS | ---------------------------------+-------+-------------------+----------------+
OrientDB - 列出数据库
本章解释如何从OrientDB命令行获取实例中所有数据库的列表。
以下语句是info命令的基本语法。
LIST DATABASES
注意 − 只有在连接到本地或远程服务器后才能使用此命令。
示例
在检索数据库列表之前，我们必须通过远程服务器连接到本地主机服务器。需要提醒的是，连接到本地主机实例的用户名和密码分别是guest和guest，这在orintdb/config/orientdb-server-config.xml文件中配置。
您可以使用以下命令连接到本地主机数据库服务器实例。
orientdb> connect remote:localhost guest
它将提示输入密码。根据配置文件，guest的密码也是guest。如果成功连接，您将获得以下输出。
Connecting to remote Server instance [remote:localhost] with user 'guest'...OK
orientdb {server = remote:localhost/}>
连接到本地主机数据库服务器后，您可以使用以下命令列出数据库。
orientdb {server = remote:localhost/}> list databases
如果成功执行，您将获得以下输出：
Found 6 databases:
* demo (plocal)
* s2 (plocal)
* s1 (plocal)
* GratefulDeadConcerts (plocal)
* s3 (plocal)
* sample (plocal)
orientdb {server = remote:localhost/}>
OrientDB - 冻结数据库
每当您想要使数据库状态保持静态时，这意味着数据库不会响应任何读写操作。简单地说，数据库处于冻结状态。
在本章中，您可以学习如何从OrientDB命令行冻结数据库。
以下语句是冻结数据库命令的基本语法。
FREEZE DATABASE
注意 − 只有在连接到远程或本地数据库中的特定数据库后才能使用此命令。
示例
在此示例中，我们将使用我们在上一章中创建的相同名为“demo”的数据库。我们将从CLI冻结此数据库。
您可以使用以下命令冻结数据库。
Orientdb {db = demo}> FREEZE DATABASE
如果成功执行，您将获得以下输出。
Database 'demo' was frozen successfully
OrientDB - 解冻数据库
本章将讲解如何通过 OrientDB 命令行将数据库从冻结状态解除。
以下是解除数据库冻结命令的基本语法。
RELEASE DATABASE
注意 − 只有在连接到处于冻结状态的特定数据库后才能使用此命令。
示例
在本例中，我们将使用上一章创建的名为“demo”的同一数据库。我们将解除上一章中冻结的数据库。
可以使用以下命令解除数据库冻结。
Orientdb {db = demo}> RELEASE DATABASE
如果成功执行，您将获得以下输出。
Database 'demo' was release successfully
OrientDB - 配置数据库
本章将讲解如何通过 OrientDB 命令行显示特定数据库的配置。此命令适用于本地和远程数据库。
配置信息包含默认缓存是否启用、缓存大小、负载因子值、映射最大内存、节点页面大小、池最小和最大大小等。
以下是数据库配置命令的基本语法。
CONFIG
注意 − 只有在连接到特定数据库后才能使用此命令。
示例
在本例中，我们将使用上一章创建的名为“demo”的同一数据库。
可以使用以下命令显示 demo 数据库的配置。
Orientdb {db = demo}> CONFIG
如果成功执行，您将获得以下输出。
LOCAL SERVER CONFIGURATION:
+---------------------------------------+-------------------------+
| NAME | VALUE |
+---------------------------------------+-------------------------+
| environment.dumpCfgAtStartup | false |
| environment.concurrent | true |
| environment.allowJVMShutdown | true |
| script.pool.maxSize | 20 |
| memory.useUnsafe | true |
| memory.directMemory.safeMode | true |
| memory.directMemory.trackMode | false |
|……………………………….. | |
| storage.lowestFreeListBound | 16 |
| network.binary.debug | false |
| network.http.maxLength | 1000000 |
| network.http.charset | utf-8 |
| network.http.jsonResponseError | true |
| network.http.json | false |
| tx.log.fileType | classic |
| tx.log.synch | false |
| tx.autoRetry | 1 |
| client.channel.minPool | 1 |
| storage.keepOpen | true |
| cache.local.enabled | true |
+---------------------------------------+-------------------------+
orientdb {db = demo}>
在上述配置参数列表中，如果要更改任何参数值，则可以使用 config set 和 get 命令轻松地通过命令行进行更改。
Config Set
可以使用CONFIG SET命令更新配置变量值。
以下是 config set 命令的基本语法。
CONFIG SET <config-variable> <config-value>
注意 − 只有在连接到特定数据库后才能使用此命令。
示例
在本例中，我们将使用上一章创建的名为“demo”的同一数据库。我们将把“tx.autoRetry”变量的值修改为 5。
可以使用以下命令设置 demo 数据库的配置。
orientdb {db = demo}> CONFIG SET tx.autoRetry 5
如果成功执行，您将获得以下输出。
Local configuration value changed correctly
Config Get
可以使用CONFIG GET命令显示配置变量值。
以下是 config get 命令的基本语法。
CONFIG GET <config-variable>
注意 − 只有在连接到特定数据库后才能使用此命令。
示例
在本例中，我们将使用上一章创建的名为“demo”的同一数据库。我们将尝试检索“tx.autoRetry”变量的值。
可以使用以下命令显示 demo 数据库的配置。
orientdb {db = demo}> CONFIG GET tx.autoRetry
如果成功执行，您将获得以下输出。
Local configuration: tx.autoRetry = 5
OrientDB - 导出数据库
与 RDBMS 类似，OrientDB 也提供数据库导出和导入功能。OrientDB 使用 JSON 格式导出数据。默认情况下，导出命令使用 GZIP 算法压缩文件。
导出数据库时不会锁定数据库，这意味着您可以对其执行并发读写操作。这也意味着由于并发读写操作，您可以创建数据的精确副本。
本章将讲解如何通过 OrientDB 命令行导出数据库。
以下是导出数据库命令的基本语法。
EXPORT DATABASE <output file>
注意 − 只有在连接到特定数据库后才能使用此命令。
示例
在本例中，我们将使用上一章创建的名为“demo”的同一数据库。可以使用以下命令将数据库导出到名为“export-demo”的文件。
orientdb {db = demo}> EXPORT DATABASE ./export-demo.export
如果执行成功，它将创建一个名为“export-demo.zip”或“exportdemo.gz”的文件（取决于操作系统），您将获得以下输出。
Exporting current database to: DATABASE /home/linuxtp/Desktop/demo.export in GZipped JSON format ... Started export of database 'demo' to /home/linuxtp/Desktop/demo.export.gz... Exporting database info...OK Exporting clusters...OK (12 clusters) Exporting schema...OK (11 classes) Exporting records... - Cluster 'internal' (id = 0)...OK (records = 3/3) - Cluster 'index' (id = 1)...OK (records = 0/0) - Cluster 'manindex' (id = 2)...OK (records = 0/0) - Cluster 'default' (id = 3)...OK (records = 0/0) - Cluster 'orole' (id = 4)...OK (records = 3/3) - Cluster 'ouser' (id = 5)...OK (records = 3/3) - Cluster 'ofunction' (id = 6)...OK (records = 0/0) - Cluster 'oschedule' (id = 7)...OK (records = 0/0) - Cluster 'orids' (id = 8)...OK (records = 0/0) - Cluster 'v' (id = 9)...OK (records = 0/0) - Cluster 'e' (id = 10)...OK (records = 0/0) - Cluster '_studio' (id = 11)...OK (records = 1/1) Done. Exported 10 of total 10 records Exporting index info... - Index dictionary...OK - Index OUser.name...OK - Index ORole.name...OK OK (3 indexes) Exporting manual indexes content... - Exporting index dictionary ...OK (entries = 0) OK (1 manual indexes) Database export completed in 377ms
OrientDB - 导入数据库
无论何时要导入数据库，都必须使用导出命令生成的 JSON 格式的导出文件。
本章将讲解如何通过 OrientDB 命令行导入数据库。
以下是导入数据库命令的基本语法。
IMPORT DATABASE <input file>
注意 − 只有在连接到特定数据库后才能使用此命令。
示例
在本例中，我们将使用上一章创建的名为“demo”的同一数据库。可以使用以下命令将数据库导入名为“export-demo.gz”的文件。
orientdb {db = demo}> IMPORT DATABASE ./export-demo.export.gz
如果执行成功，您将获得以下输出以及成功通知。
Database import completed in 11612ms
OrientDB - 提交数据库
与 RDBMS 类似，OrientDB 也提供事务概念，如提交和回滚。提交是指通过将所有更改保存到数据库来关闭事务。回滚是指将数据库状态恢复到打开事务时的状态。
以下是提交数据库命令的基本语法。
COMMIT
注意 − 只有在连接到特定数据库并在开始事务后才能使用此命令。
示例
在本例中，我们将使用上一章创建的名为“demo”的同一数据库。我们将看到使用事务提交事务和存储记录的操作。
首先，使用以下BEGIN命令启动事务。
orientdb {db = demo}> BEGIN
然后，使用以下命令将记录插入到员工表中，其值为 id = 12 和 name = satish.P。
orientdb> INSERT INTO employee (id, name) VALUES (12, 'satish.P')
可以使用以下命令提交事务。
orientdb> commit
如果此事务成功提交，您将获得以下输出。
Transaction 2 has been committed in 4ms
OrientDB - 回滚数据库
本章将讲解如何通过 OrientDB 命令行界面回滚未提交的事务。
以下是回滚数据库命令的基本语法。
ROLLBACK
注意 − 只有在连接到特定数据库并在开始事务后才能使用此命令。
示例
在本例中，我们将使用上一章创建的名为“demo”的同一数据库。我们将看到回滚事务和使用事务存储记录的操作。
首先，使用以下BEGIN命令启动事务。
orientdb {db = demo}> BEGIN
然后，使用以下命令将记录插入到员工表中，其值为 id = 12 和 name = satish.P。
orientdb> INSERT INTO employee (id, name) VALUES (12, 'satish.P')
可以使用以下命令从 Employee 表中检索记录。
orientdb> SELECT FROM employee WHERE name LIKE '%.P'
如果此命令成功执行，您将获得以下输出。
---+-------+-------------------- # | ID | name ---+-------+-------------------- 0 | 12 | satish.P ---+-------+-------------------- 1 item(s) found. Query executed in 0.076 sec(s).
现在可以使用以下命令回滚此事务。
orientdb> ROLLBACK
再次检查 select 查询以从 employee 表中检索相同的记录。
orientdb> SELECT FROM employee WHERE name LIKE '%.P'
如果回滚成功执行，您将得到输出中找不到 0 条记录。
0 item(s) found. Query executed in 0.037 sec(s).
OrientDB - 优化数据库
根据技术术语，优化意味着“在最短的时间内获得最佳性能”。关于数据库，优化包括最大限度地提高数据检索的速度和效率。
OrientDB 支持轻量级边，这意味着数据实体之间的直接关系。简单来说，它是一种字段到字段的关系。OrientDB 提供不同的方法来优化数据库。它支持将常规边转换为轻量级边。
以下是优化数据库命令的基本语法。
OPTMIZE DATABASE [-lwedges] [-noverbose]
其中lwedges将常规边转换为轻量级边，noverbose禁用输出。
示例
在本例中，我们将使用上一章创建的名为“demo”的同一数据库。可以使用以下优化数据库命令。
OPTIMIZE DATABASE -lwedges
如果执行成功，您将获得一些成功通知以及完成消息。
Database Optimization completed in 35ms
OrientDB - 删除数据库
与 RDBMS 类似，OrientDB 提供了删除数据库的功能。删除数据库是指完全删除数据库。
以下是删除数据库命令的基本语法。
DROP DATABASE [<database-name> <server-username> <server-user-password>]
以下是上述语法中选项的详细信息。
<database-name> − 要删除的数据库名称。
<server-username> − 具有删除数据库权限的数据库用户名。
<server-user-password> − 特定用户的密码。
示例
有两种方法可以删除数据库，一种是删除当前打开的数据库，另一种是通过提供特定名称来删除特定数据库。
在本例中，我们将使用前面章节中创建的名为“demo”的同一数据库。可以使用以下命令删除数据库demo。
orientdb {db = demo}> DROP DATABASE
如果此命令成功执行，您将获得以下输出。
Database 'demo' deleted successfully
或
可以使用另一个命令删除数据库，如下所示。
orientdb> DROP DATABASE PLOCAL:/opt/orientdb/databases/demo admin admin
如果此命令成功执行，您将获得以下输出。
Database 'demo' deleted successfully
OrientDB - 插入记录
OrientDB 是一个 NoSQL 数据库，可以存储文档和面向图的数据。NoSQL 数据库不包含任何表，那么如何将数据插入为记录呢？在这里您可以看到表数据以类的形式、属性、顶点和边的形式，这意味着类就像表，属性就像表中的字段。
我们可以使用 OrientDB 中的模式定义所有这些实体。属性数据可以插入到类中。insert 命令在数据库模式中创建一个新记录。记录可以是无模式的，也可以遵循某些指定的规则。
以下是插入记录命令的基本语法。
INSERT INTO [class:]<class>|cluster:<cluster>|index:<index>
[(<field>[,]*) VALUES (<expression>[,]*)[,]*]|
[SET <field> = <expression>|<sub-command>[,]*]|
[CONTENT {<JSON>}]
[RETURN <expression>]
[FROM <query>]
以下是上述语法中选项的详细信息。
SET − 定义每个字段及其值。
CONTENT − 定义要设置字段值的 JSON 数据。这是可选的。
RETURN − 定义要返回的表达式，而不是插入的记录数。最常见的用例是 −
@rid − 返回新记录的记录 ID。
@this − 返回整个新记录。
FROM − 您要插入记录或结果集的位置。
示例
让我们考虑一个具有以下字段和类型的 Customer 表。
| 序号 | 字段名称 | 类型 |
|---|---|---|
| 1 | Id | 整数 |
| 2 | Name | 字符串 |
| 3 | Age | 整数 |
您可以通过执行以下命令来创建模式（表）。
CREATE DATABASE PLOCAL:/opt/orientdb/databases/sales CREATE CLASS Customer CREATE PROPERTY Customer.id integer CREATE PROPERTY Customer.name String CREATE PROPERTY Customer.age integer
执行所有命令后，您将获得名为 Customer 的表，其中包含 id、name 和 age 字段。您可以通过执行 Customer 表中的 select 查询来检查该表。
OrientDB 提供不同的方法来插入记录。考虑以下包含示例记录的 Customer 表。
| 序号 | Name | Age |
|---|---|---|
| 1 | Satish | 25 |
| 2 | Krishna | 26 |
| 3 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | Raja | 29 |
以下命令是将第一条记录插入 Customer 表。
INSERT INTO Customer (id, name, age) VALUES (01,'satish', 25)
如果上述命令成功执行，您将获得以下输出。
Inserted record 'Customer#11:0{id:1,name:satish,age:25} v1' in 0.069000 sec(s).
以下命令是将第二条记录插入 Customer 表。
INSERT INTO Customer SET id = 02, name = 'krishna', age = 26
如果上述命令成功执行，您将获得以下输出。
Inserted record 'Customer#11:1{id:2,age:26,name:krishna} v1' in 0.005000 sec(s).
以下命令是将第三条记录插入 Customer 表。
INSERT INTO Customer CONTENT {"id": "03", "name": "kiran", "age": "29"}
如果上述命令成功执行，您将获得以下输出。
Inserted record 'Customer#11:2{id:3,name:kiran,age:29} v1' in 0.004000 sec(s).
以下命令是将接下来的两条记录插入 Customer 表。
INSERT INTO Customer (id, name, age) VALUES (04,'javeed', 21), (05,'raja', 29)
如果上述命令成功执行，您将获得以下输出。
Inserted record '[Customer#11:3{id:4,name:javeed,age:21} v1,
Customer#11:4{id:5,name:raja,age:29} v1]' in 0.007000 sec(s).
您可以通过执行以下命令来检查所有这些记录是否已插入。
SELECT FROM Customer
如果上述命令成功执行，您将获得以下输出。
----+-----+--------+----+-------+---- # |@RID |@CLASS |id |name |age ----+-----+--------+----+-------+---- 0 |#11:0|Customer|1 |satish |25 1 |#11:1|Customer|2 |krishna|26 2 |#11:2|Customer|3 |kiran |29 3 |#11:3|Customer|4 |javeed |21 4 |#11:4|Customer|5 |raja |29 ----+-----+--------+----+-------+----
OrientDB - 显示记录
与 RDBMS 类似，OrientDB 支持不同类型的 SQL 查询来从数据库中检索记录。在检索记录时，我们有不同的查询变体或选项以及 select 语句。
以下是 SELECT 命令的基本语法。
SELECT [ <Projections> ] [ FROM <Target> [ LET <Assignment>* ] ] [ WHERE <Condition>* ] [ GROUP BY <Field>* ] [ ORDER BY <Fields>* [ ASC|DESC ] * ] [ UNWIND <Field>* ] [ SKIP <SkipRecords> ] [ LIMIT <MaxRecords> ] [ FETCHPLAN <FetchPlan> ] [ TIMEOUT <Timeout> [ <STRATEGY> ] ] [ LOCK default|record ] [ PARALLEL ] [ NOCACHE ]
以下是上述语法中选项的详细信息。
<Projections> − 指示您希望从查询中提取的数据作为结果记录集。
FROM − 指明要查询的对象。可以是类、集群、单个记录 ID 或一组记录 ID。您可以指定所有这些对象作为目标。
WHERE − 指定用于筛选结果集的条件。
LET − 指明在投影、条件或子查询中使用的上下文变量。
GROUP BY − 指明用于分组记录的字段。
ORDER BY − 指明用于按顺序排列记录的字段。
UNWIND − 指定要展开记录集合的字段。
SKIP − 定义要跳过结果集开头多少条记录。
LIMIT − 指明结果集中记录的最大数量。
FETCHPLAN − 指定定义如何获取结果的策略。
TIMEOUT − 定义查询的最大时间（毫秒）。
LOCK − 定义锁定策略。可用的锁定策略包括 DEFAULT 和 RECORD。
PARALLEL − 使用 ‘x’ 个并发线程执行查询。
NOCACHE − 定义是否要使用缓存。
示例
让我们考虑一下上一章中创建的客户表。
| 序号 | Name | Age |
|---|---|---|
| 1 | Satish | 25 |
| 2 | Krishna | 26 |
| 3 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | Raja | 29 |
尝试不同的 select 查询来从客户表中检索数据记录。
方法 1 − 您可以使用以下查询从客户表中选择所有记录。
orientdb {db = demo}> SELECT FROM Customer
如果以上查询成功执行，您将获得以下输出。
----+-----+--------+----+-------+---- # |@RID |@CLASS |id |name |age ----+-----+--------+----+-------+---- 0 |#11:0|Customer|1 |satish |25 1 |#11:1|Customer|2 |krishna|26 2 |#11:2|Customer|3 |kiran |29 3 |#11:3|Customer|4 |javeed |21 4 |#11:4|Customer|5 |raja |29 ----+-----+--------+----+-------+----
方法 2 − 选择所有名称以字母 'k' 开头的记录。
orientdb {db = demo}> SELECT FROM Customer WHERE name LIKE 'k%'
或者，您可以对上述示例使用以下查询。
orientdb {db = demo}> SELECT FROM Customer WHERE name.left(1) = 'k'
如果以上查询成功执行，您将获得以下输出。
----+-----+--------+----+-------+---- # |@RID |@CLASS |id |name |age ----+-----+--------+----+-------+---- 0 |#11:1|Customer|2 |krishna|26 1 |#11:2|Customer|3 |kiran |29 ----+-----+--------+----+-------+----
方法 3 − 从客户表中选择 id 和 name 记录，名称为大写字母。
orientdb {db = demo}> SELECT id, name.toUpperCase() FROM Customer
如果以上查询成功执行，您将获得以下输出。
----+--------+----+------- # |@CLASS |id |name ----+--------+----+------- 0 |null |1 |SATISH 1 |null |2 |KRISHNA 2 |null |3 |KIRAN 3 |null |4 |JAVEED 4 |null |5 |RAJA ----+--------+----+-------
方法 4 − 选择客户表中年龄在 25 到 29 之间的记录。
orientdb {db = demo}> SELECT FROM Customer WHERE age in [25,29]
如果以上查询成功执行，您将获得以下输出。
----+-----+--------+----+-------+---- # |@RID |@CLASS |id |name |age ----+-----+--------+----+-------+---- 0 |#11:0|Customer|1 |satish |25 1 |#11:2|Customer|3 |kiran |29 2 |#11:4|Customer|5 |raja |29 ----+-----+--------+----+-------+----
方法 5 − 选择客户表中任何字段包含单词“sh”的记录。
orientdb {db = demo}> SELECT FROM Customer WHERE ANY() LIKE '%sh%'
如果以上查询成功执行，您将获得以下输出。
----+-----+--------+----+-------+---- # |@RID |@CLASS |id |name |age ----+-----+--------+----+-------+---- 0 |#11:0|Customer|1 |satish |25 1 |#11:1|Customer|2 |krishna|26 ----+-----+--------+----+-------+----
方法 6 − 选择客户表中的所有记录，并按年龄降序排列。
orientdb {db = demo}> SELECT FROM Customer ORDER BY age DESC
如果以上查询成功执行，您将获得以下输出。
----+-----+--------+----+-------+---- # |@RID |@CLASS |id |name |age ----+-----+--------+----+-------+---- 0 |#11:2|Customer|3 |kiran |29 1 |#11:4|Customer|5 |raja |29 2 |#11:1|Customer|2 |krishna|26 3 |#11:0|Customer|1 |satish |25 4 |#11:3|Customer|4 |javeed |21 ----+-----+--------+----+-------+----
OrientDB - 加载记录
Load Record 用于从模式加载特定记录。Load record 将借助记录 ID 加载记录。它在结果集中用@rid 符号表示。
以下语句是 LOAD Record 命令的基本语法。
LOAD RECORD <record-id>
其中<record-id> 定义要加载的记录的记录 ID。
如果您不知道特定记录的记录 ID，则可以对表执行任何查询。在结果集中，您将找到相应记录的记录 ID（@rid）。
示例
让我们考虑一下我们在前几章中使用的相同的客户表。
| 序号 | Name | Age |
|---|---|---|
| 1 | Satish | 25 |
| 2 | Krishna | 26 |
| 3 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | Raja | 29 |
尝试以下查询来检索具有记录 ID @rid: #11:0 的记录。
orientdb {db = demo}> LOAD RECORD #11:0
如果以上查询成功执行，您将获得以下输出。
+---------------------------------------------------------------------------+ | Document - @class: Customer @rid: #11:0 @version: 1 | +---------------------------------------------------------------------------+ | Name | Value | +---------------------------------------------------------------------------+ | id | 1 | | name | satish | | age | 25 | +---------------------------------------------------------------------------+
OrientDB - 重新加载记录
Reload Record 的工作方式也类似于 Load Record 命令，也用于从模式加载特定记录。Load record 将借助记录 ID 加载记录。它在结果集中用@rid 符号表示。主要区别在于 Reload record 会忽略缓存，这在应用外部并发事务来更改记录时非常有用。它将提供最新的更新。
以下语句是 RELOAD Record 命令的基本语法。
RELOAD RECORD <record-id>
其中<record-id> 定义要重新加载的记录的记录 ID。
如果您不知道特定记录的记录 ID，则可以对表执行任何查询。在结果集中，您将找到相应记录的记录 ID（@rid）。
示例
让我们考虑一下我们在上一章中使用的相同的客户表。
| 序号 | Name | Age |
|---|---|---|
| 1 | Satish | 25 |
| 2 | Krishna | 26 |
| 3 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | Raja | 29 |
尝试以下查询来检索具有记录 ID @rid: #11:0 的记录。
orientdb {db = demo}> LOAD RECORD #11:0
如果以上查询成功执行，您将获得以下输出。
+---------------------------------------------------------------------------+ | Document - @class: Customer @rid: #11:0 @version: 1 | +---------------------------------------------------------------------------+ | Name | Value | +---------------------------------------------------------------------------+ | id | 1 | | name | satish | | age | 25 | +---------------------------------------------------------------------------+
OrientDB - 导出记录
Export Record 命令用于将加载的记录导出到请求的和支持的格式。如果您执行任何错误的语法，它将提供支持的格式列表。OrientDB 是文档数据库系列，因此 JSON 是默认支持的格式。
以下语句是 Export Record 命令的基本语法。
EXPORT RECORD <format>
其中<Format> 定义您想要获取记录的格式。
注意 − Export 命令将基于记录 ID 导出加载的记录。
示例
让我们考虑一下我们在上一章中使用的相同的客户表。
| 序号 | Name | Age |
|---|---|---|
| 1 | Satish | 25 |
| 2 | Krishna | 26 |
| 3 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | Raja | 29 |
尝试以下查询来检索具有记录 ID @rid: #11:0 的记录。
orientdb {db = demo}> LOAD RECORD #11:0
如果以上查询成功执行，您将获得以下输出。
+---------------------------------------------------------------------------+ | Document - @class: Customer @rid: #11:0 @version: 1 | +---------------------------------------------------------------------------+ | Name | Value | +---------------------------------------------------------------------------+ | id | 1 | | name | satish | | age | 25 | +---------------------------------------------------------------------------+
使用以下查询将加载的记录（#11:0）导出为 JSON 格式。
orientdb {db = demo}> EXPORT RECORD json
如果以上查询成功执行，您将获得以下输出。
{
"@type": "d",
"@rid": "#11:0",
"@version": 1,
"@class": "Customer",
"id": 1,
"name": "satish",
"age": 25
}
OrientDB - 更新记录
Update Record 命令用于修改特定记录的值。SET 是更新特定字段值的命令。
以下语句是 Update 命令的基本语法。
UPDATE <class>|cluster:<cluster>|<recordID> [SET|INCREMENT|ADD|REMOVE|PUT <field-name> = <field-value>[,]*] |[CONTENT| MERGE <JSON>] [UPSERT] [RETURN <returning> [<returning-expression>]] [WHERE <conditions>] [LOCK default|record] [LIMIT <max-records>] [TIMEOUT <timeout>]
以下是上述语法中选项的详细信息。
SET − 定义要更新的字段。
INCREMENT − 将指定字段的值增加给定值。
ADD − 将新项目添加到集合字段中。
REMOVE − 从集合字段中删除项目。
PUT − 将条目放入映射字段中。
CONTENT − 用 JSON 文档内容替换记录内容。
MERGE − 将记录内容与 JSON 文档合并。
LOCK − 指定如何在加载和更新之间锁定记录。我们有两个选项可以指定Default 和 Record。
UPSERT − 如果记录存在则更新记录，如果不存在则插入新记录。它有助于在一个查询中执行两个查询的操作。
RETURN − 指定要返回的表达式，而不是记录数。
LIMIT − 定义要更新的记录的最大数量。
TIMEOUT − 定义您希望更新运行的时间，超过此时间将超时。
示例
让我们考虑一下我们在上一章中使用的相同的客户表。
| 序号 | Name | Age |
|---|---|---|
| 1 | Satish | 25 |
| 2 | Krishna | 26 |
| 3 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | Raja | 29 |
尝试以下查询来更新客户“Raja”的年龄。
Orientdb {db = demo}> UPDATE Customer SET age = 28 WHERE name = 'Raja'
如果以上查询成功执行，您将获得以下输出。
Updated 1 record(s) in 0.008000 sec(s).
要检查客户表的记录，您可以使用以下查询。
orientdb {db = demo}> SELECT FROM Customer
如果以上查询成功执行，您将获得以下输出。
----+-----+--------+----+-------+---- # |@RID |@CLASS |id |name |age ----+-----+--------+----+-------+---- 0 |#11:0|Customer|1 |satish |25 1 |#11:1|Customer|2 |krishna|26 2 |#11:2|Customer|3 |kiran |29 3 |#11:3|Customer|4 |javeed |21 4 |#11:4|Customer|5 |raja |28 ----+-----+--------+----+-------+----
OrientDB - 清空记录
Truncate Record 命令用于删除特定记录的值。
以下语句是 Truncate 命令的基本语法。
TRUNCATE RECORD <rid>*
其中<rid>* 表示要截断的记录 ID。您可以使用逗号分隔多个 Rid 来截断多个记录。它返回被截断的记录数。
示例
让我们考虑一下我们在上一章中使用的相同的客户表。
| 序号 | Name | Age |
|---|---|---|
| 1 | Satish | 25 |
| 2 | Krishna | 26 |
| 3 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | Raja | 28 |
尝试以下查询来截断具有记录 ID #11:4 的记录。
Orientdb {db = demo}> TRUNCATE RECORD #11:4
如果以上查询成功执行，您将获得以下输出。
Truncated 1 record(s) in 0.008000 sec(s).
要检查客户表的记录，您可以使用以下查询。
Orientdb {db = demo}> SELECT FROM Customer
如果以上查询成功执行，您将获得以下输出。
----+-----+--------+----+-------+---- # |@RID |@CLASS |id |name |age ----+-----+--------+----+-------+---- 0 |#11:0|Customer|1 |satish |25 1 |#11:1|Customer|2 |krishna|26 2 |#11:2|Customer|3 |kiran |29 3 |#11:3|Customer|4 |javeed |21 ----+-----+--------+----+-------+----
OrientDB - 删除记录
Delete Record 命令用于从数据库中完全删除一个或多个记录。
以下语句是 Delete 命令的基本语法。
DELETE FROM <Class>|cluster:<cluster>|index:<index> [LOCK <default|record>] [RETURN <returning>] [WHERE <Condition>*] [LIMIT <MaxRecords>] [TIMEOUT <timeout>]
以下是上述语法中选项的详细信息。
LOCK − 指定如何在加载和更新之间锁定记录。我们有两个选项可以指定Default 和 Record。
RETURN − 指定要返回的表达式，而不是记录数。
LIMIT − 定义要更新的记录的最大数量。
TIMEOUT − 定义您希望更新运行的时间，超过此时间将超时。
注意 − 不要使用 DELETE 删除顶点或边，因为它会影响图的完整性。
示例
让我们考虑一下客户表。
| 序号 | Name | Age |
|---|---|---|
| 1 | Satish | 25 |
| 2 | Krishna | 26 |
| 3 | Kiran | 29 |
| 4 | Javeed | 21 |
尝试以下查询删除 id = 4 的记录。
orientdb {db = demo}> DELETE FROM Customer WHERE id = 4
如果以上查询成功执行，您将获得以下输出。
Delete 1 record(s) in 0.008000 sec(s).
要检查客户表的记录，您可以使用以下查询。
Orientdb {db = demo}> SELECT FROM Customer
如果以上查询成功执行，您将获得以下输出。
----+-----+--------+----+-------+---- # |@RID |@CLASS |id |name |age ----+-----+--------+----+-------+---- 0 |#11:0|Customer|1 |satish |25 1 |#11:1|Customer|2 |krishna|26 2 |#11:2|Customer|3 |kiran |29 ----+-----+--------+----+-------+----
OrientDB - 创建类
OrientDB 支持多模型功能，并提供不同的方法来处理和理解数据库的基本概念。但是，我们可以从文档数据库 API 的角度轻松访问这些模型。像 RDBMS 一样，OrientDB 也使用记录作为存储元素，但它使用文档类型。文档以键值对的形式存储。我们将字段和属性作为属于概念类的键值对存储。
类是一种数据模型类型，其概念源自面向对象编程范式。基于传统的文档数据库模型，数据以集合的形式存储，而在关系数据库模型中，数据存储在表中。OrientDB 遵循文档 API 以及 OPPS 范式。作为一个概念，OrientDB 中的类与关系数据库中的表关系最密切，但（与表不同）类可以是无模式的、有模式的或混合的。类可以从其他类继承，创建类树。每个类都有它自己的集群或集群（如果未定义，则默认创建）。
以下语句是 Create Class 命令的基本语法。
CREATE CLASS <class> [EXTENDS <super-class>] [CLUSTER <cluster-id>*] [CLUSTERS <total-cluster-number>] [ABSTRACT]
以下是上述语法中选项的详细信息。
<class> − 定义要创建的类的名称。
<super-class> − 定义要以此类扩展的超类。
<total-cluster-number> − 定义此类中使用的集群总数。默认为 1。
ABSTARCT − 定义类为抽象类。这是可选的。
示例
如上所述，类是一个与表相关的概念。因此，在这里我们将创建一个名为 Account 的表。但是，在创建类时，我们不能根据 OOPS 范式定义字段，即属性。
以下命令用于创建一个名为 Account 的类。
orientdb> CREATE CLASS Account
如果以上命令成功执行，您将获得以下输出。
Class created successfully
您可以使用以下命令创建一个扩展类Vehicle的类Car。
orientdb> CREATE CLASS Car EXTENDS Vehicle
如果以上命令成功执行，您将获得以下输出。
Class created successfully
您可以使用以下命令创建一个名为 Person 的抽象类。
orientdb> CREATE CLASS Person ABSTRACT
如果以上命令成功执行，您将获得以下输出。
Class created successfully
注意 − 没有属性的类是无用的，无法构建真实的类。
OrientDB - 修改类
OrientDB 中的类和属性用于构建具有相应属性（例如类名、超类、集群、集群数、Abstract 等）的模式。如果要修改或更新模式中现有类的任何属性，则必须使用Alter Class 命令。
以下语句是 Alter Class 命令的基本语法。
ALTER CLASS <class> <attribute-name> <attribute-value>
以下是上述语法中选项的详细信息。
<class> − 定义类名。
<attribute-name> − 定义要更改的属性。
<attribute-value> − 定义要为属性设置的值。
下表定义了支持 Alter Class 命令的属性列表。
| 属性 | 类型 | 描述 |
|---|---|---|
| NAME | 字符串 | 更改类名。 |
| SHORTNAME | 字符串 | 为类定义短名称（即别名）。使用 NULL 删除短名称赋值。 |
| SUPERCLASS | 字符串 | 为类定义超类。要添加新类，可以使用语法 +<class>，要删除它，可以使用 -<class>。 |
| OVERSIZE | 十进制数 | 定义超大因子。 |
| ADDCLUSTER | 字符串 | 向类添加集群。如果集群不存在，它将创建一个物理集群。向类添加集群在分布式服务器中存储记录也很有用。 |
| REMOVECLUSTER | 字符串 | 从类中删除集群。它不会删除集群，只会将其从类中删除。 |
| STRICTMODE | - | 启用或禁用严格模式。在严格模式下，您在完全模式下工作，如果属性是类模式定义的一部分，则无法向记录添加新属性。 |
| CLUSTERSELECTION | - | 定义选择策略，用于选择为新记录使用哪个集群。 |
| CUSTOM | - | 定义自定义属性。属性名称和值必须遵循语法 <propertyname>=<value>，名称和值之间没有空格。 |
| ABSTRACT | 布尔值 | 将类转换为抽象类或相反。 |
示例
让我们尝试一些将更新或修改现有类属性的示例。
以下查询用于为现有类“Employee”定义一个超类“Person”。
orientdb> ALTER CLASS Employee SUPERCLASS Person
如果以上查询成功执行，您将获得以下输出。
Class altered successfully
以下查询用于为现有类“Employee”添加一个超类“Person”。
orientdb> ALTER CLASS Employee SUPERCLASS +Person
如果以上查询成功执行，您将获得以下输出。
Class altered successfully
OrientDB - 清空类
Truncate class 将删除定义为类一部分的所有集群的记录。在 OrientDB 中，每个类都具有与之关联的同名集群。如果还想要从类层次结构中删除所有记录，则需要使用 POLYMORPHIC 关键字。
以下语句是 Truncate Class 命令的基本语法。
TRUNCATE CLASS <class> [ POLYMORPHIC ] [ UNSAFE ]
以下是上述语法中选项的详细信息。
<class> − 定义要截断的类。
多态 (POLYMORPHIC) − 定义命令是否也截断层次结构。
不安全 (UNSAFE) − 定义命令强制截断顶点或边类。
示例
以下查询用于截断Profile类。
orientdb> TRUNCATE CLASS Profile
如果以上查询成功执行，您将获得以下输出。
Class truncated successfully
OrientDB - 删除类
删除类 (Drop Class) 命令从模式中删除一个类。注意并维护一致的模式非常重要。例如，避免删除作为其他类的超类的类。关联的集群不会被删除。
以下语句是 Drop Class 命令的基本语法。
DROP CLASS <class>
删除具有类名称的类。
示例
尝试以下查询以删除 Employee 类。
Orientdb> DROP CLASS Employee
如果以上查询成功执行，您将获得以下输出。
Class dropped successfully
OrientDB - 创建集群
集群 (Cluster) 是 OrientDB 中的一个重要概念，用于存储记录、文档或顶点。简单来说，集群是存储一组记录的地方。默认情况下，OrientDB 将为每个类创建一个集群。一个类的所有记录都存储在同一个集群中，该集群与类的名称相同。您可以在数据库中创建最多 32,767 (2^15-1) 个集群。
CREATE class 命令用于创建具有特定名称的集群。创建集群后，您可以通过在创建任何数据模型时指定名称来使用集群保存记录。如果要向类添加新的集群，请使用 Alter Class 命令和 ADDCLUSTER 命令。
以下语句是 Create Cluster 命令的基本语法。
CREATE CLUSTER <cluster> [ID <cluster-id>]
其中<cluster> 定义要创建的集群的名称，<cluster-id> 定义要用于集群的数字 ID。
下表提供了集群选择策略的列表。
| 序号 | 策略 & 描述 |
|---|---|
| 1 | 默认 (Default) 使用类属性 default ClusterId 选择集群。 |
| 2 | 轮询 (Round-robin) 按循环顺序选择下一个集群。完成后重新启动。 |
| 3 | 平衡 (Balanced) 选择最小的集群。允许类在大小上平衡所有底层集群。向现有类添加新集群时，它会先填充新集群。 |
示例
让我们以创建名为 sales 的集群为例。
orientdb> CREATE CLUSTER sales
如果以上查询成功执行，您将获得以下输出。
Cluster created correctly with id #12
OrientDB - 修改集群
修改集群 (Alter Cluster) 命令用于更新现有集群上的属性。在本节中，您可以学习如何添加或修改集群的属性。
以下语句是 Alter Cluster 命令的基本语法。
ALTER CLUSTER <cluster> <attribute-name> <attribute-value>
以下是上述语法中选项的详细信息。
<cluster> − 定义集群名称。
<attribute-name> − 定义要更改的属性。
<attribute-value> − 定义要为此属性设置的值。
下表提供了您可以与 Alter cluster 命令一起使用的受支持属性列表。
| Name | 类型 | 描述 |
|---|---|---|
| NAME | 字符串 | 更改集群名称。 |
| STATUS | 字符串 | 更改集群状态。允许的值为 ONLINE 和 OFFLINE。默认情况下，集群处于联机状态。 |
| 压缩 (COMPRESSION) | 字符串 | 定义要使用的压缩类型。允许的值为 NOTHING、SNAPPY、GZIP 和在 OCompressionFactory 类中注册的任何其他压缩类型。 |
| 使用写前日志 (USE_WAL) | 布尔值 | 定义 OrientDB 对集群进行操作时是否使用日志。 |
| 记录增长因子 (RECORD_GROW_FACTOR) | 整数 | 定义增长因子以在记录创建时节省更多空间。当您使用附加信息更新记录时，您可能会发现这很有用。 |
| 记录溢出增长因子 (RECORD_OVERFLOW_GROW_FACTOR) | 整数 | 定义更新时的增长因子。当它达到大小限制时，它使用此设置来获取更多空间 (因子 > 1)。 |
| 冲突策略 (CONFLICTSTRATEGY) | 字符串 | 定义它用于处理冲突的策略，如果 OrientDB MVCC 发现它对旧记录执行的更新或删除操作。 |
下表提供了冲突策略的列表。
| 序号 | 策略 & 描述 |
|---|---|
| 1 | 版本 (Version) 版本不同时抛出异常。这是默认设置。 |
| 2 | 内容 (Content) 如果版本不同，则检查内容的更改，否则使用最高版本以避免抛出异常。 |
| 3 | 自动合并 (Automerge) 合并更改。 |
示例
尝试以下示例查询以了解 Alter cluster 命令。
执行以下命令将集群的名称从 Employee 更改为 Employee2。
orientdb {db = demo}> ALTER CLUSTER Employee NAME Employee2
如果以上命令成功执行，您将获得以下输出。
Cluster updated successfully
执行以下命令使用集群 ID 将集群的名称从 Employee2 更改为 Employee。
orientdb {db = demo}> ALTER CLUSTER 12 NAME Employee
如果以上命令成功执行，您将获得以下输出。
Cluster updated successfully
执行以下命令将集群冲突策略更改为自动合并。
orientdb {db = demo}> ALTER CLUSTER V CONFICTSTRATEGY automerge
如果以上命令成功执行，您将获得以下输出。
Cluster updated successfully
OrientDB - 清空集群
截断集群 (Truncate Cluster) 命令删除集群的所有记录。
以下语句是 Truncate Cluster 命令的基本语法。
TRUNCATE CLUSTER <cluster-name>
其中<cluster-name> 是集群的名称。
示例
尝试以下查询以截断名为 sales 的集群。
Orientdb {db = demo}> TRUNCATE CLUSTER Profile
如果以上查询成功执行，您将获得以下输出。
Cluster truncated successfully.
OrientDB - 删除集群
删除集群 (Drop Cluster) 命令删除集群及其所有相关内容。此操作是永久性的，不可回滚。
以下语句是 Drop Cluster 命令的基本语法。
DROP CLUSTER <cluster-name>|<cluster-id>
其中<cluster-name> 定义要删除的集群的名称，<cluster-id> 定义要删除的集群的 ID。
示例
尝试以下命令删除 Sales 集群。
orientdb> DROP CLUSTER Sales
如果以上查询成功执行，您将获得以下输出。
Cluster dropped successfully
OrientDB - 创建属性
OrientDB 中的属性 (Property) 类似于类中的字段和数据库表中的列。创建属性 (Create Property) 是为特定类创建属性的命令。您在命令中使用的类名必须存在。
以下语句是 Create Property 命令的基本语法。
CREATE PROPERTY <class-name>.<property-name> <property-type> [<linked-type>][ <linked-class>]
以下是上述语法中选项的详细信息。
<class-name> − 定义要在其中创建属性的类。
<property-name> − 定义属性的逻辑名称。
<property-type> − 定义要创建的属性的类型。
<linked-type> − 定义容器类型，用于容器属性类型。
<linked-class> − 定义容器类，用于容器属性类型。
下表提供了属性的数据类型，以便 OrientDB 知道要存储的数据类型。
| 布尔型 (BOOLEAN) | 整数型 (INTEGER) | 短整型 (SHORT) | 长整型 (LONG) |
| 浮点型 (FLOAT) | 日期型 (DATE) | 字符串型 (STRING) | 嵌入型 (EMBEDDED) |
| 链接型 (LINK) | 字节型 (BYTE) | 二进制型 (BINARY) | 双精度型 (DOUBLE) |
除了这些之外，还有几种其他属性类型可以用作容器。
| 嵌入列表 (EMBEDDEDLIST) | 嵌入集合 (EMBEDDEDSET) | 嵌入映射 (EMBEDDEDMAP) |
| 链接列表 (LINKLIST) | 链接集合 (LINKSET) | 链接映射 (LINKMAP) |
示例
尝试以下示例以在 Employee 类中创建名为 name 的字符串类型属性。
orientdb> CREATE PROPERTY Employee.name STRING
如果以上查询成功执行，您将获得以下输出。
Property created successfully with id = 1
OrientDB - 修改属性
修改属性 (Alter Property) 是用于修改或更新特定类的属性的命令。修改属性意味着修改表的字段。在本节中，您可以学习如何更新属性。
以下语句是 Alter Property 命令的基本语法。
ALTER PROPERTY <class>.<property> <attribute-name> <attribute-value>
以下是上述语法中选项的详细信息。
<class> − 定义属性所属的类。
<property> − 定义要更新的属性。
<attribute-name> − 定义要更新的属性的属性。
<attribute-value> − 定义要为此属性设置的值。
下表定义了用于修改属性的属性列表。
| 属性 | 类型 | 描述 |
|---|---|---|
| 关联类 (LINKEDCLASS) | 字符串 | 定义关联的类名。使用 NULL 删除现有值。 |
| 关联类型 (LINKEDTYPE) | 字符串 | 定义链接类型。使用 NULL 删除现有值。 |
| 最小值 (MIN) | 整数 | 定义最小值作为约束。使用 NULL 删除现有约束。 |
| 必填 (MANDATORY) | 布尔值 | 定义属性是否需要值。 |
| 最大值 (MAX) | 整数 | 定义最大值作为约束。使用 NULL 删除现有约束。 |
| NAME | 字符串 | 定义属性名称。 |
| 非空 (NOTNULL) | 布尔值 | 定义属性是否可以具有 NULL 值。 |
| 正则表达式 (REGEX) | 字符串 | 定义正则表达式作为约束。使用 NULL 删除现有约束。 |
| 类型 (TYPE) | 字符串 | 定义属性类型。 |
| 排序规则 (COLLATE) | 字符串 | 将排序规则设置为已定义的比较策略之一。默认情况下，它设置为区分大小写 (cs)。您也可以将其设置为不区分大小写 (ci)。 |
| 只读 (READONLY) | 布尔值 | 定义属性值是否不可变。也就是说，是否可以在第一次赋值后更改它。与 DEFAULT 一起使用可在创建时具有不可变的值。 |
| CUSTOM | 字符串 | 定义自定义属性。自定义属性的语法为 <custom-name> = <custom-value>，例如 stereotype = icon。 |
| 默认值 (DEFAULT) | 定义默认值或函数。 |
注意 − 如果您正在更改 NAME 或 TYPE，则此命令将需要一些时间来更新，具体取决于数据量。
示例
尝试以下一些查询来了解 Alter property。
执行以下查询以将 Customer 类中属性的名称从“age”更改为“born”。
orinetdb {db = demo}> ALTER PROPERTY Customer.age NAME born
如果以上查询成功执行，您将获得以下输出。
Property altered successfully
执行以下查询以将“name”设为“Customer”类的必填属性。
orientdb {db = demo}> ALTER PROPERTY Customer.name MANDATORY TRUE
如果以上查询成功执行，您将获得以下输出。
Property altered successfully
OrientDB - 删除属性
删除属性 (Drop property) 命令从模式中删除属性。它不会从记录中删除属性值，它只是更改模式。
以下语句是 Drop Property 命令的基本语法。
DROP PROPERTY <class>.<property> [FORCE]
以下是上述语法中选项的详细信息。
<class> − 定义属性存在的类。
<property> − 定义要删除的属性。
[Force] − 如果在属性上定义了一个或多个索引。
示例
尝试以下命令从“Customer”类中删除“age”属性。
orientdb> DROP PROPERTY Customer.age
如果以上命令成功执行，您将获得以下输出。
Property dropped successfully
OrientDB - 创建顶点
OrientDB 数据库不仅是文档数据库，也是图数据库。顶点和边等新概念用于以图的形式存储数据。它对顶点应用多态性。顶点的基类是 V。
在本节中，您可以学习如何创建顶点以存储图数据。
以下语句是 Create Vertex 命令的基本语法。
CREATE VERTEX [<class>] [CLUSTER <cluster>] [SET <field> = <expression>[,]*]
以下是上述语法中选项的详细信息。
<class> − 定义顶点所属的类。
<cluster> − 定义存储顶点的集群。
<field> − 定义要设置的字段。
<expression> − 定义要为字段设置的表达式。
示例
尝试以下示例以了解如何创建顶点。
执行以下查询以在基类 V 上创建没有“name”的顶点。
orientdb> CREATE VERTEX
如果以上查询成功执行，您将获得以下输出。
Created vertex 'V#9:0 v1' in 0.118000 sec(s)
执行以下查询以创建一个名为 v1 的新顶点类，然后在该类中创建顶点。
orientdb> CREATE CLASS V1 EXTENDS V orientdb> CREATE VERTEX V1
如果以上查询成功执行，您将获得以下输出。
Created vertex 'V1#14:0 v1' in 0.004000 sec(s)
执行以下查询以创建一个名为 v1 的类的新的顶点，定义其属性，例如 brand = 'Maruti' 和 name = 'Swift'。
orientdb> CREATE VERTEX V1 SET brand = 'maruti', name = 'swift'
如果以上查询成功执行，您将获得以下输出。
Created vertex 'V1#14:1{brand:maruti,name:swift} v1' in 0.004000 sec(s)
OrientDB - 移动顶点
OrientDB 中的移动顶点 (Move Vertex) 命令用于将一个或多个顶点从当前位置移动到不同的类或集群。如果您将移动命令应用于特定顶点，则它将更新连接到此顶点的所有边。如果您指定一个集群来移动顶点，则它会将顶点移动到目标集群的服务器所有者。
以下语句是 Move Vertex 命令的基本语法。
MOVE VERTEX <source> TO <destination> [SET [<field>=<value>]* [,]] [MERGE <JSON>] [BATCH <batch-size>]
以下是上述语法中选项的详细信息。
<source> − 定义要移动的顶点。它接受特定顶点的记录 ID 或顶点的记录 ID 数组。
<destination> − 定义要将顶点移动到的位置。它支持类或集群作为目标。
SET − 将值设置为字段。
MERGE − 通过 JSON 将值设置为字段。
BATCH − 定义批处理大小。
注意 − 此命令更新所有连接的边，但不更新链接。使用图 API 时，建议使用连接到顶点的边。
示例
尝试以下示例以学习如何移动顶点。
执行以下查询以将具有记录 ID #11:2 的单个顶点从其当前位置移动到 Employee 类。
orientdb> MOVE VERTEX #11:2 TO CLASS:Employee
如果以上查询成功执行，您将得到以下输出：
Move vertex command executed with result '[{old:#11:2, new:#13:0}]' in 0.022000 sec(s)
执行以下查询将一组顶点从“Customer”类移动到“Employee”类。
orientdb> MOVE VERTEX (SELECT FROM Customer) TO CLASS:Employee
如果以上查询成功执行，您将获得以下输出。
Move vertex command executed with result '[{old:#11:0,
new:#13:1},{old:#11:1, new:#13:2},{old:#11:2, new:#13:3}]' in 0.011000 sec(s)
OrientDB - 删除顶点
删除顶点命令用于从数据库中删除顶点。删除时，它会检查并维护与边的 consistency，并删除所有与已删除顶点的交叉引用（与边一起）。
以下语句是删除顶点命令的基本语法。
DELETE VERTEX <vertex> [WHERE <conditions>] [LIMIT <MaxRecords>>] [BATCH <batch-size>]
以下是上述语法中选项的详细信息。
<vertex> − 定义要删除的顶点，可以使用其类、记录 ID 或子查询。
WHERE − 筛选条件，用于确定命令删除哪些记录。
LIMIT − 定义要删除的最大记录数。
BATCH − 定义命令一次删除多少条记录，允许您将大型事务分解成较小的块以节省内存使用。
示例
尝试以下命令来学习如何删除单个顶点或多个顶点。
执行以下命令删除顶点“#14:1”。
orientdb> DELETE VERTEX #14:1
如果以上命令成功执行，您将获得以下输出。
Delete record(s) '1' in 0.005000 sec(s)
执行以下命令删除“Customer”类中所有标记为“isSpam”属性的顶点。
orientdb> DELETE VERTEX Customer WHERE isSpam = TRUE
如果以上命令成功执行，您将获得以下输出。
Delete record(s) '3' in 0.005000 sec(s)
OrientDB - 创建边
在 OrientDB 中，边的概念就像借助某些属性在顶点之间建立的关系一样。边和顶点是图数据库的主要组成部分。它对边应用多态性。边的基类是 E。在实现边时，如果源顶点或目标顶点丢失或不存在，则事务将回滚。
以下语句是创建边命令的基本语法。
CREATE EDGE <class> [CLUSTER <cluster>] FROM <rid>|(<query>)|[<rid>]* TO <rid>|(<query>)|[<rid>]*
[SET <field> = <expression>[,]*]|CONTENT {<JSON>}
[RETRY <retry> [WAIT <pauseBetweenRetriesInMs]] [BATCH <batch-size>]
以下是上述语法中选项的详细信息。
<class> − 定义边的类名。
<cluster> − 定义要存储边的集群。
JSON − 提供要设置为记录的 JSON 内容。
RETRY − 定义在发生冲突时尝试的重试次数。
WAIT − 定义重试之间延迟的时间（毫秒）。
BATCH − 定义是否将命令分解成较小的块以及批次的 size。
示例
执行以下查询在两个顶点 #9:0 和 #14:0 之间创建一条边 E。
orientdb> CREATE EDGE FROM #11:4 TO #13:2
如果以上查询成功执行，您将获得以下输出。
Created edge '[e[#10:0][#9:0->#14:0]]' in 0.012000 sec(s)
执行以下查询创建一个新的边类型和一个新类型的边。
orientdb> CREATE CLASS E1 EXTENDS E orientdb> CREATE EDGE E1 FROM #10:3 TO #11:4
如果以上查询成功执行，您将获得以下输出。
Created edge '[e[#10:1][#10:3->#11:4]]' in 0.011000 sec(s)
OrientDB - 更新边
更新边命令用于更新当前数据库中的边记录。这相当于实际的更新命令，此外还检查并维护与顶点的图一致性，如果您更新out和in属性。
以下语句是更新边命令的基本语法。
UPDATE EDGE <edge> [SET|INCREMENT|ADD|REMOVE|PUT <field-name> = <field-value> [,]*]|[CONTENT|MERGE <JSON>] [RETURN <returning> [<returning-expression>]] [WHERE <conditions>] [LOCK default|record] [LIMIT <max-records>] [TIMEOUT <timeout>]
以下是上述语法中选项的详细信息。
<edge> − 定义要更新的边。您可以选择Class（按类更新边）、Cluster（使用 CLUSTER 前缀按集群更新边）或Record ID（按记录 ID 更新边）。
SET − 将字段更新为给定值。
INCREMENT − 将给定字段的值递增。
ADD − 定义要添加到字段集合的项目。
REMOVE − 定义要从字段集合中删除的项目。
PUT − 定义要放入映射字段的条目。
RETURN − 定义运行更新后要返回的表达式。
WHERE − 定义筛选条件。
LOCK − 定义加载和更新之间的记录锁定方式。
LIMIT − 定义最大记录数。
示例
让我们考虑一个更新 person 类中名为“address”的边的示例，该边从 area Id = 001 和 person name = Krishna 的 address 表中获取数据。
orientdb> UPDATE EDGE address SET out = (SELECT FROM Address WHERE areaID = 001) WHERE name = 'krishna'
如果以上查询成功执行，您将获得以下输出。
Updated edge '[address[#10:3][#11:3->#14:2]]' in 0.012000 sec(s)
OrientDB - 删除边
删除边命令用于删除数据库。这相当于 delete 命令，此外还通过从“in”和“out”顶点属性中删除所有交叉引用来检查并维护与顶点的一致性。
以下语句是删除边命令的基本语法。
DELETE EDGE
( <rid>
|
[<rid> (, <rid>)*]
|
( [ FROM (<rid> | <select_statement> ) ] [ TO ( <rid> | <select_statement> ) ] )
|
[<class>]
(
[WHERE <conditions>]
[LIMIT <MaxRecords>]
[BATCH <batch-size>]
))
以下是上述语法中选项的详细信息。
FROM − 定义要删除边的起点顶点。
To − 定义要删除边的终点顶点。
WHERE − 定义筛选条件。
LIMIT − 定义要删除的最大边数。
BATCH − 定义操作的块 size。
示例
尝试以下示例来学习如何删除边。
执行以下查询删除两个顶点（#11:2，#11:10）之间的边。但是，两个顶点之间可能存在一条或多条边。因此，我们使用 date 属性来实现正确的功能。此查询将删除于“2015-01-15”及以后创建的边。
orientdb {db = demo}> DELETE EDGE FROM #11:2 TO #11:10 WHERE date >= "2012-01-15"
如果以上查询成功执行，您将获得以下输出。
Delete record(s) '2' in 0.00200 sec(s)
执行以下查询删除从顶点“#11:5”到顶点“#11:10”并且与“class = Customer”相关的边。
orientdb {db = demo}> DELETE EDGE FROM #11:5 TO #11:10 WHERE @class = 'Customer'
如果以上查询成功执行，您将获得以下输出。
Delete record(s) '2' in 0.00200 sec(s)
OrientDB - 函数
本章解释了 OrientDB 中不同类型函数的完整参考。下表定义了按功能分类的函数列表。
图函数
尝试一些图函数以及以下查询。
执行以下查询以获取所有车辆顶点的所有出度顶点。
orientdb {db = demo}>SELECT out() from Vehicle
如果以上查询成功执行，您将获得以下输出。
---+----------+--------- # | @class | out ---+----------+--------- 0 | Vehicle | #11:2 1 | Vehicle | #13:1 2 | Vehicle | #13:4 ---+----------+---------
执行以下查询以获取顶点 #11:3 的所有入度和出度顶点。
orientdb {db = demo}>SELECT both() FROM #11:3
如果以上查询成功执行，您将获得以下输出。
---+----------+--------+------- # | @class | out | in ---+----------+--------+------- 0 | Vehicle | #13:2 | #10:2 ---+----------+-------+-------
数学函数
尝试使用以下查询使用一些数学函数。
执行以下查询以获取所有员工的薪资总和。
orientdb {db = demo}>SELECT SUM(salary) FROM Employee
如果以上查询成功执行，您将获得以下输出。
---+----------+--------- # | @CLASS | sum ---+----------+--------- 0 | null | 150000 ---+----------+---------
执行以下查询以获取所有员工的平均薪资。
orientdb {db = demo}>SELECT avg(salary) FROM Employee
如果以上查询成功执行，您将获得以下输出。
---+----------+--------- # | @CLASS | avg ---+----------+--------- 0 | null | 25 ---+----------+---------
集合函数
使用以下查询尝试一些集合函数。
执行以下查询以获取教授九年级课程的教师集合。
orientdb {db = demo}>SELECT ID, set(teacher.id) AS teacherID from classess where class_id = 9
如果以上查询成功执行，您将获得以下输出。
---+----------+--------+-------------------------- # | @CLASS | id | TeacherID ---+----------+--------+-------------------------- 0 | null | 9 | 1201, 1202, 1205, 1208 ---+----------+-------+---------------------------
杂项函数
使用以下查询尝试一些杂项函数。
执行以下查询以了解如何执行if表达式。
orientdb {db = demo}> SELECT if(eval("name = 'satish'"), "My name is satish",
"My name is not satish") FROM Employee
如果以上查询成功执行，您将获得以下输出。
----+--------+----------------------- # |@CLASS | IF ----+--------+----------------------- 0 |null |My name is satish 1 |null |My name is not satish 2 |null |My name is not satish 3 |null |My name is not satish 4 |null |My name is not satish ----+--------+------------------------
执行以下查询以获取系统日期。
orientdb {db = demo}> SELECT SYSDATE() FROM Employee
如果以上查询成功执行，您将获得以下输出。
----+--------+----------------------- # |@CLASS | SYSDATE ----+--------+----------------------- 0 |null |2016-02-10 12:05:06 1 |null |2016-02-10 12:05:06 2 |null |2016-02-10 12:05:06 3 |null |2016-02-10 12:05:06 4 |null |2016-02-10 12:05:06 ----+--------+------------------------
通过彻底使用此函数，您可以轻松地操作OrientDB数据。
OrientDB - 序列
序列是自动递增机制中使用的概念，它在OrientDB v2.2中引入。在数据库术语中，序列是管理计数器字段的结构。简单地说，序列主要用于需要始终递增的数字。它支持两种类型：
ORDERED − 每当指针调用返回新值的.next方法时。
CACHED − 序列将在每个节点上缓存“N”个项目。要调用每个项目，我们使用.next()，当缓存包含多个项目时，这是首选。
创建序列
序列通常用于自动递增人员的ID值。与OrientDB的其他SQL概念一样，它也执行与RDBMS中的序列类似的操作。
以下语句是创建序列的基本语法。
CREATE SEQUENCE <sequence> TYPE <CACHED|ORDERED> [START <start>] [INCREMENT <increment>] [CACHE <cache>]
以下是上述语法中选项的详细信息。
<Sequence> − 序列的本地名称。
TYPE − 定义序列类型ORDERED或CACHED。
START − 定义初始值。
INCREMENT − 定义每次.next方法调用时的增量。
CACHE − 定义要预缓存的值的数量，如果您使用的是缓存序列类型。
让我们创建一个名为“seqid”的序列，它从数字1201开始。尝试以下查询以使用序列实现此示例。
CREATE SEQUENCE seqid START 1201
如果以上查询成功执行，您将获得以下输出。
Sequence created successfully
尝试以下查询以使用序列“seqid”插入Account表的id值。
INSERT INTO Account SET id = sequence('seqid').next()
如果以上查询成功执行，您将获得以下输出。
Insert 1 record(s) in 0.001000 sec(s)
更改序列
更改序列是用于更改序列属性的命令。它将修改所有序列选项，除了序列类型。
以下语句是更改序列的基本语法。
ALTER SEQUENCE <sequence> [START <start-point>] [INCREMENT <increment>] [CACHE <cache>]
以下是上述语法中选项的详细信息。
<Sequence> − 定义您要更改的序列。
START − 定义初始值。
INCREMENT − 定义每次.next方法调用时的增量。
CACHE − 定义要预缓存的值的数量，如果您使用的是缓存序列类型。
尝试以下查询将名为seqid的序列的起始值从“1201”更改为“1000”。
ALTER SEQUENCE seqid START 1000
如果以上查询成功执行，您将获得以下输出。
Altered sequence successfully
删除序列
删除序列是用于删除序列的命令。
以下语句是删除序列的基本语法。
DROP SEQUENCE <sequence>
其中<Sequence>定义您要删除的序列。
尝试以下查询以删除名为“seqid”的序列。
DROP SEQUENCE seqid
如果以上查询成功执行，您将获得以下输出。
Sequence dropped successfully
OrientDB - 索引
索引是指向数据库中数据位置的指针。索引是用于快速定位数据而不必搜索数据库中每个记录的概念。OrientDB支持四种索引算法和每种算法中的几种类型。
四种索引类型是：
SB-Tree索引
它提供了其他索引类型提供的功能的良好组合。最好将其用于通用实用程序。它是持久性的、事务性的，并支持范围查询。它是默认索引类型。支持此算法的不同类型插件有：
UNIQUE − 这些索引不允许重复键。对于复合索引，这指的是复合键的唯一性。
NOTUNIQUE − 这些索引允许重复键。
FULLTEXT − 这些索引基于任何单个文本单词。您可以通过CONTAINSTEXT运算符在查询中使用它们。
DICTIONARY − 这些索引类似于使用UNIQUE的索引，但在重复键的情况下，它们会将现有记录替换为新记录。
哈希索引
它执行速度更快，并且磁盘使用率非常低。它是持久性的、事务性的，但不支持范围查询。它的工作方式类似于HASHMAP，这使得它在精确查找方面速度更快，并且比其他索引类型消耗更少的资源。支持此算法的不同类型插件有：
UNIQUE_HASH_INDEX − 这些索引不允许重复键。对于复合索引，这指的是复合键的唯一性。
NOTUNIQUE_HASH_INDEX − 这些索引允许重复键。
FULLTEXT_HASH_INDEX − 这些索引基于任何单个文本单词。您可以通过CONTAINSTEXT运算符在查询中使用它们。
DICTIONARY_HASH_INDEX − 这些索引类似于使用UNIQUE_HASH_INDEX的索引，但在重复键的情况下，它们会将现有记录替换为新记录。
Lucene全文索引
它提供良好的全文索引，但不能用于索引其他类型。它是持久性的、事务性的，并支持范围查询。
Lucene空间索引
它提供良好的空间索引，但不能用于索引其他类型。它是持久性的、事务性的，并支持范围查询。
创建索引
创建索引是用于在特定模式上创建索引的命令。
以下语句是创建索引的基本语法。
CREATE INDEX <name> [ON <class-name> (prop-names)] <type> [<key-type>]
[METADATA {<metadata>}]
以下是上述语法中选项的详细信息。
<name> − 定义索引的逻辑名称。您还可以使用<class.property>表示法来创建绑定到模式属性的自动索引。<class>使用模式的类，<property>使用在类中创建的属性。
<class-name> − 提供您要创建自动索引以进行索引的类的名称。此类必须存在于数据库中。
<prop-names> − 提供您希望自动索引进行索引的属性列表。这些属性必须已存在于模式中。
<type> − 提供您要创建的索引的算法和类型。
<key-type> − 为自动索引提供可选的键类型。
<metadata> − 提供JSON表示。
示例
尝试以下查询以创建绑定到sales_user用户的“ID”属性的自动索引。
orientdb> CREATE INDEX indexforID ON sales_user (id) UNIQUE
如果以上查询成功执行，您将获得以下输出。
Creating index... Index created successfully with 4 entries in 0.021000 sec(s)
查询索引
您可以使用select查询获取索引中的记录。
尝试以下查询以检索名为“indexforId”的索引的键。
SELECT FROM INDEX:indexforId
如果以上查询成功执行，您将获得以下输出。
----+------+----+----- # |@CLASS|key |rid ----+------+----+----- 0 |null |1 |#11:7 1 |null |2 |#11:6 2 |null |3 |#11:5 3 |null |4 |#11:8 ----+------+----+-----
删除索引
如果您想删除特定索引，可以使用此命令。此操作不会删除链接的记录。
以下语句是删除索引的基本语法。
DROP INDEX <name>
其中<name>提供您要删除的索引的名称。
尝试以下查询以删除sales_user用户的名为“ID”的索引。
DROP INDEX sales_users.Id
如果以上查询成功执行，您将获得以下输出。
Index dropped successfully
OrientDB - 事务
与RDBMS一样，OrientDB支持事务ACID属性。事务包括在数据库管理系统内执行的工作单元。在数据库环境中维护事务有两个主要原因。
允许从故障中并发恢复，即使在系统故障的情况下也能保持数据库的一致性。
提供并发访问数据库的程序之间的隔离。
默认情况下，数据库事务必须遵循ACID属性，例如原子性、一致性、隔离性和持久性。但OrientDB是一个符合ACID的数据库，这意味着它不会与ACID概念相矛盾或否定它，而是在处理NoSQL数据库时会改变其认知。让我们看看ACID属性如何与NoSQL数据库一起工作。
原子性 − 当您执行某些操作来更改数据库时，更改应该整体生效或整体失败。
一致性 − 数据库应该保持一致。
隔离性 − 如果其他事务执行正在同时执行，则用户将无法看到并发执行中的记录。
持久性 − 如果系统崩溃（硬件或软件），数据库本身应该能够进行备份。
数据库事务可以通过使用Commit和Rollback命令来实现。
Commit
Commit表示通过将所有更改保存到数据库来关闭事务。Rollback表示将数据库状态恢复到打开事务时的状态。
以下语句是COMMIT数据库命令的基本语法。
COMMIT
注意 − 只有在连接到特定数据库并在开始事务后才能使用此命令。
示例
在本例中，我们将使用教程前面章节中创建的同名数据库“demo”。我们将了解事务提交的操作，并使用事务存储记录。
您需要首先使用以下 BEGIN 命令启动事务。
orientdb {db = demo}> BEGIN
使用以下命令将一条记录插入到 employee 表中，其值为 id = 12 和 name = satish.P。
orientdb> INSERT INTO employee (id, name) VALUES (12, 'satish.P')
可以使用以下命令提交事务。
orientdb> commit
如果此事务成功提交，您将获得以下输出。
Transaction 2 has been committed in 4ms
回滚
回滚意味着将数据库状态恢复到您打开事务时的状态。
以下语句是 ROLLBACK 数据库命令的基本语法。
ROLLBACK
注意 − 只有在连接到特定数据库并在开始事务后才能使用此命令。
示例
在本例中，我们将使用教程前面章节中创建的同名数据库“demo”。我们将了解事务回滚的操作，并使用事务存储记录。
您必须首先使用以下 BEGIN 命令启动事务。
orientdb {db = demo}> BEGIN
使用以下命令将一条记录插入到 employee 表中，其值为 id = 12 和 name = satish.P。
orientdb> INSERT INTO employee (id, name) VALUES (12, 'satish.P')
您可以使用以下命令检索 employee 表的记录。
orientdb> SELECT FROM employee WHERE name LIKE '%.P'
如果此命令成功执行，您将获得以下输出。
---+-------+-------------------- # | ID | name ---+-------+-------------------- 0 | 12 | satish.P ---+-------+-------------------- 1 item(s) found. Query executed in 0.076 sec(s).
您可以使用以下命令回滚此事务。
orientdb> ROLLBACK
再次检查 select 查询以从 Employee 表中检索相同的记录。
orientdb> SELECT FROM employee WHERE name LIKE '%.P'
如果回滚成功执行，您将获得输出中找不到 0 条记录。
0 item(s) found. Query executed in 0.037 sec(s).
OrientDB - 钩子
OrientDB 的**钩子 (Hooks)** 在数据库术语中就是触发器，它允许在用户应用程序中每次 CRUD 操作之前和之后触发内部事件。您可以使用钩子编写自定义验证规则，强制执行安全策略，或安排外部事件，例如针对关系型 DBMS 进行复制。
OrientDB 支持两种类型的钩子：
**动态钩子 (Dynamic Hook)** - 可以在类级别和/或文档级别构建的触发器。
**Java（原生）钩子 (Java (Native) Hook)** - 使用 Java 类构建的触发器。
动态钩子
动态钩子比 Java 钩子更灵活，因为它们可以在运行时更改，并且如果需要可以针对每个文档运行，但速度比 Java 钩子慢。
要对您的文档执行钩子，首先允许您的类扩展**OTriggered**基类。然后，为感兴趣的事件定义一个自定义属性。以下是可用的事件：
**onBeforeCreate** - 在创建新文档**之前**调用。
**onAfterCreate** - 在创建新文档**之后**调用。
**onBeforeRead** - 在读取文档**之前**调用。
**onAfterRead** - 在读取文档**之后**调用。
**onBeforeUpdate** - 在更新文档**之前**调用。
**onAfterUpdate** - 在更新文档**之后**调用。
**onBeforeDelete** - 在删除文档**之前**调用。
**onAfterDelete** - 在删除文档**之后**调用。
动态钩子可以调用：
用 SQL、Javascript 或 OrientDB 和 JVM 支持的任何语言编写的函数。
Java 静态方法。
类级别钩子
类级别钩子是为与某个类相关的所有文档定义的。以下是如何设置一个针对 Invoice 文档在类级别起作用的钩子的示例。
CREATE CLASS Invoice EXTENDS OTriggered ALTER CLASS Invoice CUSTOM onAfterCreate = invoiceCreated
让我们在 Javascript 中创建一个函数**invoiceCreated**，它在服务器控制台中打印创建的发票号码。
CREATE FUNCTION invoiceCreated "print('\\nInvoice created: ' + doc.field ('number'));"
LANGUAGE Javascript
现在通过创建一个新的**Invoice**文档来测试钩子。
INSERT INTO Invoice CONTENT {number: 100, notes: 'This is a test}
如果此命令成功执行，您将获得以下输出。
Invoice created: 100
文档级别钩子
您可以仅针对一个或多个文档定义特殊操作。为此，请允许您的类扩展**OTriggered**类。
例如，让我们针对现有的 Profile 类执行一个触发器（作为 Javascript 函数），用于所有具有属性 account = 'Premium' 的文档。将调用触发器以防止删除文档。
ALTER CLASS Profile SUPERCLASS OTriggered UPDATE Profile SET onBeforeDelete = 'preventDeletion' WHERE account = 'Premium'
让我们创建**preventDeletion()** Javascript 函数。
CREATE FUNCTION preventDeletion "throw new java.lang.RuntimeException('Cannot
delete Premium profile ' + doc)" LANGUAGE Javascript
然后通过尝试删除“Premium”帐户来测试钩子。
DELETE FROM #12:1
java.lang.RuntimeException: Cannot delete Premium profile
profile#12:1{onBeforeDelete:preventDeletion,account:Premium,name:Jill} v-1
(<Unknown source>#2) in <Unknown source> at line number 2
JAVA 钩子
OrientDB 钩子（触发器）的一个常见用例是管理任何或所有类的创建日期和更新日期。例如，您可以每当创建记录时设置一个**CreatedDate**字段，每当更新记录时设置一个**UpdatedDate**字段，并且以一种在数据库层实现逻辑一次，而无需再次在应用程序层处理它的方式来实现。
在创建之前，您需要通过访问以下链接下载**orientdb-core.jar**文件 下载 OrientDB core。然后将该 jar 文件复制到您要存储 Java 源文件的文件夹中。
创建钩子文件
创建一个名为**HookTest.java**的 Java 文件，该文件将使用 Java 语言测试 Hook 机制。
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;
import com.orientechnologies.orient.core.hook.ODocumentHookAbstract;
import com.orientechnologies.orient.core.hook.ORecordHook;
import com.orientechnologies.orient.core.hook.ORecordHookAbstract;
import com.orientechnologies.orient.core.db.ODatabaseLifecycleListener;
import com.orientechnologies.orient.core.db.ODatabase;
import com.orientechnologies.orient.core.record.ORecord;
import com.orientechnologies.orient.core.record.impl.ODocument;
public class HookTest extends ODocumentHookAbstract implements ORecordHook {
public HookTest() {
}
@Override
public DISTRIBUTED_EXECUTION_MODE getDistributedExecutionMode() {
return DISTRIBUTED_EXECUTION_MODE.BOTH;
}
public RESULT onRecordBeforeCreate( ODocument iDocument ) {
System.out.println("Ran create hook");
return ORecordHook.RESULT.RECORD_NOT_CHANGED;
}
public RESULT onRecordBeforeUpdate( ODocument iDocument ) {
System.out.println("Ran update hook");
return ORecordHook.RESULT.RECORD_NOT_CHANGED;
}
}
以上示例代码每次创建或更新该类的记录时都会打印相应的注释。
让我们再添加一个钩子文件**setCreatedUpdatedDates.java**，如下所示：
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;
import com.orientechnologies.orient.core.hook.ODocumentHookAbstract;
import com.orientechnologies.orient.core.hook.ORecordHook;
import com.orientechnologies.orient.core.hook.ORecordHookAbstract;
import com.orientechnologies.orient.core.db.ODatabaseLifecycleListener;
import com.orientechnologies.orient.core.db.ODatabase;
import com.orientechnologies.orient.core.record.ORecord;
import com.orientechnologies.orient.core.record.impl.ODocument;
public class setCreatedUpdatedDates extends ODocumentHookAbstract implements ORecordHook {
public setCreatedUpdatedDates() {
}
@Override
public DISTRIBUTED_EXECUTION_MODE getDistributedExecutionMode() {
return DISTRIBUTED_EXECUTION_MODE.BOTH;
}
public RESULT onRecordBeforeCreate( ODocument iDocument ) {
if ((iDocument.getClassName().charAt(0) == 't') || (iDocument.getClassName().charAt(0)=='r')) {
iDocument.field("CreatedDate", System.currentTimeMillis() / 1000l);
iDocument.field("UpdatedDate", System.currentTimeMillis() / 1000l);
return ORecordHook.RESULT.RECORD_CHANGED;
} else {
return ORecordHook.RESULT.RECORD_NOT_CHANGED;
}
}
public RESULT onRecordBeforeUpdate( ODocument iDocument ) {
if ((iDocument.getClassName().charAt(0) == 't') || (iDocument.getClassName().charAt(0)=='r')) {
iDocument.field("UpdatedDate", System.currentTimeMillis() / 1000l);
return ORecordHook.RESULT.RECORD_CHANGED;
} else {
return ORecordHook.RESULT.RECORD_NOT_CHANGED;
}
}
}
以上代码的作用是查找任何以字母“**r**”或“**t**”开头的类，并在创建记录时设置 CreatedDate 和 UpdatedDate，并在每次更新记录时仅设置 UpdatedDate。
编译 Java 钩子
使用以下命令编译 Java 代码。**注意：**将下载的 jar 文件和这些 Java 文件放在同一个文件夹中。
$ jar cf hooks-1.0-SNAPSHOT.jar *.java
将编译后的代码移动到 OrientDB 服务器可以找到的位置
您需要将生成的 .jar 文件复制到 OrientDB 服务器将查找它们的目录。这意味着您的 OrientDB 服务器根目录下的“**./lib**”文件夹将如下所示：
$ cp hooks-1.0-SNAPSHOT.jar "$ORIENTDB_HOME/lib"
在 OrientDB 服务器配置文件中启用测试钩子
编辑**$ORIENTDB_HOME/config/orientdb-server-config.xml**并在文件末尾附近添加以下部分。
<hooks>
<hook class = "HookTest" position = "REGULAR"/>
</hooks>
...
</orient-server>
重新启动 OrientDB 服务器
重新启动 OrientDB 服务器后，您在**orientdb-server-config.xml**中定义的钩子现在处于活动状态。启动 OrientDB 控制台，将其连接到您的数据库，然后运行以下命令：
INSERT INTO V SET ID = 1;
如果此命令成功执行，您将获得以下输出。
Ran create hook
现在运行以下命令：
UPDATE V SET ID = 2 WHERE ID = 1;
如果此命令成功执行，您将获得以下输出。
Ran update hook
在 OrientDB 服务器配置文件中启用真实钩子
编辑**$ORIENTDB_HOME/config/orientdb-server-config.xml**并将钩子部分更改为如下所示：
<hooks>
<hook class="setCreatedUpdatedDates" position="REGULAR"/>
</hooks>
...
</orient-server>
重新启动 OrientDB 服务器
创建一个以字母“**r**”或“**t**”开头的新的类：
CREATE CLASS tTest EXTENDS V;
现在插入一条记录：
INSERT INTO tTest SET ID = 1 SELECT FROM tTest
如果此命令成功执行，您将获得以下输出。
----+-----+------+----+-----------+----------- # |@RID |@CLASS|ID |CreatedDate|UpdatedDate ----+-----+------+----+-----------+----------- 0 |#19:0|tTest |1 |1427597275 |1427597275 ----+-----+------+----+-----------+-----------
即使您没有指定要为**CreatedDate**和**UpdatedDate**设置的值，OrientDB 也已自动为您设置了这些字段。
接下来，您需要使用以下命令更新记录：
UPDATE tTest SET ID = 2 WHERE ID = 1; SELECT FROM tTest;
如果此命令成功执行，您将获得以下输出。
----+-----+------+----+-----------+----------- # |@RID |@CLASS|ID |CreatedDate|UpdatedDate ----+-----+------+----+-----------+----------- 0 |#19:0|tTest |2 |1427597275 |1427597306 ----+-----+------+----+-----------+-----------
您可以看到 OrientDB 已更改了**UpdatedDate**，但保留了**CreatedDate**不变。
OrientDB Java 钩子可以成为一个非常有价值的工具，可以帮助自动化您原本必须在应用程序代码中执行的工作。由于许多 DBA 并非总是 Java 专家，因此本教程中包含的信息希望能为您提供一个良好的开端，让您对这项技术感到满意，从而使您能够在需要时成功创建数据库触发器。
OrientDB - 缓存
**缓存 (Caching)** 是一种概念，它将创建数据库表结构的副本，为用户应用程序提供一个舒适的环境。OrientDB 在不同级别具有多种缓存机制。
下图说明了缓存的概念。
在上图中，**DB1**、**DB2**、**DB3** 是应用程序中使用的三个不同的数据库实例。
**一级 (Level-1)** 缓存是**本地缓存 (Local cache)**，它存储特定会话已知的全部实体。如果此会话中有三个事务，它将保存所有三个事务使用的所有实体。当您关闭会话或执行“clear”方法时，此缓存将被清除。它减少了应用程序和数据库之间的 I/O 操作负担，进而提高了性能。
**二级 (Level-2)** 缓存是**实际缓存 (Real cache)**，它通过使用第三方提供程序来工作。您可以完全控制缓存的内容，即您可以指定哪些条目应被删除，哪些条目应存储更长时间等等。它是多个线程之间共享的完整缓存。
**存储模型 (Storage model)** 就是存储设备，可以是磁盘、内存或远程服务器。
OrientDB 中缓存的工作原理？
OrientDB 缓存在不同的环境中提供不同的方法。缓存主要用于加快数据库事务，减少事务的处理时间并提高性能。以下流程图显示了缓存在本地模式和客户端-服务器模式下的工作方式。
本地模式（嵌入式数据库）
以下流程图说明了记录在本地模式（即数据库服务器在您的本地主机上）中存储和使用应用程序之间的过程。
当客户端应用程序请求记录时，OrientDB 检查以下内容：
如果已开始事务，则它会在事务内搜索已更改的记录，如果找到则返回。
如果启用了本地缓存并且包含请求的记录，则返回。
如果此时缓存中没有记录，则向存储（磁盘、内存）请求。
客户端服务器模式（远程数据库）
以下流程图说明了记录在客户端-服务器模式（即数据库服务器位于远程位置）中存储和使用应用程序之间的过程。
当客户端应用程序请求记录时，OrientDB 检查以下内容：
如果已开始事务，则它会在事务内搜索已更改的记录，如果找到则返回。
如果启用了本地缓存并且包含请求的记录，则返回。
此时，如果缓存中没有记录，则通过 TCP/IP 调用向服务器请求。
在服务器上，如果启用了本地缓存并且包含请求的记录，则返回。
此时，服务器中仍然没有缓存记录，则向存储（磁盘、内存）请求。
OrientDB - 日志
OrientDB 使用与 Java 虚拟机捆绑在一起的 Java 日志记录框架。OrientDB 的默认日志格式由**OLogFormatter**类管理。
以下语句是日志记录命令的基本语法。
<date> <level> <message> [<requester>]
以下是上述语法中选项的详细信息。
**<date>** - 日志日期，格式为：yyyy-MM-dd HH:mm:ss:SSS。
**<level>** - 日志级别，以 5 个字符输出。
**<message>** - 日志文本，大小可以任意。
**[<class>]** - 记录的 Java 类（可选）。
支持的级别包含在 JRE 类 java.util.logging.Level 中。它们是：
- SEVERE（最高值）
- WARNING
- INFO
- CONFIG
- FINE
- FINER
- FINEST（最低值）
默认情况下，安装了两个记录器：
**Console**，作为启动应用程序/服务器的 shell/命令提示符的输出。可以通过设置变量“log.console.level”来更改。
**File**，作为对日志文件的输出。可以通过设置“log.file.level”来更改。
配置日志记录
可以使用遵循 Java 的文件配置日志记录策略。
**语法** - Java 日志记录配置。
示例
复制**orientdb-server-log.properties**文件中的以下内容，并将其放入**$ORIENTDB_HOME/config**文件中。
# Specify the handlers to create in the root logger # (all loggers are children of the root logger) # The following creates two handlers handlers = java.util.logging.ConsoleHandler, java.util.logging.FileHandler # Set the default logging level for the root logger .level = ALL # Set the default logging level for new ConsoleHandler instances java.util.logging.ConsoleHandler.level = INFO # Set the default formatter for new ConsoleHandler instances java.util.logging.ConsoleHandler.formatter = com.orientechnologies.common.log.OLogFormatter # Set the default logging level for new FileHandler instances java.util.logging.FileHandler.level = INFO # Naming style for the output file java.util.logging.FileHandler.pattern =../log/orient-server.log # Set the default formatter for new FileHandler instances java.util.logging.FileHandler.formatter = com.orientechnologies.common.log.OLogFormatter # Limiting size of output file in bytes: java.util.logging.FileHandler.limit = 10000000 # Number of output files to cycle through, by appending an # integer to the base file name: java.util.logging.FileHandler.count = 10
要告诉 JVM 属性文件的位置，您需要将其“**java.util.logging.config.file**”系统属性设置为它。例如，使用以下命令：
$ java -Djava.util.logging.config.file=mylog.properties ...
设置日志级别
要更改日志级别而不修改日志记录配置，只需将“**log.console.level**”和“**log.file.level**”系统变量设置为请求的级别。
启动时记录日志
以下是通过不同方式设置启动级别日志记录的过程。
在服务器配置中
打开文件**orientdb-server-config.xml**并在<properties>部分的结尾添加或更新以下几行：
<entry value = "fine" name = "log.console.level" /> <entry value = "fine" name = "log.file.level" />
在 Server.sh（或 .bat）脚本中
使用java的-D参数设置系统属性“log.console.level”和“log.file.level”到您想要的级别。
$ java -Dlog.console.level = FINE ...
运行时日志记录
以下是通过不同方式设置启动级别日志记录的过程。
使用Java代码
可以使用System.setProperty() API在启动时设置系统变量。以下代码片段是使用Java代码设置日志级别的语法。
public void main(String[] args){
System.setProperty("log.console.level", "FINE");
...
}
远程服务器上
对URL执行HTTP POST请求：/server/log.<type>/<level>，其中−
- <type>可以是“console”或“file”
- <level>是支持的级别之一
示例
以下示例使用cURL对OrientDB服务器执行HTTP POST命令。使用了服务器的“root”用户和密码，请替换为您的密码。
启用控制台的精细跟踪级别−
curl -u root:root -X POST https://:2480/server/log.console/FINEST
启用文件的精细跟踪级别−
curl -u root:root -X POST https://:2480/server/log.file/FINEST
OrientDB - 性能调优
本章将提供一些关于如何优化使用OrientDB的应用程序的通用技巧。有三种方法可以提高不同类型数据库的性能。
文档数据库性能调优 − 它使用一种技术来帮助避免为每个新文档创建文档。
对象数据库性能调优 − 它使用通用技术来提高性能。
分布式配置调优 − 它使用不同的方法来提高分布式配置的性能。
您可以通过更改内存、JVM和远程连接设置来实现通用的性能调优。
内存设置
内存设置中有不同的策略可以提高性能。
服务器和嵌入式设置
这些设置同时适用于服务器组件和使用OrientDB嵌入模式（直接使用plocal）运行Java应用程序的JVM。
调优最重要的方面是确保内存设置正确。堆和内存映射使用的虚拟内存之间的正确平衡可以产生真正的差异，尤其是在大型数据集（GB、TB及更多）中，内存缓存结构的重要性低于原始IO。
例如，如果您最多可以为Java进程分配8GB内存，通常最好分配较小的堆和较大的磁盘缓存缓冲区（堆外内存）。
尝试使用以下命令来增加堆内存。
java -Xmx800m -Dstorage.diskCache.bufferSize=7200 ...
storage.diskCache.bufferSize设置（在旧的“local”存储中为file.mmap.maxMemory）以MB为单位，指示磁盘缓存组件要使用多少内存。默认值为4GB。
注意 − 如果最大堆和磁盘缓存缓冲区的总和过高，可能会导致操作系统进行交换，从而导致严重减速。
JVM设置
JVM设置编码在server.sh（和server.bat）批处理文件中。您可以更改它们以根据您的使用情况和硬件/软件设置来调整JVM。在server.bat文件中添加以下行。
-server -XX:+PerfDisableSharedMem
此设置将禁用写入有关JVM的调试信息。如果您需要分析JVM，只需删除此设置即可。
远程连接
使用远程连接访问数据库时，有很多方法可以提高性能。
获取策略
使用远程数据库时，您必须注意使用的获取策略。默认情况下，OrientDB客户端仅加载结果集中包含的记录。例如，如果查询返回100个元素，但如果从客户端交叉这些元素，则OrientDB客户端将延迟加载元素，每次缺少记录时都会对服务器进行一次额外的网络调用。
网络连接池
默认情况下，每个客户端仅使用一个网络连接与服务器通信。同一客户端上的多个线程共享相同的网络连接池。
当您有多个线程时，可能会出现瓶颈，因为大量时间都花在了等待空闲网络连接上。这就是为什么配置网络连接池非常重要的原因。
配置非常简单，只有两个参数−
minPool − 这是连接池的初始大小。默认值配置为全局参数“client.channel.minPool”。
maxPool − 这是连接池可以达到的最大大小。默认值配置为全局参数“client.channel.maxPool”。
如果所有池连接都繁忙，则客户端线程将等待第一个空闲连接。
使用数据库属性进行配置的示例命令。
database = new ODatabaseDocumentTx("remote:localhost/demo");
database.setProperty("minPool", 2);
database.setProperty("maxPool", 5);
database.open("admin", "admin");
分布式配置调优
有很多方法可以提高分布式配置的性能。
使用事务
即使更新图形，也应始终在事务中工作。OrientDB允许您在事务之外工作。常见的情况是只读查询或大规模的非并发操作，可以在发生故障时恢复。在分布式配置上运行时，使用事务有助于减少延迟。这是因为分布式操作仅在提交时发生。由于延迟的原因，分布一个大型操作比传输多个小型操作效率更高。
复制与分片
OrientDB分布式配置设置为完全复制。拥有多个具有相同数据库副本的节点对于扩展读取非常重要。事实上，每个服务器在执行读取和查询方面都是独立的。如果您有10个服务器节点，则读取吞吐量为10倍。
对于写入，则相反：如果复制是同步的，则拥有多个具有完全复制的节点会减慢操作速度。在这种情况下，跨多个节点对数据库进行分片允许您扩展写入，因为只有一部分节点参与写入。此外，您的数据库可以大于一个服务器节点的硬盘。
扩展写入
如果您网络缓慢并且使用了同步（默认）复制，则您可能需要承担延迟的成本。事实上，当OrientDB同步运行时，它至少会等待writeQuorum。这意味着如果writeQuorum为3，而您有5个节点，则协调器服务器节点（在其中启动分布式操作）必须等待来自至少3个节点的答复才能向客户端提供答复。
为了保持一致性，writeQuorum应设置为多数。如果您有5个节点，则多数为3。对于4个节点，它仍然是3。将writeQuorum设置为3而不是4或5可以减少延迟成本，同时仍然保持一致性。
异步复制
为了加快速度，您可以设置异步复制以消除延迟瓶颈。在这种情况下，协调器服务器节点在本地执行操作并向客户端提供答复。整个复制将在后台进行。如果未达到配额，则更改将被透明地回滚。
扩展读取
如果您已将writeQuorum设置为节点的大多数，则可以将readQuorum保留为1（默认值）。这将加快所有读取速度。
OrientDB - 升级
升级时，您必须考虑版本号和格式。有三种类型的格式 - MAJOR、MINOR、PATCH。
MAJOR版本包含不兼容的API更改。
MINOR版本以向后兼容的方式包含功能。
PATCH版本包含向后兼容的错误修复。
为了在次要版本和主要版本之间同步，您可能需要导出和导入数据库。有时您可能需要将数据库从LOCAL迁移到PLOCAL，并且需要将图形迁移到RidBag。
从LOCAL存储引擎迁移到PLOCAL
从1.5.x版本开始，OrientDB提供了一个全新的存储引擎：PLOCAL（分页LOCAL）。它像LOCAL一样是持久性的，但以不同的方式存储信息。以下几点显示了PLOCAL和LOCAL之间的比较−
在PLOCAL中，记录存储在集群文件中，而LOCAL则在集群和数据段之间分割。
由于追加写入模式，PLOCAL比LOCAL更持久。
PLOCAL在写入上的争用锁较少，这意味着更高的并发性。
PLOCAL不使用内存映射技术（MMap），因此行为更“可预测”。
要将您的LOCAL存储迁移到新的PLOCAL，您需要使用PLOCAL作为存储引擎导出并重新导入数据库。以下是该过程。
步骤1 − 打开一个新的shell（Linux/Mac）或命令提示符（Windows）。
步骤2 − 使用控制台导出数据库。按照给定的命令将数据库demo导出到demo.json.gzip文件。
$ bin/console.sh (or bin/console.bat under Windows) orientdb> CONNECT DATABASE local:/temp/demo admin admin orientdb> EXPORT DATABASE /temp/demo.json.gzip orientdb> DISCONNECT
步骤3 − 在本地文件系统上，使用“plocal”引擎创建一个新的数据库−
orientdb> CREATE DATABASE plocal:/temp/newdb admin admin plocal graph
步骤4 − 将旧数据库导入到新数据库。
orientdb> IMPORT DATABASE /temp/demo.json.gzip -preserveClusterIDs=true orientdb> QUIT
如果您在相同的JVM中访问数据库，请记住将URL从“local:”更改为“plocal:”
将图形迁移到RidBag
从OrientDB 1.7开始，RidBag是管理图形中邻接关系的默认集合。虽然由MVRB-Tree管理的旧数据库完全兼容，但您可以将数据库更新到最新的格式。
您可以通过控制台或使用ORidBagMigration类来升级您的图形。
连接到数据库 CONNECT plocal:databases/<graphdb-name>
运行升级图形命令
OrientDB - 安全性
与RDBMS一样，OrientDB还提供基于众所周知的概念、用户和角色的安全机制。每个数据库都有其自己的用户，每个用户都有一个或多个角色。角色是工作模式和权限集的组合。
用户
默认情况下，OrientDB为服务器中的所有数据库维护三个不同的用户−
Admin − 此用户可以无限制地访问数据库上的所有功能。
Reader − 此用户是只读用户。阅读器可以查询数据库中的任何记录，但不能修改或删除它们。它无权访问内部信息，例如用户和角色本身。
Writer − 此用户与阅读器用户相同，但它还可以创建、更新和删除记录。
使用用户
连接到数据库后，您可以使用SELECT查询在OUser类上查询数据库上的当前用户。
orientdb> SELECT RID, name, status FROM OUser
如果以上查询成功执行，您将获得以下输出。
---+--------+--------+-------- # | @CLASS | name | status ---+--------+--------+-------- 0 | null | admin | ACTIVE 1 | null | reader | ACTIVE 2 | null | writer | ACTIVE ---+--------+--------+-------- 3 item(s) found. Query executed in 0.005 sec(s).
创建新用户
要创建新用户，请使用INSERT命令。请记住，这样做时，必须将状态设置为ACTIVE并赋予其有效的角色。
orientdb> INSERT INTO OUser SET
name = 'jay',
password = 'JaY',
status = 'ACTIVE',
roles = (SELECT FROM ORole WHERE name = 'reader')
更新用户
您可以使用UPDATE语句更改用户的名称。
orientdb> UPDATE OUser SET name = 'jay' WHERE name = 'reader'
同样，您也可以更改用户的密码。
orientdb> UPDATE OUser SET password = 'hello' WHERE name = 'reader'
OrientDB以哈希格式保存密码。触发器OUserTrigger在保存记录之前会透明地加密密码。
禁用用户
要禁用用户，请使用 UPDATE 将其状态从 ACTIVE 切换到 SUSPENDED。例如，如果您想禁用除管理员以外的所有用户，请使用以下命令：
orientdb> UPDATE OUser SET status = 'SUSPENDED' WHERE name <> 'admin'
角色
角色决定用户可以对资源执行哪些操作。主要取决于工作模式和规则。规则本身的工作方式不同，取决于工作模式。
使用角色
连接到数据库后，您可以使用**SELECT** 查询在**ORole** 类上查询数据库上的当前角色。
orientdb> SELECT RID, mode, name, rules FROM ORole
如果以上查询成功执行，您将获得以下输出。
--+------+----+--------+-------------------------------------------------------
# |@CLASS|mode| name | rules
--+------+----+--------+-------------------------------------------------------
0 | null | 1 | admin | {database.bypassRestricted = 15}
1 | null | 0 | reader | {database.cluster.internal = 2, database.cluster.orole = 0...
2 | null | 0 | writer | {database.cluster.internal = 2, database.cluster.orole = 0...
--+------+----+--------+-------------------------------------------------------
3 item(s) found. Query executed in 0.002 sec(s).
创建新角色
要创建新角色，请使用 INSERT 语句。
orientdb> INSERT INTO ORole SET name = 'developer', mode = 0
使用模式
规则决定属于特定角色的用户可以在数据库上执行哪些操作，而工作模式则决定 OrientDB 如何解释这些规则。有两种工作模式，分别用 1 和 0 表示。
**允许所有操作，但（规则）除外** - 默认情况下，这是超级用户模式。使用规则指定对此的例外。如果 OrientDB 未找到请求资源的规则，则允许用户执行该操作。此模式主要用于高级用户和管理员。默认角色 admin 默认使用此模式，并且没有例外规则。在数据库中写为 1。
**拒绝所有操作，但（规则）除外** - 默认情况下，此模式不允许任何操作。使用规则指定对此的例外。如果 OrientDB 找到请求资源的规则，则允许用户执行该操作。将此模式用作所有经典用户的默认模式。默认角色 reader 和 writer 使用此模式。在数据库中写为 0。
OrientDB - Studio
OrientDB 提供一个 Web UI，可以通过 GUI 执行数据库操作。本章介绍 OrientDB 中可用的不同选项。
Studio 首页
Studio 是 OrientDB 的一个 Web 管理界面，包含在 OrientDB 发行版中。
首先，您需要使用以下命令启动 OrientDB 服务器。
$ server.sh
如果您在您的机器上运行 OrientDB，则可以通过以下 URL 访问 Web 界面：
https://:2480
如果命令执行成功，屏幕上将显示以下输出。
连接到现有数据库
要登录，请从数据库列表中选择一个数据库并使用任何数据库用户。默认情况下，**reader/reader** 可以读取数据库中的记录，**writer/writer** 可以读取、创建、更新和删除记录，而 **admin/admin** 拥有所有权限。
删除现有数据库
从数据库列表中选择一个数据库，然后单击垃圾桶图标。Studio 将打开一个确认弹出窗口，您需要在其中输入服务器用户和服务器密码。
然后单击“删除数据库”按钮。您可以在 **$ORIENTDB_HOME/config/orientdb-server-config.xml** 文件中找到服务器凭据。
<users> <user name = "root" password = "pwd" resources = "*" /> </users>
创建新数据库
要创建新数据库，请单击首页上的“新建数据库”按钮。
创建新数据库需要以下信息：
- 数据库名称
- 数据库类型（文档/图形）
- 存储类型（plocal/memory）
- 服务器用户
- 服务器密码
您可以在 **$ORIENTDB_HOME/config/orientdbserver-config.xml** 文件中找到服务器凭据。
<users> <user name = "root" password = "pwd" resources = "*" /> </users>
创建后，Studio 将自动登录到新数据库。
执行查询
Studio 支持自动识别您使用的语言（在支持的语言之间）：SQL 和 Gremlin。在编写时，按 **Ctrl + Space** 使用自动完成功能。
查询编辑器中可使用以下快捷键：
**Ctrl + Enter** - 执行查询或单击**运行**按钮。
**Ctrl/Cmd + Z** - 撤消更改。
**Ctrl/Cmd + Shift + Z** - 重做更改。
**Ctrl/Cmd + F** - 在编辑器中搜索。
**Ctrl/Cmd + /** - 切换注释。
以下屏幕截图显示了如何执行查询。
单击结果集中的任何 **@rid** 值，如果记录是文档，则将进入文档编辑模式，否则将进入顶点编辑模式。
您可以通过单击结果集或编辑器中的星形图标来为查询添加书签。要浏览已加书签的查询，请单击**书签**按钮。Studio 将在左侧打开书签列表，您可以在其中编辑/删除或重新运行查询。
Studio 将执行的查询保存在浏览器的本地存储中。在查询设置中，您可以配置 Studio 要保留的历史查询数量。您还可以搜索以前执行的查询、删除历史记录中的所有查询或删除单个查询。
编辑顶点
要编辑图形的顶点，请转到“图形”部分。然后运行以下查询。
Select From Customer
成功运行查询后，以下将是输出屏幕截图。选择图形画布中的特定顶点进行编辑。
选择特定顶点上的编辑符号。您将看到以下屏幕，其中包含编辑顶点的选项。
模式管理器
OrientDB 可以无模式模式、模式模式或两种模式的混合模式运行。在这里，我们将讨论模式模式。单击 Web UI 顶部的“模式”部分。您将看到以下屏幕截图。
创建新类
要创建新类，只需单击**新建类**按钮。将出现以下屏幕截图。您必须提供屏幕截图中显示的以下信息才能创建新类。
查看所有索引
当您想要概述数据库中创建的所有索引时，只需单击模式 UI 中的“所有索引”按钮即可。这将提供对索引的一些信息的快速访问（名称、类型、属性等），您可以从此处删除或重建它们。
编辑类
单击模式部分中的任何类，您将看到以下屏幕截图。
编辑类时，您可以添加属性或添加新索引。
添加属性
单击“新建属性”按钮添加属性。您将看到以下屏幕截图。
您必须提供屏幕截图中显示的以下详细信息才能添加属性。
添加索引
单击“新建索引”按钮。您将看到以下屏幕截图。您必须提供屏幕截图中显示的以下详细信息才能添加索引。
图形编辑器
单击图形部分。您不仅可以以图形样式可视化您的数据，还可以与图形交互并修改它。
要填充图形区域，请在查询编辑器中键入查询或使用浏览 UI 中的“发送到图形”功能。
添加顶点
要在图形数据库和图形画布区域中添加新的顶点，您必须按下**添加顶点**按钮。此操作分两步完成。
第一步，您必须为新的顶点选择类，然后单击“下一步”。
第二步，您必须插入新顶点的字段值。您还可以添加自定义字段，因为 OrientDB 支持无模式模式。要使新顶点持久化，请单击“保存更改”，顶点将保存到数据库并添加到画布区域。
删除顶点
单击要删除的顶点打开圆形菜单。将鼠标悬停在更多(...)菜单项上打开子菜单，然后单击垃圾桶图标。
从画布中移除顶点
打开圆形菜单，将鼠标悬停在更多(...)菜单项上打开子菜单，然后单击橡皮擦图标。
检查顶点
如果您想快速查看顶点属性，请单击眼睛图标。
安全性
Studio 2.0 包含新的安全管理，您可以在其中以图形方式管理用户和角色。
用户
您可以执行以下操作来管理数据库用户：
- 搜索用户
- 添加用户
- 删除用户
- 编辑用户：角色可以在内联编辑，对于名称、状态和密码，请单击**编辑**按钮
添加用户
要添加新用户，请单击**添加用户**按钮，完成新用户的资料（名称、密码、状态、角色），然后保存以将新用户添加到数据库。
角色
您可以执行以下操作来管理数据库角色：
- 搜索角色
- 添加角色
- 删除角色
- 编辑角色
添加角色
要添加新用户，请单击**添加角色**按钮，完成新角色的资料（名称、父角色、模式），然后保存以将新角色添加到数据库。
向角色添加规则
要为选定的角色添加新的安全规则，请单击**添加规则**按钮。这将要求您输入要保护的资源的字符串。然后，您可以配置新创建资源上的 CRUD 权限。
OrientDB - Java 接口
与 RDBMS 类似，OrientDB 支持 JDBC。为此，首先需要配置 JDBC 编程的环境。以下是创建应用程序和数据库之间连接的过程。
首先，我们需要下载 JDBC 驱动程序。访问以下链接https://code.google.com/archive/p/orient/downloads下载 OrientDB-JDBC。
以下是实现 OrientDB-jdbc 连接的基本五个步骤。
- 加载 JDBC 驱动程序
- 创建连接
- 创建语句
- 执行语句
- 关闭连接
示例
尝试以下示例以了解 OrientDB-JDBC 连接。让我们假设我们有一个员工表，其中包含以下字段及其类型。
| 序号 | 字段名称 | 类型 |
|---|---|---|
| 1 | Id | 整数 |
| 2 | Name | 字符串 |
| 3 | 薪资 | 整数 |
| 4 | 入职日期 | 日期 |
您可以通过执行以下命令来创建模式（表）。
CREATE DATABASE PLOCAL:/opt/orientdb/databases/testdb CREATE CLASS Employee CREATE PROPERTY Customer.id integer CREATE PROPERTY Customer.name String CREATE PROPERTY Customer.salary integer CREATE PROPERTY Customer.join_date date
执行所有命令后，您将获得包含以下字段的员工表：员工姓名（含 ID）、年龄和入职日期字段。
将以下代码保存到 **OrientJdbcDemo.java** 文件中。
import com.orientechnologies.common.log.OLogManager;
import com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import java.io.File;
import java.sql.DriverManager;
import java.util.Properties;
import static com.orientechnologies.orient.jdbc.OrientDbCreationHelper.createSchemaDB;
import static com.orientechnologies.orient.jdbc.OrientDbCreationHelper.loadDB;
import static java.lang.Class.forName;
public abstract class OrientJdbcDemo {
protected OrientJdbcConnection conn;
public static void main(String ar[]){
//load Driver
forName(OrientJdbcDriver.class.getName());
String dbUrl = "memory:testdb";
ODatabaseDocumentTx db = new ODatabaseDocumentTx(dbUrl);
String username = "admin";
String password = "admin";
createSchemaDB(db);
loadDB(db, 20);
dbtx.create();
//Create Connection
Properties info = new Properties();
info.put("user", username);
info.put("password", password);
conn = (OrientJdbcConnection) DriverManager.getConnection("jdbc:orient:" + dbUrl, info);
//create and execute statement
Statement stmt = conn.createStatement();
int updated = stmt.executeUpdate("INSERT into emplyoee
(intKey, text, salary, date) values ('001','satish','25000','"
+ date.toString() + "')");
int updated = stmt.executeUpdate("INSERT into emplyoee
(intKey, text, salary, date) values ('002','krishna','25000','"
+ date.toString() + "')");
System.out.println("Records successfully inserted");
//Close Connection
if (conn != null && !conn.isClosed())
conn.close();
}
}
以下命令用于编译上述程序。
$ javac –classpath:.:orientdb-jdbc-1.0-SNAPSHOT.jar OrientJdbcDemo.java $ java –classpath:.:orientdb-jdbc-1.0-SNAPSHOT.jar OrientJdbcDemo
如果以上命令成功执行，您将获得以下输出。
Records Successfully Inserted
OrientDB - Python 接口
OrientDB 的 Python 驱动程序使用二进制协议。PyOrient 是 git hub 项目名称，有助于将 OrientDB 与 Python 连接。它适用于 OrientDB 1.7 及更高版本。
以下命令用于安装 PyOrient。
pip install pyorient
您可以使用名为 **demo.py** 的脚本文件执行以下任务：
创建客户端实例，即创建连接。
创建名为 **DB_Demo** 的数据库。
打开名为 DB_Demo 的数据库。
创建类 my_class。
创建属性 id 和 name。
将记录插入 my_class。
//create connection
client = pyorient.OrientDB("localhost", 2424)
session_id = client.connect( "admin", "admin" )
//create a databse
client.db_create( db_name, pyorient.DB_TYPE_GRAPH, pyorient.STORAGE_TYPE_MEMORY )
//open databse
client.db_open( DB_Demo, "admin", "admin" )
//create class
cluster_id = client.command( "create class my_class extends V" )
//create property
cluster_id = client.command( "create property my_class.id Integer" )
cluster_id = client.command( "create property my_class.name String" )
//insert record
client.command("insert into my_class ( 'id','’name' ) values( 1201, 'satish')")
使用以下命令执行上述脚本。
$ python demo.py