Orientdb 简明教程
OrientDB - Overview
OrientDB 是一个开源 NoSQL 数据库管理系统。 NoSQL Database 提供了一种存储和检索无关系或非关系数据（指除表格数据之外的数据，比如文档数据或图表数据）的机制。NoSQL 数据库越来越多地在大数据和实时网络应用程序中使用。NoSQL 系统有时也称为“不只是 SQL”，以强调它们可能支持类似 SQL 的查询语言。
OrientDB 也属于 NoSQL 系列。OrientDB 是一个第二代分布式图表数据库，具有一款产品的文档灵活性，并采用 Apache 2 的开源许可。在 OrientDB 之前，市场上已有几个 NoSQL 数据库，其中之一是 MongoDB。
MongoDB vs OrientDB
MongoDB 和 OrientDB 包含许多常见功能，但引擎从根本上是不同的。MongoDB 是纯文档数据库，而 OrientDB 是混合文档图表引擎。
Features |
MongoDB |
OrientDB |
Relationships |
使用 RDBMS JOIN 来创建实体之间的关系。它的运行时成本较高，并且在数据库规模增加时无法扩展。 |
嵌入和连接文档，就像关系数据库一样。它使用从图表数据库世界获取的直接超快速链接。 |
Fetch Plan |
Costly JOIN operations. |
轻松返回带互联文档的完整图表。 |
Transactions |
不支持 ACID 事务，但它支持原子操作。 |
支持ACID事务以及原子操作。 |
Query language |
它有自己的语言基于JSON。 |
查询语言建立在SQL之上。 |
Indexes |
对所有索引使用B树算法。 |
支持三种不同的索引算法以便用户可以实现最佳性能。 |
Storage engine |
Uses memory mapping technique. |
使用 LOCAL 和 PLOCAL 存储引擎名称。 |
OrientDB是第一个多模型开源NoSQL DBMS，它将图的功能和文档的灵活性集合在一个可伸缩的高性能操作数据库中。
OrientDB - Installation
OrientDB安装文件有两种版本可用−
-
Community Edition − OrientDB社区版已发布，Apache以0.2许可证作为开源软件发布
-
Enterprise Edition − OrientDB企业版已发布，是建立在社区版之上的专有软件。它作为社区版的扩展。
本章解释OrientDB社区版的安装过程，因为它开源。
Prerequisites
社区版和企业版均可在实现Java虚拟机(JVM)的任何操作系统上运行。OrientDB需要Java 1.7或更高版本。
使用以下步骤将OrientDB下载并安装到您的系统中。
Step 1 − Download OrientDB Binary Setup File
OrientDB带有内置设置文件，可在您的系统上安装数据库。它为不同的操作系统提供了不同的预编译二进制包（焦油包或ZIP包）。您可以从 Download OrientDB 链接中下载OrientDB文件。
以下屏幕截图显示了OrientDB的下载页面。您可以通过单击合适的操作系统图标来下载ZIP或焦油文件。
下载后，您将在 Downloads 文件夹中获取二进制包。
Step 2 − Extract and Install OrientDB
以下是为不同的操作系统提取和安装OrientDB的过程。
In Linux
下载后，您将在 Downloads 文件夹中获取 orientdb-community-2.1.9.tar.gz 文件。您可以使用以下命令来提取焦油文件。
$ tar –zxvf orientdb-community-2.1.9.tar.gz您可以使用以下命令从 orientdbcommunity-2.1.9 to /opt/orientdb/ 目录移动所有OrientDB库文件。在此，我们使用超级用户命令(sudo)，因此您必须提供超级用户密码以执行以下命令。
$ sudo mv orientdb-community-2.1.9 /opt/orientdb你可以使用以下命令注册 orientdb 命令和 Orient 服务器。
$ export ORIENTDB_HoME = /opt/orientdb
$ export PATH = $PATH:$ORIENTDB_HOME/binStep 3 − Configuring OrientDB Server as a Service
按照上述步骤，你可以使用 OrientDB 的桌面版本。你可以使用以下步骤以服务形式启动 OrientDB 数据库服务器。该程序根据你的操作系统而不同。
In Linux
OrientDB 提供了一个名为 orientdb.sh 的脚本文件，用以将数据库作为守护进程运行。你可以在 OrientDB 安装目录的 bin/directory 中找到它，即 $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使用以下命令将 control.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使用以下命令停止 OrinetDB 服务器守护进程。此处你必须提供你在 orientdb.sh 文件中提到的相应用户的密码来停止服务器。
$ service orientdb stopIn Windows
OrientDB 是一个服务器应用程序，因此它必须在启动关闭 Java 虚拟机进程之前执行多项任务。如果你想手动关闭 OrientDB 服务器，则必须执行 shutdown.bat 文件。但是，如果系统在不执行上述脚本的情况下突然关闭，则服务器实例不会正确停止。Windows 中操作系统使用一组特定信号控制的程序称为 services 。
我们必须使用 Apache Common Daemon ，它允许 Windows 用户将 Java 应用程序包装为 Windows 服务。以下是下载和注册 Apache common daemon 的过程。
-
点击 common-daemon-1.0.15-bin-windows 下载。
-
解压 common-daemon-1.0.15-bin-windows 目录。解压后你会在目录内找到 prunsrv.exe 和 prunmgr.exe 文件。在这些文件中， prunsrv.exe 文件是一个服务应用程序，用于将应用程序作为服务运行。 prunmgr.exe 文件是一个用于监控和配置 Windows 服务的应用程序。
-
转到 OrientDB 安装文件夹 → 创建一个新目录并将其命名为服务。
-
复制 prunsrv.exe 和 prunmgr .exe ，将其粘贴到服务目录中。
-
要将 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打开任务管理器服务，您将看到其中有已注册服务名称的以下屏幕截图。
Step 4 − Verifying OrientDB Installation
此步骤将通过以下步骤验证 OrientDB 数据库服务器安装。
-
Run the server.
-
Run the console.
-
Run the studio.
这根据操作系统而异。
In Linux
按照给定的步骤验证 Linux 中的 OrientDB 安装。
Running the server − 您可以使用以下命令启动服务器。
$ 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]Running the console − 您可以使用以下命令在控制台下运行 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>Running the Studio − 启动服务器后，您可以在浏览器中使用以下 URL ( http://localhost:2480/ )。您将看到以下屏幕截图。
In Windows
按照给定的步骤验证 Windows 中的 OrientDB 安装。
Running the server − 您可以使用以下命令启动服务器。
> 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]Running the console − 您可以使用以下命令在控制台下运行 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\>Running the Studio − 启动服务器后，您可以在浏览器中使用以下 URL ( http://localhost:2480/ )。您将看到以下屏幕截图。
OrientDB - Basic Concepts
OrientDB 的主要功能是对多模型对象的支持，即支持文档、图、键/值和真实对象等不同的模型。它包含一个单独的 API 来支持这四个模型。
Document Model
术语文档模型属于 NoSQL 数据库。这意味着数据存储在文档中，并且一组文档称为 Collection 。从技术上讲，文档表示一组键/值对，或称为字段或属性。
OrientDB 使用类、丛集和链接等概念来存储、分组和分析文档。
下表说明了关系模型、文档模型和 OrientDB 文档模型之间的比较 −
Relational Model |
Document Model |
OrientDB Document Model |
Table |
Collection |
Class or Cluster |
Row |
Document |
Document |
Column |
Key/value pair |
Document field |
Relationship |
Not available |
Link |
Graph Model
图数据结构是一个数据模型，它可以以顶点（节点）的形式存储数据，顶点通过边（弧）相互连接。OrientDB 图数据库的构思源自属性图。顶点和边是图模型的主要组成部分。它们包含属性，这可以使它们看起来类似于文档。
下表显示了图模型、关系数据模型和 OrientDB 图模型之间的比较。
Relational Model |
Graph Model |
OrientDB Graph Model |
Table |
Vertex and Edge Class |
扩展“V”（表示顶点）和“E”（表示边）的类 |
Row |
Vertex |
Vertex |
Column |
Vertex and Edge property |
Vertex and Edge property |
Relationship |
Edge |
Edge |
The Key/Value Model
键/值模型表示数据可以以键/值对的形式存储，其中值可以是简单类型和复杂类型。它可以支持文档和图形元素作为值。
下表说明了关系模型、键/值模型和 OrientDB 键/值模型之间的比较。
Relational Model |
Key/Value Model |
OrientDB Key/Value Model |
Table |
Bucket |
Class or Cluster |
Row |
Key/Value pair |
Document |
Column |
Not available |
文档字段或顶点/边属性 |
Relationship |
Not available |
Link |
The Object Model
此模型由面向对象编程继承，并且支持类型（子类型扩展超类型）之间的 Inheritance 、类型指的是基础类时的 Polymorphism 以及编程语言中使用的对象来自/至的 Direct binding 。
下表说明了关系模型、对象模型和 OrientDB 对象模型之间的比较。
Relational Model |
Object Model |
OrientDB Object Model |
Table |
Class |
Class or Cluster |
Row |
Object |
Document or Vertex |
Column |
Object property |
文档字段或顶点/边属性 |
Relationship |
Pointer |
Link |
在详细讨论之前，最好了解与 OrientDB 相关的基本术语。以下是一些重要的术语。
Record ID
当 OrientDB 生成记录时，数据库服务器会自动为该记录分配一个单元标识符，称为 RecordID (RID)。RID 看起来像 #<cluster>:<position>。 <cluster> 表示集群标识号，<position> 表示集群中记录的绝对位置。
Documents
文档是 OrientDB 中可用的最灵活的记录类型。文档是软类型，由具有定义约束的模式类定义，但你也可以在没有任何模式的情况下插入文档，即它也支持无模式模式。
文档可以通过 JSON 格式轻松地导出和导入。例如，看一看以下 JSON 示例文档。它定义了文档详细信息。
{
"id" : "1201",
"name" : "Jay",
"job" : "Developer",
"creations" : [
{
"name" : "Amiga",
"company" : "Commodore Inc."
},
{
"name" : "Amiga 500",
"company" : "Commodore Inc."
}
]
}Vertex
OrientDB 数据库不仅是文档数据库，也是图形数据库。使用顶点和边等新概念以图形的形式存储数据。在图形数据库中，最基本的数据单位是节点，在 OrientDB 中称为顶点。顶点为数据库存储信息。
Class
类是一种数据模型类型和从面向对象编程范例中汲取的概念。基于传统的文档数据库模型，数据以集合的形式存储，而在关系数据库模型中，数据存储在表中。OrientDB 遵循文档 API 以及 OPPS 范例。作为一个概念，OrientDB 中的类与关系数据库中的表的关系最密切，但是（与表不同）类可以是无模式的，全模式的或混合的。类可以继承自其他类，从而创建类的树。每个类都有自己的集群，（如果未定义，则默认创建）。
Cluster
集群是一个重要的概念，用于存储记录、文档或顶点。简单来说，集群是存储一组记录的地方。默认情况下，OrientDB 将为每个类创建一个集群。一个类的所有记录都存储在具有与类同名的同一集群中。您可以在数据库中创建多达 32,767（2^15-1）个集群。
CREATE class 是一条用于创建带有特定名称的集群的命令。创建集群后，您可以通过在创建任何数据模型期间指定名称来使用该集群来保存记录。
OrientDB - Data Types
OrientDB 原生支持几种数据类型。以下是完整的表格。
Sr. No. |
Type |
Description |
1 |
Boolean |
仅处理值 True 或 False。 Java types : java.lang.Boolean Min : 0 Max : 1 |
2 |
Integer |
32 位有符号整数。 Java types : java.lang.Interger Min : -2,147,483,648 Max : +2,147,483,647 |
3 |
Short |
小的 16 位有符号整数。 Java types : java.lang.short Min : -32,768 Max : 32,767 |
4 |
Long |
大的 64 位有符号整数。 Java types : java.lang.Long Min : -263 Max : +263-1 |
5 |
Float |
十进制数。 Java types : java.lang.Float: 2-149 Max : (2-2-23)*2,127 |
6 |
Double |
具有高精度的十进制数。 Java types : Java.lang.Double. Min : 2-1074 Max : (2-2-52)*21023 |
7 |
Date-time |
具有高达毫秒精度的任何日期。 Java types : java.util.Date |
8 |
String |
任何字符串作为字母数字字符序列。 Java types : java.lang.String |
9 |
Binary |
可以包含任何值作为字节数组。 Java types : byte[ ] Min : 0 Max : 2,147,483,647 |
10 |
Embedded |
记录包含在所有者内部。包含的记录没有 RecordId。 Java types : 记录 |
11 |
Embedded list |
记录包含在所有者内部。包含的记录没有 RecordId，并且只能通过导航所有者记录来访问。 Java types : List<objects> Min : 0 Max : 41,000,000 项 |
12 |
Embedded set |
记录包含在所有者内部。包含的记录没有 RecordId，并且只能通过导航所有者记录来访问。 Java types : set<objects> Min : 0 Max : 41,000,000 项 |
13 |
Embedded map |
记录包含在所有者中作为条目的值，而键只能是字符串。所含记录没有 RecordId，只能通过导航所有者记录来访问它们。@ {s0}：Map <String、ORecord> @ {s1}：0 @ {s2}：41,000,000 项 |
14 |
Link |
指向其他记录的链接。这是一种常见的 1 对 1 关系。@ {s3}：ORID，<? extends ORecord> @ {s4}：1 @ {s5}：32767:2^63-1 |
15 |
Link list |
链接到其他记录。这是一种常见的 1 对多关系，其中仅存储 RecordId。@ {s6}：列表？<扩展 ORecord> @ {s7}：0 @ {s8}：41,000,000 项 |
16 |
Link set |
链接到其他记录。这是一种常见的 1 对多关系。@ {s9}：设置？<扩展 ORecord> @ {s10}：0 @ {s11}：41,000,000 项 |
17 |
Link map |
指向其他记录的链接作为条目值，而键只能是字符串。这是一种常见的 1 对多关系。仅存储 RecordId。@ {s12}：Map <String、? 扩展记录> @ {s13}：0 @ {s14}：41,000,000 项 |
18 |
Byte |
单字节。用于存储小型的 8 位有符号整数。@ {s15}：java.lang.Byte @ {s16}：-128 @ {s17}：+127 |
19 |
Transient |
未存储在数据库中的任何值。 |
20 |
Date |
任何日期作为年、月和日。@ {s18}：java.util.Date |
21 |
Custom |
用于存储提供 Marshall 和 Unmarshall 方法的自定义类型。@ {s19}：OSerializableStream @ {s20}：0 @ {s21}：x |
22 |
Decimal |
未经舍入的十进制数。 Java types : java.math.BigDecimal |
23 |
LinkBag |
以特定 RidBag 形式表示的 RecordId 列表。 Java types : ORidBag |
24 |
Any |
没有确定的类型，用于指定混合类型和 null 的集合。 |
在以下章节中，将讨论如何在 OrientDB 中使用这些数据类型。
OrientDB - Console Modes
OrientDB 控制台是一个 Java 应用程序，用于处理 OrientDB 数据库和服务器实例。OrientDB 支持多种控制台模式。
Interactive Mode
这是默认模式。通过执行以下脚本 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>完成此步骤后，控制台就可以接受命令。
OrientDB - Create Database
OrientDB 数据库的 SQL 参考提供了多个命令，用于创建、修改和删除数据库。
以下语句是 Create Database 命令的基本语法。
CREATE DATABASE <database-url> [<user> <password> <storage-type> [<db-type>]]以下是上文中选项的详细信息。
<database-url> - 定义数据库的 URL。URL 包含两部分，一部分是 <mode>，另一部分是 <path>。
<mode> - 定义模式，即本地模式或远程模式。
<path> - 定义到数据库的路径。
<user> - 定义连接到数据库的用户。
<password> - 定义用于连接到数据库的密码。
<storage-type> - 定义存储类型。可以在 PLOCAL 和 MEMORY 中进行选择。
OrientDB - Alter Database
数据库是一个包含不同属性的重要数据模型，可以根据自己的要求对其进行修改。
以下语句是 Alter Database 命令的基本语法。
ALTER DATABASE <attribute-name> <attribute-value>其中 <attribute-name> 定义要修改的属性， <attributevalue> 定义要为此属性设置的值。
下表定义了用于修改数据库的支持属性列表。
Sr.No. |
Attribute Name |
Description |
1 |
STATUS |
在不同的属性之间定义数据库状态。 |
2 |
IMPORTING |
Sets the importing status. |
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 |
设置用于选择集群的默认策略。这些策略将与类创建一起创建。支持的策略是默认的、循环和平衡的。 |
11 |
MINIMUMCLUSTERS |
设置在创建新类时自动创建的集群的最小数量。默认值为 1。 |
12 |
CUSTOM |
Sets the custom property. |
13 |
VALIDATION |
禁用或启用整个数据库的验证。 |
OrientDB - Backup Database
与 RDBMS 一样，OrientDB 也支持备份和还原操作。在执行备份操作时，它会使用 ZIP 算法将当前数据库的所有文件压缩为 zip 格式。可以通过启用 Automatic-Backup 服务器插件自动使用此功能（备份）。
备份数据库或导出数据库是相同的，但是，根据过程，我们必须知道何时使用备份以及何时使用导出。
在进行备份时，它将创建一个数据库的一致副本，所有进一步的写操作都会被锁定并等待完成备份过程。在此操作中，它将创建一个只读备份文件。
如果你在进行备份时需要并发读写操作，你必须选择导出数据库而不是备份数据库。导出不会锁定数据库，并在导出过程中允许并发写入。
以下语句是数据库备份的基本语法。
./backup.sh <dburl> <user> <password> <destination> [<type>]以下是上文中选项的详细信息。
<dburl> − 位于本地或远程位置的数据库 URL，其中包含数据库。
<user> − 指定运行备份的用户名。
<password> − 提供特定用户的密码。
<destination> − 目标文件位置，指定存储备份 zip 文件的位置。
<type> − 可选的备份类型。它有以下两个选项之一。
-
默认的 − 在备份期间锁定数据库。
-
LVM − 在后台使用 LVM 写时复制快照。
Example
备份 demo 数据库（位于 local file system /opt/orientdb/database/demo 中）到一个名为 sample-demo.zip 的文件，并将其放在当前目录中。
你可以使用以下命令备份数据库 demo。
$ backup.sh plocal: opt/orientdb/database/demo admin admin ./backup-demo.zipUsing Console
你也可以使用 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 secondsOrientDB - Restore Database
与 RDBMS 一样，OrientDB 也支持还原操作。只有在控制台模式下，你才可以成功执行此操作。
以下语句是还原操作的基本语法。
orientdb> RESTORE DATABSE <url of the backup zip file>Example
你必须仅在控制台模式下执行此操作。因此，你首先必须使用以下 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 secondsOrientDB - Connect Database
本章解释如何通过 OrientDB 命令行连接到特定数据库。它打开一个数据库。
以下是连接命令的基本语法。
CONNECT <database-url> <user> <password>以下是上文中选项的详细信息。
<database-url> - 定义数据库的 URL。URL 包含两部分，一是 <mode>，二是 <path>。
<mode> - 定义模式，即本地模式或远程模式。
<path> - 定义到数据库的路径。
<user> - 定义连接到数据库的用户。
<password> - 定义用于连接到数据库的密码。
OrientDB - Disconnect Database
本章介绍如何从 OrientDB 命令行断开与特定数据库的连接。它会关闭当前打开的数据库。
以下语句是 Disconnect 命令的基本语法。
DISCONNECTNote − 你只能在连接到特定数据库后才能使用此命令，并且它只会关闭当前正在运行的数据库。
OrientDB - Info Database
本章介绍如何从 OrientDB 命令行获取特定数据库的信息。
以下语句是 Info 命令的基本语法。
infoNote - 仅在连接到特定数据库后才能使用此命令，它将仅检索当前正在运行的数据库的信息。
Example
在此示例中，我们将使用我们在上一章创建的同名数据库“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 - List Database
本章介绍如何从 OrientDB 命令行获取实例中所有数据库的列表。
以下语句是 info 命令的基本语法。
LIST DATABASESNote − 你只能在连接到本地或远程服务器后才能使用此命令。
Example
在检索数据库列表之前，我们必须通过远程服务器连接到本地主机服务器。需要提醒的是，连接到本地主机实例的用户名和密码分别是 guest 和 guest，这已在 orintdb/config/orientdb-server-config.xml 文件中配置。
可使用以下命令连接到 localhost 数据库服务器实例。
orientdb> connect remote:localhost guest它将询问密码。根据配置文件，guest 的密码也是 guest。如果已成功连接，你将获得以下输出。
Connecting to remote Server instance [remote:localhost] with user 'guest'...OK
orientdb {server = remote:localhost/}>连接到 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 - Freeze Database
每当需要使数据库状态为静态时，这意味着数据库不对任何读、写操作做出响应的状态。简单来说，数据库处于冻结状态。
在本章中，你可以了解如何从 OrientDB 命令行冻结数据库。
以下语句是冻结数据库命令的基本语法。
FREEZE DATABASENote − 在连接到远程或本地数据库中特定数据库后，你才能使用此命令。
OrientDB - Config Database
在本章中，你可以了解如何通过 OrientDB 命令行显示特定数据库的配置。此命令适用于本地和远程数据库。
配置信息包含已启用或未启用的默认缓存、该缓存的大小、负载因子值、映射的最大内存、节点页大小、池的最小和最大大小等。
以下语句是 config 数据库命令的基本语法。
CONFIGNote − 您只能在连接到特定数据库后才能使用此命令。
Example
在本例中，我们将使用之前章节中创建的同名数据库“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-variable> <config-value>Note − 您只能在连接到特定数据库后才能使用此命令。
OrientDB - Export Database
像 RDBMS 一样，OrientDB 也提供导出和导入数据库等功能。OrientDB 使用 JSON 格式导出数据。默认情况下，导出命令使用 GZIP 算法压缩文件。
在导出数据库期间，它不会锁定数据库，这意味着您可以对其执行并发读写操作。这也意味着您可以创建该数据的精确副本，因为并发读写操作。
在本章中，您可以了解如何从 OrientDB 命令行导出数据库。
以下语句是导出数据库命令的基本语法。
EXPORT DATABASE <output file>Note − 您只能在连接到特定数据库后才能使用此命令。
Example
在本例中，我们将使用之前章节中创建的同名数据库“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 377msOrientDB - Import Database
您需要在导入数据库时使用由导出命令生成的导出 JSON 格式文件。
在本章中，您可以了解如何从 OrientDB 命令行导入数据库。
以下命令为导入数据库命令的基本语法。
IMPORT DATABASE <input file>Note − 您只能在连接到特定数据库后才能使用此命令。
OrientDB - Commit Database
与 RDBMS 相似，OrientDB 也提供了提交和回滚等事务概念。 Commit 指关闭事务，通过将所有更改保存到数据库。 Rollback 指恢复数据库状态到打开事务时的那个点。
以下命令为提交数据库命令的基本语法。
COMMITNote −您必须在连接到特定的数据库并且开始事务之后才能使用此命令。
Example
在这个例子中，我们会使用上一章建立的，叫做“demo”的相同数据库。我们将会看到提交事务的操作，以及通过事务储存记录。
首先，使用以下 BEGIN 命令开始事务。
orientdb {db = demo}> BEGIN然后，使用以下命令，插入一条 id = 12 且 name = satish.P 的记录到 employee 表中。
orientdb> INSERT INTO employee (id, name) VALUES (12, 'satish.P')您可以使用以下命令执行事务。
orientdb> commit如果成功提交这个事务，你会看到以下的输出。
Transaction 2 has been committed in 4msOrientDB - Rollback Database
在本章中，你将学会如何通过 OrientDB 命令行界面，回滚尚未提交的事务。
以下命令为回滚数据库命令的基本语法。
ROLLBACKNote −您必须在连接到特定的数据库并且开始事务之后才能使用此命令。
Example
在这个例子中，我们会使用上一章建立的，叫做“demo”的相同数据库。我们将会看到回滚事务的操作，以及通过事务储存记录。
首先，使用以下 BEGIN 命令开始事务。
orientdb {db = demo}> BEGIN然后，使用以下命令，插入一条 id = 12 且 name = satish.P 的记录到 employee 表中。
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 - Optimize Database
根据技术术语， Optimization 意味着“在最短的时间内，达到最好的可能性能”。参照数据库，优化包含最大化数据检索的速度和效率。
OrientDB 支持轻量级边，即数据实体之间的直接关系。简单来说，它是一种字段到字段的关系。OrientDB 提供了优化数据库的不同方式。它支持将常规边转换为轻量级边。
以下命令为优化数据库命令的基本语法。
OPTMIZE DATABASE [-lwedges] [-noverbose]在 lwedges 将常规节点转化为轻量级节点和 noverbose 禁用输出。
OrientDB - Drop Database
类似于 RDBMS，OrientDB 提供了删除数据库的功能。 Drop database 指的是彻底删除一个数据库。
下列陈述是删除数据库命令的基本语法。
DROP DATABASE [<database-name> <server-username> <server-user-password>]以下是上文中选项的详细信息。
<database-name> − 您想要删除的数据库名称。
<server-username> − 拥有删除数据库权限的数据库的用户名。
<server-user-password> − 指定用户的密码。
Example
有两种删除数据库的方法，一种是删除当前已打开的数据库，另一种是通过提供特定名称来删除特定数据库。
在此示例中，我们将使用此前章节中创建的同名数据库“demo”。您可以使用以下命令来删除数据库 demo 。
orientdb {db = demo}> DROP DATABASE如果这个命令成功执行，您将得到以下输出。
Database 'demo' deleted successfully或
您可以使用另一个命令来删除数据库，如下所示。
orientdb> DROP DATABASE PLOCAL:/opt/orientdb/databases/demo admin admin如果这个命令成功执行，您将得到以下输出。
Database 'demo' deleted successfullyOrientDB - Insert Record
OrientDB 是一个 NoSQL 数据库，可以存储文档和面向图的数据。NoSQL 数据库不包含任何表，那么您如何才能作为记录来插入数据。在此，您可以看到以类、特性、顶点和边的形式存在的表数据，这意味着类类似于表，而特性类似于文件。
我们可以在 OrientDB 中使用 schema 来定义所有这些实体。可以将属性数据插入到一个类中。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 – 要插入记录或结果集的位置。
Example
我们考虑一个具有以下字段和类型的 Customer 表。
Sr.No. |
Field Name |
Type |
1 |
Id |
Integer |
2 |
Name |
String |
3 |
Age |
Integer |
您可以通过执行以下命令来创建架构（表）。
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执行所有命令后，您将获得具有 id、name 和 age 字段的表名 Customer。您可以通过在 Customer 表中执行选择查询来检查表。
OrientDB 提供了不同的方式来插入记录。考虑以下包含示例记录的 Customer 表。
Sr.No. |
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 - Display Records
类似于 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 − 定义是否要使用缓存。
Example
让我们考虑一下上一章中创建的以下 Customer 表。
Sr.No. |
Name |
Age |
1 |
Satish |
25 |
2 |
Krishna |
26 |
3 |
Kiran |
29 |
4 |
Javeed |
21 |
5 |
Raja |
29 |
尝试不同的 select 查询以从 Customer 表中检索数据记录。
Method 1 − 您可以使用以下查询从 Customer 表中选择所有记录。
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
----+-----+--------+----+-------+----Method 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
----+-----+--------+----+-------+----Method 3 − 从 Customer 表中选择 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
----+--------+----+-------Method 4 − 从 Customer 表中选择所有记录，其中年龄在 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
----+-----+--------+----+-------+----Method 5 − 从 Customer 表中选择所有记录，其中任何字段都包含单词“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
----+-----+--------+----+-------+----Method 6 − 从 Customer 表中选择按年龄降序排列的所有记录。
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 记录命令的基本语法。
LOAD RECORD <record-id>其中 <record-id> 定义要加载的记录的记录 id。
如果您不知道特定记录的记录 ID，则可以在表上执行任何查询。在结果集中，您会找到相应记录的记录 ID (@rid)。
Example
我们考虑我们在前几章中使用的同一个 Customer 表。
Sr.No. |
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
Reload Record 与加载记录命令类似，也用于从架构中加载特定记录。加载记录会借助记录 ID 加载记录。它在结果集中用 @rid 符号表示。主要区别在于重新加载记录会忽略缓存，当应用外部并发事务更改记录时，这非常有用。它会提供最新更新。
以下语句是重新加载记录命令的基本语法。
RELOAD RECORD <record-id>其中 <record-id> 定义您要重新加载的记录的记录 ID。
如果您不知道特定记录的记录 ID，则可以在表上执行任何查询。在结果集中，您会找到相应记录的记录 ID (@rid)。
Example
让我们考虑我们在上一章中使用的相同的客户表。
Sr.No. |
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
Export Record 是用于将加载的记录导出到请求和支持的格式的命令。如果您执行任何错误的语法，它都会提供支持的格式列表。OrientDB 是一系列文档数据库，因此 JSON 是默认支持的格式。
以下语句是导出记录命令的基本语法。
EXPORT RECORD <format>其中 <Format> 定义您要获取记录的格式。
Note - 导出命令将根据记录 ID 导出加载的记录。
Example
让我们考虑我们在上一章中使用的相同的客户表。
Sr.No. |
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 |
+---------------------------------------------------------------------------+使用以下查询以 JSON 格式导出加载的记录 (#11:0)。
orientdb {db = demo}> EXPORT RECORD json如果成功执行了以上查询，您会获得以下输出。
{
"@type": "d",
"@rid": "#11:0",
"@version": 1,
"@class": "Customer",
"id": 1,
"name": "satish",
"age": 25
}OrientDB - Update Record
Update Record 命令用来修改某个特定记录的值。SET 是更新某个特定字段值的基本命令。
以下语句是更新命令的基本语法。
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 − 定义在超时前允许更新运行的时间。
Example
让我们考虑我们在上一章中使用的相同的客户表。
Sr.No. |
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 Record 命令用于删除特定记录的值。
以下语句是截断命令的基本语法。
TRUNCATE RECORD <rid>*其中 <rid> * 表示要截断的记录 ID。可以使用多个 Rids 并用逗号分隔它们来截断多个记录。它返回截断的记录数。
Example
让我们考虑我们在上一章中使用的相同的客户表。
Sr.No. |
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 Record 命令用于从数据库中完全删除一个或多个记录。
以下语句是删除命令的基本语法。
DELETE FROM <Class>|cluster:<cluster>|index:<index>
[LOCK <default|record>]
[RETURN <returning>]
[WHERE <Condition>*]
[LIMIT <MaxRecords>]
[TIMEOUT <timeout>]以下是上文中选项的详细信息。
LOCK - 指定如何在加载和更新之间锁定记录。我们有两个选项来指定 Default 和 Record 。
RETURN − 指定要在记录数量中返回的表达式。
LIMIT − 定义要更新的最大记录数量。
TIMEOUT − 定义在超时前允许更新运行的时间。
Note − 不要使用 DELETE 删除点或边，因为它会影响图表的完整性。
Example
我们以客户表为例。
Sr.No. |
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 - Create Class
OrientDB 支持多模型功能，并提供不同的方法来理解和了解数据库的基本概念。然而，我们可以轻松访问这些模型，从文档数据库 API 的角度来看。与 RDBMS 类似，OrientDB 也使用 Record 作为存储元素，但它使用 Document 类型。文档以键值对的形式存储。我们将字段和属性存储为属于概念类的键值对。
Class 是一种数据模型，这种概念取自面向对象编程模式。基于传统的文档数据库模型，数据以集合的形式存储，而在关系数据库模型中，数据存储在表中。OrientDB 遵循文档 API 和 OPPS 模式。作为一个概念，OrientDB 中的类与关系数据库中的表有最密切的关系，但是（与表不同）类可以无模式、全模式或混合。类可以从其他类继承，创建类树。每个类都有自己的集群或多个集群（如果未定义，则默认创建）。
以下语句是 Create Class Command 的基本语法。
CREATE CLASS <class>
[EXTENDS <super-class>]
[CLUSTER <cluster-id>*]
[CLUSTERS <total-cluster-number>]
[ABSTRACT]以下是上文中选项的详细信息。
<class> − 定义要创建的类的名称。
<super-class> − 定义要使用此类扩展的超类。
<total-cluster-number> − 定义此类中使用的集群总数。默认值为 1。
ABSTARCT − 定义类是抽象的。此为可选。
Example
如前所述，类是一个与表相关的概念。因此，这里我们将创建一个表 Account。但是，在创建类时，我们无法定义字段，即基于 OOPS 模式的属性。
以下命令用于创建一个名为 Account 的类。
orientdb> CREATE CLASS Account如果上述命令执行成功，您将获得以下输出内容。
Class created successfully您可以使用以下命令来创建一个 Car 类，该类扩展至 Vehicle 类。
orientdb> CREATE CLASS Car EXTENDS Vehicle如果上述命令执行成功，您将获得以下输出内容。
Class created successfully您可以使用以下命令来创建一个抽象 Person 类。
orientdb> CREATE CLASS Person ABSTRACT如果上述命令执行成功，您将获得以下输出内容。
Class created successfullyNote − 在没有属性的情况下，该类是无用的并且无法构建实际对象。在后面的章节中，您可以学习如何为特定类创建属性。
OrientDB - Alter Class
OrientDB 中的类和属性用于构建架构，其中包含不同的属性，例如类名、超类、集群、集群数、抽象等。如果您想修改或更新架构中现有类的任何属性，则必须使用 Alter Class 命令。
以下语句是 Alter Class 命令的基本语法。
ALTER CLASS <class> <attribute-name> <attribute-value>以下是上文中选项的详细信息。
<class> − 定义类名。
<attribute-name> − 定义您想要更改的属性。
<attribute-value> − 定义想要为该属性设置的值。
下表定义了支持 Alter Class 命令的属性列表。
Attribute |
Type |
Description |
NAME |
String |
Changes the class name. |
SHORTNAME |
String |
为类定义一个短名称（即别名）。使用 NULL 删除短名称分配。 |
SUPERCLASS |
String |
为类定义超类。要添加一个新类，您可以使用语法 +<class>，要删除它，请使用 -<class>。 |
OVERSIZE |
Decimal number |
Defines the oversize factor. |
ADDCLUSTER |
String |
将集群添加到类中。如果集群不存在，它将创建一个物理集群。将集群添加到类中也有助于将记录存储在分布式服务器中。 |
REMOVECLUSTER |
String |
从类中删除集群。它不会删除集群，只会将它从类中删除。 |
STRICTMODE |
- |
启用或禁用严格模式。处于严格模式时，您将以模式全模式工作，并且如果属性是类模式定义的一部分，则无法向记录中添加新属性。 |
CLUSTERSELECTION |
- |
定义在选择用于新记录的集群时采用的选择策略。 |
CUSTOM |
- |
定义自定义属性。属性名称和值必须遵循语法 <propertyname>=<value>，名称和值之间没有空格。 |
ABSTRACT |
Boolean |
将类转换为抽象类或相反。 |
OrientDB - Truncate Class
Truncate class 将删除作为类一部分定义的群集的所有记录。在 OrientDB 中，每个类都有一个关联的群集，名称相同。如果您还想要从类层次结构中删除所有记录，您需要使用 POLYMORPHIC 关键字。
以下是 Truncate Class 命令的基本语法。
TRUNCATE CLASS <class> [ POLYMORPHIC ] [ UNSAFE ]以下是上文中选项的详细信息。
<class> −定义您想要截断的类。
POLYMORPHIC −定义此命令是否还截断了层次结构。
UNSAFE - 定义了命令强制对顶点或边类执行截断。
OrientDB - Create Cluster
Cluster 是 OrientDB 中的一个重要概念，用于存储记录、文档或顶点。简单来说，集群是一个存储一组记录的地方。默认情况下，OrientDB 将为每个类创建一个集群。某个类的所有记录都存储在同一个集群中，该集群具有与该类相同名称。可以在数据库中创建多达 32767（2^15-1）个集群。
CREATE class 是一个用于创建特定名称集群的命令。创建集群后，您可以在创建任何数据模型期间指定名称，使用集群来保存记录。如果您想向类中添加一个新集群，请使用 Alter Class 命令和 ADDCLUSTER 命令。
以下语句是 Create Cluster 命令的基本语法。
CREATE CLUSTER <cluster> [ID <cluster-id>]其中 <cluster> 定义所要创建的集群的名称， <cluster-id> 定义所要用于该集群的数字 ID。
下表提供了集群选取策略列表。
Sr.No. |
Strategy & Description |
1 |
Default 使用类属性默认的 ClusterId 选取集群。 |
2 |
Round-robin 以循环顺序选取下一个集群。完成后重新启动。 |
3 |
Balanced 选取最小的集群。该类允许基于大小让所有底层集群保持平衡。向现有类添加新集群时，先填充新集群。 |
OrientDB - Alter Cluster
Alter Cluster 命令用于更新现有集群上的属性。在本部分中，您可以了解如何添加或修改集群的属性。
以下语句是 Alter Cluster 命令的基本语法。
ALTER CLUSTER <cluster> <attribute-name> <attribute-value>以下是上文中选项的详细信息。
<cluster> − 定义集群名称。
<attribute-name> − 定义您想要更改的属性。
<attribute-value> − 定义所要为该属性设置的值。
以下表格格式提供了您可与 Alter cluster 命令一起使用的受支持属性列表。
Name |
Type |
Description |
NAME |
String |
Changes the cluster name. |
STATUS |
String |
更改集群状态。允许的值是 ONLINE 和 OFFLINE。默认情况下，集群是联机的。 |
COMPRESSION |
String |
定义所要使用的压缩类型。允许的值是 NOTHING、SNAPPY、GZIP 和 OCompressionFactory 类中注册的任何其他压缩类型。 |
USE_WAL |
Boolean |
定义当 OrientDB 对该集群执行操作时是否使用日记。 |
RECORD_GROW_FACTO R |
Integer |
定义在创建记录时为节省更多空间而使用的增长因子。在使用其他信息更新记录时，您可能会发现它非常有用。 |
RECORD_OVERFLOW_GR OW_FACTOR |
Integer |
在更新时定义增长因子。当它达到大小限制时，使用此设置以获取更多空间（因子 > 1）。 |
CONFLICTSTRATEGY |
String |
定义在 OrientDB MVCC 对旧记录执行更新或删除操作时，它使用来处理冲突的策略。 |
下表提供了冲突策略列表。
Sr.No. |
Strategy & Description |
1 |
Version 版本不同时引发异常。这是默认设置。 |
2 |
Content 如果版本不同，它会检查内容的变化，否则它将使用最高版本来避免引发异常。 |
3 |
Automerge Merges the changes. |
Example
尝试以下示例查询以学习 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 successfullyOrientDB - Create Property
OrientDB 中的 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 |
OrientDB - Alter Property
Alter Property 是用来修改或更新特定类的属性的命令。更改属性表示修改表中的字段。在本章中，你可以了解如何更新属性。
以下语句是 Alter Property 命令的基本语法。
ALTER PROPERTY <class>.<property> <attribute-name> <attribute-value>以下是上文中选项的详细信息。
<class> − 定义属性所属的类。
<property> − 定义要更新的属性。
<attribute-name> − 定义要更新的属性的属性。
<attribute-value> − 定义要设置在属性上的值。
下表定义了用于更改属性的属性列表。
Attribute |
Type |
Description |
LINKEDCLASS |
String |
定义链接的类名称。使用 NULL 删除现有值。 |
LINKEDTYPE |
String |
定义链接类型。使用 NULL 删除现有值。 |
MIN |
Integer |
定义最小值作为约束。使用 NULL 删除现有约束。 |
MANDATORY |
Boolean |
定义属性是否需要值。 |
MAX |
Integer |
定义最大值作为约束。使用 NULL 删除现有约束。 |
NAME |
String |
Defines the property name. |
NOTNULL |
Boolean |
定义属性是否可以具有 NULL 值。 |
REGEX |
String |
定义正则表达式的作为约束。使用 NULL 删除现有约束。 |
TYPE |
String |
Defines a property type. |
COLLATE |
String |
Sets 归类到一个已定义的比较策略。默认情况下，它设置为区分大小写 (cs)。你还可以将其设置为不区分大小写 (ci)。 |
READONLY |
Boolean |
定义属性值是否不可变。也就是说，是否可以在首次分配之后更改它。与 DEFAULT 结合使用，可在创建时具有不可变值。 |
CUSTOM |
String |
定义自定义属性。自定义属性的语法为 <custom-name> = <custom-value>，比如 stereotype = icon。 |
DEFAULT |
定义默认值或函数。 |
Note - 如果要更改 NAME 或 TYPE，则此命令将根据数据量花费一些时间进行更新。
Example
尝试一些下面给出的查询来理解 Alter 属性。
执行以下查询，将 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 successfullyOrientDB - Drop Property
Drop property 命令从模式中删除属性。它不会从记录中删除属性值，只会更改模式。
以下语句是 Drop Property 命令的基本语法。
DROP PROPERTY <class>.<property> [FORCE]以下是上文中选项的详细信息。
<class> - 定义属性所在类。
<property> - 定义要删除的属性。
[Force] - 如果在属性上定义了一个或多个索引。
OrientDB - Create Vertex
OrientDB 数据库不仅是文档数据库，还是图形数据库。新概念（如顶点和边）用于以图形形式存储数据。它对顶点应用多态性。顶点的基类是 V。
在本教程中，您可以了解如何创建顶点来存储图形数据。
以下是 Create Vertex Command 的基本语法。
CREATE VERTEX [<class>] [CLUSTER <cluster>] [SET <field> = <expression>[,]*]以下是上文中选项的详细信息。
<class> − 定义顶点所属的类。
<cluster> −定义存储顶点的群集。
<field> −定义希望设置的字段。
<expression> −定义要为该字段设置的表达式。
Example
尝试以下示例来了解如何创建顶点。
执行以下查询来创建不带“name”且在基本类 V 上的顶点。
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 - Move Vertex
OrientDB 中的移动顶点命令是将一个或多个顶点从当前位置移动到不同的类或集群。如果你将移动命令应用于特定顶点，则它将更新连接到此顶点的所有边。如果你指定一个集群来移动顶点，则它会将顶点移动到目标集群的所有者服务器。
以下语句是 Move Vertex 命令的基本语法。
MOVE VERTEX <source> TO <destination>
[SET [<field>=<value>]* [,]]
[MERGE <JSON>]
[BATCH <batch-size>]以下是上文中选项的详细信息。
<source> - 定义要移动的顶点。它接受特定顶点的记录 ID 或顶点的记录 ID 数组。
<destination> - 定义要将顶点移动到哪里。它将类或集群作为目的地。
SET - 向字段设置值。
MERGE − 通过 JSON 设置字段的值。
BATCH − 定义批处理大小。
Note − 此命令更新所有已连接的边，但不更新链接。在使用图 API 时，建议使用连到顶点的边。
Example
尝试以下示例来了解如何移动顶点。
执行以下查询，将记录 ID 为 #11:2 的单个顶点从当前位置移到员工类别。
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)执行以下查询，将一组顶点从“客户”类别移到“员工”类别。
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 - Delete Vertex
Delete Vertex 命令用于从数据库中删除顶点。在删除时，它将检查并维护与边的连贯性，并删除指向已删除顶点的所有交叉引用（与边）。
以下语句是删除顶点命令的基本语法。
DELETE VERTEX <vertex> [WHERE <conditions>]
[LIMIT <MaxRecords>>] [BATCH <batch-size>]以下是上文中选项的详细信息。
<vertex> - 使用类、记录 ID 或子查询定义要删除的顶点。
WHERE - 过滤条件，用于确定命令删除哪些记录。
LIMIT - 定义要删除的最大记录数。
BATCH - 定义命令一次删除多少条记录，允许将大事务分解成小块，以节省内存使用量。
Example
试试以下命令来学习如何删除单个顶点或多个顶点。
执行以下命令，删除顶点 ‘#14:1’。
orientdb> DELETE VERTEX #14:1如果上述命令执行成功，您将获得以下输出内容。
Delete record(s) '1' in 0.005000 sec(s)执行以下命令，删除所有标记为 ‘isSpam’ 属性的类 ‘Customer’ 中的顶点。
orientdb> DELETE VERTEX Customer WHERE isSpam = TRUE如果上述命令执行成功，您将获得以下输出内容。
Delete record(s) '3' in 0.005000 sec(s)OrientDB - Create Edge
在 OrientDB 中， Edge 概念的作用是借助一些属性在顶点之间建立关系。边和顶点是图数据库的主要组成部分。它对边运用多态。边的基类是 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 − 定义它是否将命令分解为较小的块以及批处理的大小。
Example
执行以下查询，在两个顶点 #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 - Update Edge
Update edge 命令用于更新当前数据库中的边记录。这相当于实际的 update 命令，除了在事件中检查和维护与顶点的一致性外，还可以更新 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 − 定义最大记录数。
OrientDB - Delete Edge
Delete edge 命令用于删除数据库。这相当于删除命令，此外还检查并通过从“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 − 定义操作的块大小。
Example
尝试以下示例以了解如何删除边。
执行以下查询删除两个顶点（#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 - Functions
本章解释了 OrientDB 中不同类型函数的完整参考。下表定义了按其功能分类的函数列表。
Graph Functions
使用以下查询尝试一些图函数。
执行以下查询以获取所有车辆顶点的所有传出顶点。
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
---+----------+-------+-------Math Functions
使用以下查询尝试一些数学函数。
执行以下查询以获取所有员工的薪水总和。
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
---+----------+---------Collections Functions
使用以下查询尝试一些集合函数。
执行以下查询以获取教授 9 年级课程的一组教师。
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
---+----------+-------+---------------------------Misc Functions
使用以下查询尝试一些其他函数。
执行以下查询以学习如何执行 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 - Sequences
Sequences 是在自动递增机制中使用的概念，它在 OrientDB v2.2 中引入。在数据库术语中，序列是一种管理计数器字段的结构。简单来说，序列通常在需要始终递增的数字时使用。它支持两种类型−
ORDERED −每次指针调用返回新值的 .next 方法。
CACHED −序列将在每个节点上缓存“N”个项目。若要调用每个项目，我们使用 .next() ，在缓存包含多个项目时首选它。
Create Sequence
序列通常用于自动增加人员的 ID 值。与 OrientDB 的其他 SQL 概念一样，它还执行与 RDBMS 中的序列类似的操作。
以下语句是创建序列的基本语法。
CREATE SEQUENCE <sequence> TYPE <CACHED|ORDERED> [START <start>]
[INCREMENT <increment>] [CACHE <cache>]以下是上文中选项的详细信息。
<Sequence> −序列的本地名称。
TYPE −定义序列类型为有序或缓存。
START −定义初始值。
INCREMENT −为每个 .next 方法调用定义增量。
CACHE −定义预缓存的值的数量（如果使用了缓存序列类型）。
让我们创建一个以数字 1201 开头的名为“seqid”的序列。尝试以下查询使用序列实现此示例。
CREATE SEQUENCE seqid START 1201如果成功执行了以上查询，您会获得以下输出。
Sequence created successfully尝试以下查询使用序列“seqid”插入帐户表的 ID 值。
INSERT INTO Account SET id = sequence('seqid').next()如果成功执行了以上查询，您会获得以下输出。
Insert 1 record(s) in 0.001000 sec(s)Alter Sequence
Alter sequence 是一条用于更改序列属性的命令。它将修改除序列类型以外的所有序列选项。
以下语句是更改序列的基本语法。
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 successfullyOrientDB - Indexes
Index 是指向数据库中数据位置的指针。 Indexing 是一个概念，用于快速找到数据而无需搜索数据库中的每条记录。OrientDB 支持四种索引算法和其中的若干类型。
四种索引类型是：
SB-Tree Index
它提供了一种从其他索引类型中获得的良好功能组合。最好将其用于常规实用工具。它耐用，可进行事务处理并支持范围查询。它是默认索引类型。支持此算法的不同类型插件包括：
-
UNIQUE - 这些索引不允许重复键。对于复合索引，这指的是复合键的唯一性。
-
NOTUNIQUE - 这些索引允许重复键。
-
FULLTEXT - 这些索引基于文本中的任何单个单词。您可以通过 CONTAINSTEXT 运算符在查询中使用它们。
-
DICTIONARY - 这些索引类似于使用 UNIQUE 的索引，但对于重复键，它们会用新记录替换现有记录。
Hash Index
它的性能更快，并且磁盘占用量非常小。它耐用、可进行事务处理，但不支持范围查询。它的工作原理类似于 HASHMAP，这使得它在点查找方面更快速并且比其他索引类型消耗更少的资源。支持此算法的不同类型插件包括：
-
UNIQUE_HASH_INDEX - 这些索引不允许重复键。对于复合索引，这指的是复合键的唯一性。
-
NOTUNIQUE_HASH_INDEX - 这些索引允许重复键。
-
FULLTEXT_HASH_INDEX - 这些索引基于文本中的任何单个单词。您可以通过 CONTAINSTEXT 运算符在查询中使用它们。
-
DICTIONARY_HASH_INDEX - 这些索引类似于使用 UNIQUE_HASH_INDEX 的索引，但在重复键的情况下，它们会用新记录替换现有记录。
Creating Indexes
Create index 是在特定架构上创建索引的命令。
以下语句是创建索引的基本语法。
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 表示。
OrientDB - Transactions
与 RDBMS 类似，OrientDB 支持事务 ACID 属性。 transaction 包含在数据库管理系统内执行的工作单元。在数据库环境中维护事务有两个主要原因。
-
允许从故障中并发恢复，并在系统故障的情况下保持数据库一致性。
-
在并发访问数据库的程序之间提供隔离。
默认情况下，数据库事务必须遵循 ACID 属性，如原子性、一致性、隔离性和持久性属性。但 OrientDB 是一个 ACID 兼容数据库，这意味着它不会矛盾或否定 ACID 的概念，而是在处理 NoSQL 数据库时改变了它的认知。了解 ACID 属性如何与 NoSQL 数据库一起工作。
Atomic −当您执行更改数据库操作时，更改应完全成功或失败。
Consistent −数据库应保持一致。
Isolated −如果其他事务执行同时执行，那么用户将无法看到并行执行中的记录。
Durable −如果系统崩溃（硬件或软件），数据库本身应该能够进行备份。
可以使用提交和回滚命令实现数据库事务。
Commit
提交表示通过将所有更改保存到数据库来关闭事务。回滚表示将数据库状态恢复到打开事务时的点。
以下是 COMMIT 数据库命令的基本语法。
COMMITNote −您必须在连接到特定的数据库并且开始事务之后才能使用此命令。
Example
在这个示例中，我们将使用这个教程早期某个章节中创建的、称为“demo”的相同的数据库。我们将看到执行事务的操作并将记录使用事务存储起来。
您需要首先使用以下 BEGIN 命令开始事务。
orientdb {db = demo}> BEGIN使用以下命令向包含 id = 12 和 name = satish.P 值的 employee 表中插入一条记录。
orientdb> INSERT INTO employee (id, name) VALUES (12, 'satish.P')您可以使用以下命令执行事务。
orientdb> commit如果此事务成功执行，您将得到以下输出。
Transaction 2 has been committed in 4msRollback
回滚意味着将数据库状态恢复到打开事务时的点。
以下语句是 ROLLBACK 数据库命令的基本语法。
ROLLBACKNote −您必须在连接到特定的数据库并且开始事务之后才能使用此命令。
Example
在这个示例中，我们将使用这个教程早期某个章节中创建的、称为“demo”的相同的数据库。我们将看到执行回滚事务的操作并将记录使用事务存储起来。
您必须首先使用以下 BEGIN 命令开始事务。
orientdb {db = demo}> BEGIN使用以下命令向包含 id = 12 和 name = satish.P 值的 employee 表中插入一条记录。
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'如果 Rollback 成功执行，您将在输出中得到 0 条记录已找到。
0 item(s) found. Query executed in 0.037 sec(s).OrientDB - Hooks
OrientDB Hooks 不过是在数据库术语中触发器，它们启用在用户应用程序中的每个 CRUD 操作之前和之后的内部事件。您可以使用钩子来编写自定义验证规则，以强制执行安全性，或安排外部事件，比如对于关系 DBMS 进行复制。
OrientDB 支持两种钩子 −
Dynamic Hook − 触发器，可以在类级别和/或文档级别构建。
Java (Native) Hook − 触发器，可以使用 Java 类构建。
Dynamic Hooks
动态钩子比 Java 钩子更灵活，因为它们可以在运行时更改并且可以在需要时针对每个文档运行，但是比 Java 钩子慢。
要在您的文档上执行钩子，首先允许您的类扩展 OTriggered 基类。之后，为相关事件定义一个自定义属性。以下是可用的事件。
-
onBeforeCreate − 在 before 创建新文档时调用。
-
onAfterCreate − 在 after 创建新文档时调用。
-
onBeforeRead − 在 before 读取文档时调用。
-
onAfterRead − 在 after 读取文档时调用。
-
onBeforeUpdate − 在 before 更新文档时调用。
-
onAfterUpdate − 在 after 更新文档时调用。
-
onBeforeDelete − 在 before 删除文档时调用。
-
onAfterDelete − 在 after 删除文档时调用。
动态钩子可以调用 −
-
函数，用 SQL、JavaScript 或 OrientDB 和 JVM 支持的任何语言编写。
-
Java static methods.
Class Level Hooks
类级别钩子为与类相关的所有文件定义。以下示例设置一个在类级别下对发票文件起作用的钩子。
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: 100Document Level Hook
您只能针对一个或多个文件定义特别操作。为此，允许类扩展 OTriggered 类。
例如，让我们针对现有 Profile 类的所有文件（带有 account = 'Premium' 属性）以 Javascript 函数形式执行一个触发器。此触发器将被调用以防止删除文件。
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 2JAVA Hooks
OrientDB 钩子（触发器）的一个常见用例是管理任何或所有类的创建和更新日期。例如，可以设置一个 CreatedDate 字段，在创建记录时使用该字段，设置一个 UpdatedDate 字段，在更新记录时使用该字段，并且可以采用在数据库层一次实现逻辑，无需在应用程序层再次考虑的方法来执行这些操作。
在创建之前，您将必须通过访问以下链接 download OrientDB core 下载 orientdb-core.jar 文件。然后将 JAR 文件复制到要存储 Java 源文件的文件夹中。
Create Hook File
创建一个名为 HookTest.java 的 Java 文件，该文件将使用 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 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。
Compile Java Hooks
使用以下命令编译 Java 代码。 Note ：将下载的 JAR 文件和这些 Java 文件保留在同一个文件夹中。
$ jar cf hooks-1.0-SNAPSHOT.jar *.javaMove Compiled Code to Where OrientDB Server Can Find It
您需要将完成的 JAR 文件复制到 OrientDB 服务器将对其进行查找的目录中。这意味着 OrientDB 服务器根目录下的“ ./lib ”文件夹将如下所示：
$ cp hooks-1.0-SNAPSHOT.jar "$ORIENTDB_HOME/lib"Enable Test Hook in the OrientDB Server Configuration File
编辑 $ORIENTDB_HOME/config/orientdb-server-config.xml ，并添加以下部分到该文件的末尾：
<hooks>
<hook class = "HookTest" position = "REGULAR"/>
</hooks>
...
</orient-server>Restart OrientDB Server
一旦重新启动 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 hookEnable Real Hook in the OrientDB Server Configuration File
编辑 $ORIENTDB_HOME/config/orientdb-server-config.xml ，并将钩子部分更改如下：
<hooks>
<hook class="setCreatedUpdatedDates" position="REGULAR"/>
</hooks>
...
</orient-server>Restart OrientDB Server
从字母“ 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 Hooks 可能是极有价值的工具，可以帮助您自动完成本来需要在应用程序代码中完成的工作。由于许多 DBA 并不总是 Java 专家，因此希望本教程中包含的信息能为您提供良好的开端，并让您对这项技术充满信心，使您能够在需要时成功创建数据库触发器。
OrientDB - Caching
Caching 是一个概念，它将创建一个数据库表结构的副本，为用户应用程序提供一个舒适的环境。OrientDB 具有多个不同级别的缓存机制。
以下插图给出了有关缓存是什么的想法。
在上述插图中， DB1 、 DB2 、 DB3 是应用程序中使用的三个不同的数据库实例。
Level-1 缓存是一个 Local cache ，它存储特定会话已知的所有实体。如果此会话中有三个事务，它将保留所有三个事务使用的所有实体。当您关闭会话或执行“clear”方法时，会清除此缓存。它减轻了应用程序与数据库之间的 I/O 操作负担，进而提高了性能。
Level-2 缓存是一个 Real cache ，它通过使用第三方提供程序来工作。您可以完全控制缓存的内容，即您将能够指定应删除哪些条目，应将哪些条目存储更长时间，依此类推。它是多个线程之间的完全共享缓存。
Storage model 就是存储设备，即磁盘、内存或远程服务器。
How Cache Works in OrientDB?
OrientDB 缓存可在不同环境中提供不同的方法。缓存主要用于更快的数据库事务，减少事务的处理时间并提高性能。以下流程图显示了缓存如何在本地模式和客户端-服务器模式下工作。
OrientDB - Logging
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 (highest value)
-
WARNING
-
INFO
-
CONFIG
-
FINE
-
FINER
-
FINEST (lowest value)
默认情况下，安装了两个日志记录器：
-
Console 是作为启动应用程序/服务器的外壳/命令提示符的输出。可以通过设置变量 log.console.level 来更改。
-
File 是作为输出至日志文件。可以通过设置 log.file.level 来更改。
Configure Logging
可以使用 Java 之后的日志策略和策略配置一个文件。
syntax − Java 日志记录配置。
Example
从 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 ...Set the logging level
要更改日志记录级别而不修改日志记录配置，只要将“ log.console.level ”和“ log.file.level ”系统变量设置为请求的级别即可。
In the Server Configuration
打开文件 orientdb-server-config.xml ，在 <properties> 部分的文件末尾添加或更新以下行 −
<entry value = "fine" name = "log.console.level" />
<entry value = "fine" name = "log.file.level" />In Server.sh (or .bat) Script
使用 java 的 -D 参数将系统属性“ log.console.level ”和“ log.file.level ”设置为所需的级别。
$ java -Dlog.console.level = FINE ...By Using Java Code
可以使用 System.setProperty() API 在启动时设置系统变量。以下代码段是使用 Java 代码设置日志记录级别的语法。
public void main(String[] args){
System.setProperty("log.console.level", "FINE");
...
}OrientDB - Performance Tuning
在本章中，你可以获得一些关于如何优化使用 OrientDB 的应用程序的一般性技巧。有三种方法可以提高不同类型数据库的性能。
-
Document Database Performance Tuning − 它使用一种有助于避免为每个新文档创建文档的技术。
-
Object Database Performance Tuning − 它使用通用技术来提高性能。
-
Distributed Configuration Tuning − 它使用不同的方法来提高分布式配置中的性能。
你可以通过更改内存、JVM 和远程连接设置来实现通用性能调整。
Memory Settings
在内存设置中有不同的策略可以提高性能。
Server and Embedded Settings
这些设置对服务器组件和在嵌入模式下直接使用 plocal 运行 Java 应用程序的 JVM 均有效。
调优最重要的在于确保内存设置正确。决定性因素在于正确平衡内存映射中使用的堆和虚拟内存，特别是在大数据集方面（GB、TB 及以上），在这种情况下，内存内缓存结构的重要性低于原始 IO。
例如，如果可以将最高 8GB 分配给 Java 进程，那么通常分配小堆和较大的磁盘高速缓存（堆外内存）会更好。
尝试以下命令增加堆内存。
java -Xmx800m -Dstorage.diskCache.bufferSize=7200 ...设置 storage.diskCache.bufferSize （旧“本地”存储为 file.mmap.maxMemory ）以 MB 为单位，说明磁盘高速缓存组件使用多少内存。默认值为 4GB。
NOTE − 如果最大堆和磁盘高速缓存的总和过高，可能会导致操作系统因巨大减速而交换。
JVM Settings
JVM 设置编码在 server.sh（和 server.bat）批处理文件中。您可以更改它们来根据您的使用情况和硬件/软件设置来调整 JVM。在 server.bat 文件中添加以下行。
-server -XX:+PerfDisableSharedMem此设置将禁用 JVM 的调试信息写入。如果您需要分析 JVM，只需移除此设置。
Remote Connections
使用远程连接访问数据库时有许多方法可以提高性能。
Fetching Strategy
使用远程数据库时，您必须注意所使用的获取策略。默认情况下，OrientDB 客户端仅加载结果集中包含的记录。例如，如果查询返回 100 个元素，但您如果从客户端遍历这些元素，则 OrientDB 客户端会延迟为每个丢失的记录向服务器进行一次网络调用来加载元素。
Network Connection Pool
默认情况下，每个客户端仅使用一个网络连接与服务器通信。同一客户端的多个线程共享相同的网络连接池。
当有多个线程时，可能会出现瓶颈，因为要等待释放网络连接而花费大量时间。这就是配置网络连接池很重要的原因。
配置非常简单，仅有 2 个参数 −
-
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");Distributed Configuration Tuning
通过分布式配置提高性能有很多方法。
Use Transactions
即使更新图形，您也应始终在事务中工作。OrientDB 允许您在事务之外工作。常见情况是只读查询，或者在发生故障时可以恢复的庞大且非并发操作。当您在分布式配置上运行时，使用事务有助于降低延迟。这是因为分布式操作仅在提交时发生。由于延迟，分配一个大操作比传输多个小操作更有效。
Replication vs Sharding
OrientDB 分布式配置设置为完全复制。拥有多个具有相同数据库副本的节点对于扩展读取非常重要。事实上，每台服务器都是独立执行读取和查询的。如果您有 10 个服务器节点，则读取吞吐量就是 10 倍。
对于写入操作，正好相反：如果复制是同步的，则具有完全复制的多个节点会使操作变慢。在这种情况下，将数据库分片到多个节点可以扩展写入，因为只有部分节点参与写入。此外，你的数据库可以大于一个服务器节点的 HD。
Scale up on Writes
如果你有慢速网络，并且有同步（默认）复制，则可能会付出延迟的代价。事实上，当 OrientDB 同步运行时，它至少等待 writeQuorum 。这意味着，如果 writeQuorum 为 3，并且有 5 个节点，则协调器服务器节点（分布式操作在那里启动）必须至少等待来自 3 个节点的响应，才能向客户端提供响应。
为了保持一致性，应将 writeQuorum 设置为多数。如果你有 5 个节点，则多数为 3。将 writeQuorum 设置为 3 而不是 4 或 5 可以降低延迟成本，同时仍保持一致性。
OrientDB - Upgrading
升级时，必须考虑版本号和格式。有三种类型的格式 - MAJOR（主要）、MINOR（次要）、PATCH（修补）。
-
MAJOR 版本涉及不兼容的 API 更改。
-
MINOR 版本以向后兼容的方式提供功能。
-
PTCH 版本涉及向后兼容的错误修复。
要在次要版本和主要版本之间同步，可能需要导出并导入数据库。有时，可能需要将数据库从 LOCAL 迁移到 PLOCAL，并且需要将图迁移到 RidBag。
Migrate from LOCAL Storage Engine to PLOCAL
从版本 1.5.x 开始，OrientDB 带有一个全新的存储引擎：PLOCAL（分页 LOCAL）。它与 LOCAL 一样持久，但以不同的方式存储信息。以下各点显示了 PLOCAL 和 LOCAL 之间的比较 −
-
在 PLOCAL Records 中存储在集群文件内，而 LOCAL 会在集群和数据段之间拆分。
-
由于采用追加写入模式，因此 PLOCAL 比 LOCAL 更耐用。
-
PLOCAL 在写入时具有较小的争用锁，这意味着更具并发性。
-
PLOCAL 不使用内存映射技术 (MMap)，因此行为“可预测”。
若要将本地存储迁移到新 PLOCAL，需要使用 PLOCAL 作为存储引擎导出并重新导入数据库。以下为步骤。
Step 1 − 打开一个新 shell（Linux/Mac）或命令提示符（Windows）。
Step 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> DISCONNECTStep 3 − 在本地文件系统中，使用“plocal”引擎创建新数据库 −
orientdb> CREATE DATABASE plocal:/temp/newdb admin admin plocal graphStep 4 − 将旧数据库导入到新数据库中。
orientdb> IMPORT DATABASE /temp/demo.json.gzip -preserveClusterIDs=true
orientdb> QUIT如果您在相同 JVM 中访问数据库，请务必将 URL 从“local:”更改为“plocal:”
OrientDB - Security
与 RDBMS 一样，OrientDB 也提供基于众所周知概念、用户和角色的安全机制。每个数据库都有自己的用户，每个用户有一个或多个角色。角色是工作模式和权限集的组合。
Users
默认情况下，OrientDB 为服务器中的所有数据库维护三个不同的用户 −
-
Admin − 此用户可以不受限制地访问数据库上的所有功能。
-
Reader − 此用户是只读用户。读者可以查询数据库中的任何记录，但不能修改或删除它们。它无权访问内部信息，例如用户和角色本身。
-
Writer − 此用户与用户 reader 相同，但它还可以创建、更新和删除记录。
Working with Users
连接到数据库后，可以通过对 OUser 类的 SELECT 查询来查询数据库上的当前用户。
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).Creating a New User
要创建新用户，请使用 INSERT 命令。请记住，在此过程中，你必须将状态设置为 ACTIVE，并授予它一个有效角色。
orientdb> INSERT INTO OUser SET
name = 'jay',
password = 'JaY',
status = 'ACTIVE',
roles = (SELECT FROM ORole WHERE name = 'reader')Roles
角色决定用户可以对资源执行哪些操作。该决定主要取决于工作模式和规则。规则本身根据工作模式会采用不同的工作方式。
Working with Roles
连接到数据库后，可以使用对 ORole 类的 SELECT 查询来查询数据库上的当前角色。
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).Creating New Roles
要创建新角色，请使用 INSERT 语句。
orientdb> INSERT INTO ORole SET name = 'developer', mode = 0Working with Modes
规则用于确定属于特定角色的用户在数据库上可以做什么，工作模式用于确定 OrientDB 如何解释这些规则。工作模式有两种类型，由 1 和 0 指定。
-
Allow All But (Rules) − 默认情况下，这是超级用户模式。使用规则指定此模式的例外情况。如果 OrientDB 未为所请求资源找到规则，则允许用户执行操作。主要对高级用户和管理员使用此模式。默认角色 admin 默认使用此模式，且没有例外规则。在数据库中写为 1。
-
Deny All But (Rules) − 默认情况下，此模式不允许任何操作。使用规则指定此模式的例外情况。如果 OrientDB 为所请求资源找到规则，则允许用户执行操作。对所有经典用户使用此模式作为默认模式。默认角色 reader 和 writer 使用此模式。在数据库中写为 0。
OrientDB - Studio
OrientDB 提供了一个 Web UI 来通过 GUI 执行数据库操作。本章介绍 OrientDB 中提供的不同选项。
Studio Homepage
Studio 是一个用于管理 OrientDB 的 Web 界面，作为 OrientDB 发行版的一部分提供。
首先，你需要使用以下命令启动 OrientDB 服务器。
$ server.sh在计算机上运行 OrientDB 时，可以通过 URL 访问 Web 界面 −
http://localhost:2480如果成功执行了该命令，屏幕上会出现以下输出。
Connect to an Existing Database
要登录，请从数据库列表中选择一个数据库，并使用任意数据库用户。默认情况下（用户名/密码）， reader/reader 可以读取数据库中的记录， writer/writer 可以读取、创建、更新和删除记录，而 admin/admin 拥有所有权限。
Drop an Existing Database
从数据库列表中选择一个数据库，然后单击废纸篓图标。Studio 会打开一个确认弹出窗口，你必须在其中输入服务器用户名和服务器密码。
然后单击“删除数据库”按钮。你可以在 $ORIENTDB_HOME/config/orientdb-server-config.xml 文件中找到服务器凭证。
<users>
<user name = "root" password = "pwd" resources = "*" />
</users>Create a New Database
要创建一个新数据库，请单击主页上的“新建数据库”按钮。
需要以下信息才能创建新数据库 −
-
Database name
-
Database type (Document/Graph)
-
Storage type (plocal/memory)
-
Server user
-
Server password
你可以在 $ORIENTDB_HOME/config/orientdbserver-config.xml 文件中找到服务器凭证。
<users>
<user name = "root" password = "pwd" resources = "*" />
</users>创建后，Studio 会自动登录到新数据库。
Execute a Query
Studio 支持对你正在使用的语言（包括 SQL 和 Gremlin）来自动识别。在编写时，按 Ctrl + Space 使用自动完成功能。
查询编辑器中提供以下快捷方式 −
-
Ctrl + Return − 执行查询或只需单击 Run 按钮。
-
Ctrl/Cmd + Z − 撤消更改。
-
Ctrl/Cmd + Shift + Z - 重做更改。
-
Ctrl/Cmd + F - 在编辑器中搜索。
-
Ctrl/Cmd + / - 切换注释。
以下截图显示了如何执行查询。
通过单击结果集中任何 @rid 值，如果记录是文档，您将进入文档编辑模式；否则，您将进入顶点编辑模式。
您可以通过单击结果集中或编辑器中的星形图标对查询进行书签。要浏览有书签的查询，请单击 Bookmarks 按钮。Studio 将在左侧打开书签列表，您可以在其中编辑/删除或重新运行查询。
Studio 将执行的查询保存在浏览器的本地存储中。在查询设置中，您可以配置 Studio 在历史记录中保留多少查询。您还可以搜索以前执行的查询、从历史记录中删除所有查询或删除单个查询。
Edit Vertex
要编辑图表的顶点，请转到图部分。然后运行以下查询。
Select From Customer在成功运行查询后，以下是输出屏幕截图。选择图画布中的特定顶点进行编辑。
选择特定顶点上的编辑符号。您将获得以下屏幕，其中包含编辑顶点的选项。
Graph Editor
单击图部分。您不仅可以在图样式中可视化数据，还可以与图进行交互并对其进行修改。
若要填充图表区域，请在查询编辑器中键入查询或使用浏览界面左的发送到图表功能。
OrientDB - Java Interface
与 RDBMS 类似，OrientDB 支持 JDBC。为此，我们首先需要为 JDBC 编程配置环境。以下是创建应用程序和数据库之间连接的过程。
首先，我们需要下载 JDBC 驱动程序。访问以下链接 https://code.google.com/archive/p/orient/downloads 下载 OrientDB-JDBC。
以下是实现 OrientDB-jdbc 连接的基本五个步骤。
-
Load JDBC driver
-
Create Connection
-
Create statement
-
Execute statement
-
Close connection
Example
尝试以下示例来理解 OrientDB-JDBC 连接。让我们考虑一张包含以下字段及其类型的员工表。
Sr.No. |
Field Name |
Type |
1 |
Id |
Integer |
2 |
Name |
String |
3 |
Salary |
Integer |
4 |
Join date |
Date |
您可以通过执行以下命令创建架构（表）。
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执行所有命令后，将生成包含以下字段的 Employee 表，即带 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 InsertedOrientDB - Python Interface
面向 Python 的 OrientDB 驱动程序使用二进制协议。PyOrient 是帮助将 OrientDB 连接到 Python 的 git hub 项目名称。它适用于 OrientDB 1.7 及更高版本。
以下命令用于安装 PyOrient。
pip install pyorient可以将名为 demo.py 的脚本文件用于执行以下任务：
-
创建客户端实例，即创建连接。
-
Create DB named DB_Demo.
-
Open DB named DB_Demo.
-
Create class my_class.
-
创建属性 ID 和名称。
-
插入记录到我的类。
//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