OrientDB-퀵 가이드
OrientDB는 오픈 소스 NoSQL 데이터베이스 관리 시스템입니다. NoSQL Database문서 데이터 또는 그래프 데이터와 같은 표 형식 데이터 이외의 데이터를 참조하는 NO- 관계 또는 비 관계형 데이터를 저장하고 검색하는 메커니즘을 제공합니다. NoSQL 데이터베이스는 빅 데이터 및 실시간 웹 애플리케이션에서 점점 더 많이 사용되고 있습니다. NoSQL 시스템은 SQL과 유사한 쿼리 언어를 지원할 수 있음을 강조하기 위해 "Not Only SQL"이라고도합니다.
OrientDB는 또한 NoSQL 제품군에 속합니다. OrientDB는 Apache 2 라이센스의 오픈 소스를 사용하여 하나의 제품에서 문서의 유연성을 갖춘 2 세대 분산 그래프 데이터베이스입니다. OrientDB 이전에는 시장에 여러 NoSQL 데이터베이스가 있었고 그중 하나는 MongoDB였습니다.
MongoDB 대 OrientDB
MongoDB와 OrientDB에는 많은 공통 기능이 포함되어 있지만 엔진은 근본적으로 다릅니다. MongoDB는 순수 문서 데이터베이스이고 OrientDB는 그래프 엔진이있는 하이브리드 문서입니다.
| 풍모 | MongoDB | OrientDB |
|---|---|---|
| Relationships | RDBMS JOINS를 사용하여 엔터티 간의 관계를 만듭니다. 런타임 비용이 높고 데이터베이스 규모가 증가해도 확장되지 않습니다. | 관계형 데이터베이스와 같은 문서를 포함하고 연결합니다. 그래프 데이터베이스 세계에서 가져온 직접적이고 초고속 링크를 사용합니다. |
| Fetch Plan | 비용이 많이 드는 JOIN 작업. | 상호 연결된 문서로 전체 그래프를 쉽게 반환합니다. |
| Transactions | ACID 트랜잭션은 지원하지 않지만 원자 적 작업을 지원합니다. | ACID 트랜잭션과 원자 적 작업을 지원합니다. |
| Query language | JSON을 기반으로하는 자체 언어가 있습니다. | 쿼리 언어는 SQL을 기반으로합니다. |
| Indexes | 모든 인덱스에 대해 B- 트리 알고리즘을 사용합니다. | 사용자가 최상의 성능을 얻을 수 있도록 세 가지 다른 인덱싱 알고리즘을 지원합니다. |
| Storage engine | 메모리 매핑 기술을 사용합니다. | 스토리지 엔진 이름 LOCAL 및 PLOCAL을 사용합니다. |
OrientDB는 그래프의 힘과 문서의 유연성을 확장 가능한 고성능 운영 데이터베이스로 결합한 최초의 다중 모델 오픈 소스 NoSQL DBMS입니다.
OrientDB 설치 파일은 두 가지 버전으로 제공됩니다.
Community Edition − OrientDB 커뮤니티 에디션은 Apache에서 0.2 라이선스에 따라 오픈 소스로 출시되었습니다.
Enterprise Edition− OrientDB 엔터프라이즈 에디션은 커뮤니티 에디션에 구축 된 독점 소프트웨어로 출시됩니다. 커뮤니티 에디션의 확장으로 사용됩니다.
이 장에서는 오픈 소스이기 때문에 OrientDB 커뮤니티 에디션의 설치 절차를 설명합니다.
전제 조건
커뮤니티 및 엔터프라이즈 에디션은 모두 JVM (Java Virtual Machine)을 구현하는 모든 운영 체제에서 실행할 수 있습니다. OrientDB에는 1.7 이상의 Java 버전이 필요합니다.
다음 단계를 사용하여 OrientDB를 시스템에 다운로드하고 설치하십시오.
1 단계-OrientDB 바이너리 설정 파일 다운로드
OrientDB는 시스템에 데이터베이스를 설치하기위한 내장 설치 파일과 함께 제공됩니다. 다른 운영 체제에 대해 미리 컴파일 된 다른 바이너리 패키지 (타르 또는 압축 된 패키지)를 제공합니다. OrientDB 다운로드 링크 에서 OrientDB 파일을 다운로드 할 수 있습니다 .
다음 스크린 샷은 OrientDB의 다운로드 페이지를 보여줍니다. 적합한 운영 체제 아이콘을 클릭하여 압축 또는 타르 된 파일을 다운로드 할 수 있습니다.
다운로드 할 때 바이너리 패키지를 Downloads 폴더.
2 단계-OrientDB 추출 및 설치
다음은 다른 운영 체제에 대해 OrientDB를 추출하고 설치하는 절차입니다.
Linux에서
다운로드 후 orientdb-community-2.1.9.tar.gz 당신의 파일 Downloads폴더. 다음 명령을 사용하여 tarred 파일을 추출 할 수 있습니다.
$ tar –zxvf orientdb-community-2.1.9.tar.gz다음 명령을 사용하여 모든 OrientDB 라이브러리 파일을 이동할 수 있습니다. orientdbcommunity-2.1.9 to /opt/orientdb/예배 규칙서. 여기서는 슈퍼 사용자 명령 (sudo)을 사용하고 있으므로 다음 명령을 실행하려면 슈퍼 사용자 암호를 제공해야합니다.
$ sudo mv orientdb-community-2.1.9 /opt/orientdb다음 명령을 사용하여 등록 할 수 있습니다. orientdb 명령 및 Orient 서버.
$ export ORIENTDB_HoME = /opt/orientdb $ export PATH = $PATH:$ORIENTDB_HOME/binWindows에서
다운로드 후 orientdb-community-2.1.9.zip 당신의 파일 Downloads폴더. zip 추출기를 사용하여 zip 파일을 추출하십시오.
압축을 푼 폴더를 C:\ 예배 규칙서.
다음 주어진 값을 사용하여 두 개의 환경 변수 ORIENTDB_HOME 및 PATH 변수를 만듭니다.
ORIENT_HOME = C:\orientdb-community-2.1.9
PATH = C:\orientdb-community-2.1.9\bin3 단계-OrientDB 서버를 서비스로 설정하기
위의 단계를 따르면 OrientDB의 데스크톱 버전을 사용할 수 있습니다. 다음 단계를 사용하여 OrientDB 데이터베이스 서버를 서비스로 시작할 수 있습니다. 운영 체제에 따라 절차가 다릅니다.
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다음 명령을 사용하여 OrientDB 설치 디렉터리에서 console.sh 파일을 복사합니다. $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 stopWindows에서
OrientDB는 서버 애플리케이션이므로 Java 가상 머신 프로세스를 종료하기 전에 몇 가지 작업을 수행해야합니다. OrientDB 서버를 수동으로 종료하려면 다음을 실행해야합니다.shutdown.bat파일. 그러나 위의 스크립트를 실행하지 않고 시스템이 갑자기 종료되면 서버 인스턴스가 올바르게 중지되지 않습니다. 지정된 신호 세트로 운영 체제에 의해 제어되는 프로그램이 호출됩니다.services Windows에서.
우리는 사용해야합니다 Apache Common Daemon이를 통해 Windows 사용자는 Java 애플리케이션을 Windows 서비스로 래핑 할 수 있습니다. 다음은 Apache 공통 데몬을 다운로드하고 등록하는 절차입니다.
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 서비스 디렉토리에 붙여 넣으십시오.
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)
예를 들어 C : \ orientdb-community-2.1.9의 OrientDB 설치 위치
서비스는 OrientDBGraph.exe 파일 (Original 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 데이터베이스 서버 설치를 확인합니다.
- 서버를 실행하십시오.
- 콘솔을 실행하십시오.
- 스튜디오를 운영하십시오.
이것은 운영 체제에 따라 고유합니다.
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/) 브라우저에서. 다음 스크린 샷이 표시됩니다.
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의 주요 기능은 다중 모델 객체를 지원하는 것입니다. 즉, Document, Graph, Key / Value 및 Real Object와 같은 다양한 모델을 지원합니다. 이 네 가지 모델을 모두 지원하는 별도의 API가 포함되어 있습니다.
문서 모델
용어 문서 모델은 NoSQL 데이터베이스에 속합니다. 데이터가 문서에 저장되고 문서 그룹이 다음과 같이 호출됨을 의미합니다.Collection. 기술적으로 문서는 키 / 값 쌍 집합을 의미하거나 필드 또는 속성이라고도합니다.
OrientDB는 문서 저장, 그룹화 및 분석을 위해 클래스, 클러스터 및 링크와 같은 개념을 사용합니다.
다음 표는 관계형 모델, 문서 모델 및 OrientDB 문서 모델 간의 비교를 보여줍니다.
| 관계형 모델 | 문서 모델 | OrientDB 문서 모델 |
|---|---|---|
| 표 | 수집 | 클래스 또는 클러스터 |
| 열 | 문서 | 문서 |
| 기둥 | 키 / 값 쌍 | 문서 필드 |
| 관계 | 사용할 수 없습니다 | 링크 |
그래프 모델
그래프 데이터 구조는 에지 (Arcs)로 상호 연결된 정점 (노드) 형태로 데이터를 저장할 수있는 데이터 모델입니다. OrientDB 그래프 데이터베이스의 아이디어는 속성 그래프에서 나왔습니다. 꼭지점과 가장자리는 그래프 모델의 주요 아티팩트입니다. 여기에는 속성이 포함되어있어 문서와 유사하게 나타날 수 있습니다.
다음 표는 그래프 모델, 관계형 데이터 모델 및 OrientDB 그래프 모델 간의 비교를 보여줍니다.
| 관계형 모델 | 그래프 모델 | OrientDB 그래프 모델 |
|---|---|---|
| 표 | 정점 및 가장자리 클래스 | "V"(정점 용) 및 "E"(가장자리 용)를 확장하는 클래스 |
| 열 | 꼭지점 | 꼭지점 |
| 기둥 | 정점 및 가장자리 속성 | 정점 및 가장자리 속성 |
| 관계 | 가장자리 | 가장자리 |
키 / 값 모델
키 / 값 모델은 값이 단순하고 복잡한 유형이 될 수있는 키 / 값 쌍의 형태로 데이터를 저장할 수 있음을 의미합니다. 문서 및 그래프 요소를 값으로 지원할 수 있습니다.
다음 표는 관계형 모델, 키 / 값 모델 및 OrientDB 키 / 값 모델 간의 비교를 보여줍니다.
| 관계형 모델 | 키 / 값 모델 | OrientDB 키 / 값 모델 |
|---|---|---|
| 표 | 버킷 | 클래스 또는 클러스터 |
| 열 | 키 / 값 쌍 | 문서 |
| 기둥 | 사용할 수 없습니다 | 문서 필드 또는 정점 / 가장자리 속성 |
| 관계 | 사용할 수 없습니다 | 링크 |
개체 모델
이 모델은 객체 지향 프로그래밍으로 상속되었으며 Inheritance 유형 간 (하위 유형은 수퍼 유형을 확장 함), Polymorphism 기본 클래스를 참조하고 Direct binding 프로그래밍 언어에서 사용되는 객체.
다음 표는 관계형 모델, 개체 모델 및 OrientDB 개체 모델 간의 비교를 보여줍니다.
| 관계형 모델 | 개체 모델 | OrientDB 개체 모델 |
|---|---|---|
| 표 | 수업 | 클래스 또는 클러스터 |
| 열 | 목적 | 문서 또는 정점 |
| 기둥 | 개체 속성 | 문서 필드 또는 정점 / 가장자리 속성 |
| 관계 | 바늘 | 링크 |
자세히 진행하기 전에 OrientDB와 관련된 기본 용어를 아는 것이 좋습니다. 다음은 몇 가지 중요한 용어입니다.
기록
데이터베이스에서로드하고 저장할 수있는 가장 작은 단위입니다. 기록은 4 가지 유형으로 저장할 수 있습니다.
- Document
- 기록 바이트
- Vertex
- Edge
레코드 ID
OrientDB가 레코드를 생성 할 때 데이터베이스 서버는 RecordID (RID)라고하는 단위 식별자를 레코드에 자동으로 할당합니다. RID는 # <cluster> : <position>과 같습니다. <cluster>는 클러스터 식별 번호를 의미하고 <position>은 클러스터에서 레코드의 절대 위치를 의미합니다.
서류
문서는 OrientDB에서 사용할 수있는 가장 유연한 레코드 유형입니다. 문서는 소프트 유형이 지정되고 제약 조건이 정의 된 스키마 클래스에 의해 정의되지만 스키마없이 문서를 삽입 할 수도 있습니다. 즉, 스키마없는 모드도 지원합니다.
JSON 형식으로 내보내기 및 가져 오기를 통해 문서를 쉽게 처리 할 수 있습니다. 예를 들어 다음 JSON 샘플 문서를 살펴보십시오. 문서 세부 사항을 정의합니다.
{
"id" : "1201",
"name" : "Jay",
"job" : "Developer",
"creations" : [
{
"name" : "Amiga",
"company" : "Commodore Inc."
},
{
"name" : "Amiga 500",
"company" : "Commodore Inc."
}
]
}RecordBytes
Record Type은 RDBMS의 BLOB 유형과 동일합니다. OrientDB는 바이너리 데이터와 함께 문서 레코드 유형을로드하고 저장할 수 있습니다.
꼭지점
OrientDB 데이터베이스는 문서 데이터베이스 일뿐만 아니라 그래프 데이터베이스이기도합니다. Vertex 및 Edge와 같은 새로운 개념은 데이터를 그래프 형태로 저장하는 데 사용됩니다. 그래프 데이터베이스에서 가장 기본적인 데이터 단위는 노드이며 OrientDB에서는 정점이라고합니다. Vertex는 데이터베이스에 대한 정보를 저장합니다.
가장자리
한 정점을 다른 정점에 연결하는 Edge라는 별도의 레코드 유형이 있습니다. 가장자리는 양방향이며 두 개의 정점 만 연결할 수 있습니다. OrientDB에는 두 가지 유형의 엣지가 있습니다. 하나는 일반이고 다른 하나는 경량입니다.
수업
클래스는 데이터 모델의 한 유형이며 객체 지향 프로그래밍 패러다임에서 가져온 개념입니다. 기존 문서 데이터베이스 모델을 기반으로 데이터는 컬렉션 형태로 저장되고 관계형 데이터베이스 모델에서는 데이터가 테이블에 저장됩니다. OrientDB는 OPPS 패러다임과 함께 Document API를 따릅니다. 개념으로 OrientDB의 클래스는 관계형 데이터베이스의 테이블과 가장 가까운 관계를 갖지만 (테이블과 달리) 클래스는 스키마가 없거나 스키마가 가득하거나 혼합 될 수 있습니다. 클래스는 다른 클래스에서 상속하여 클래스 트리를 만들 수 있습니다. 각 클래스에는 자체 클러스터가 있습니다 (아무것도 정의되지 않은 경우 기본적으로 생성됨).
클러스터
클러스터는 레코드, 문서 또는 정점을 저장하는 데 사용되는 중요한 개념입니다. 간단히 말해서 클러스터는 레코드 그룹이 저장되는 장소입니다. 기본적으로 OrientDB는 클래스 당 하나의 클러스터를 생성합니다. 클래스의 모든 레코드는 클래스와 이름이 같은 동일한 클러스터에 저장됩니다. 데이터베이스에 최대 32,767 (2 ^ 15-1) 클러스터를 만들 수 있습니다.
CREATE 클래스는 특정 이름으로 클러스터를 만드는 데 사용되는 명령입니다. 클러스터가 생성되면 데이터 모델 생성 중에 이름을 지정하여 클러스터를 사용하여 레코드를 저장할 수 있습니다.
관계
OrientDB는 참조 및 포함의 두 가지 관계를 지원합니다. Referenced relationships 관계의 대상 개체에 대한 직접 링크를 저장함을 의미합니다. Embedded relationships관계를 포함하는 레코드 내에 관계를 저장함을 의미합니다. 이 관계는 참조 관계보다 강합니다.
데이터 베이스
데이터베이스는 실제 스토리지에 액세스하기위한 인터페이스입니다. IT는 쿼리, 스키마, 메타 데이터, 인덱스 등과 같은 고급 개념을 이해합니다. OrientDB는 또한 여러 데이터베이스 유형을 제공합니다. 이러한 유형에 대한 자세한 내용은 데이터베이스 유형을 참조하십시오.
OrientDB는 기본적으로 여러 데이터 유형을 지원합니다. 다음은 동일한 전체 표입니다.
| Sr. No. | 유형 | 기술 |
|---|---|---|
| 1 | 부울 | True 또는 False 값만 처리합니다. Java types: java.lang.Boolean Min: 0 Max: 1 |
| 2 | 정수 | 32 비트 부호있는 정수. Java types: java.lang.Interger Min: -2,147,483,648 Max: +2,147,483,647 |
| 삼 | 짧은 | 작은 16 비트 부호있는 정수. Java types: java.lang.short Min: -32,768 Max: 32,767 |
| 4 | 긴 | 부호있는 큰 64 비트 정수. Java types: java.lang.Long Min: -2 63 Max: +2 63 -1 |
| 5 | 흙손 | 십진수. Java types: java.lang.Float : 2-149 Max: (2-2 -23 ) * 2, 127 |
| 6 | 더블 | 정밀도가 높은 10 진수. Java types: Java.lang.Double. Min: 2 -1074 Max: (2-2 -52 ) * 2 1023 |
| 7 | 날짜 시간 | 최대 밀리 초의 정밀도를 가진 모든 날짜. Java types: java.util.Date |
| 8 | 끈 | 문자의 영숫자 시퀀스로 된 모든 문자열입니다. Java types: java.lang.String |
| 9 | 바이너리 | 모든 값을 바이트 배열로 포함 할 수 있습니다. Java types: 바이트 [] Min: 0 Max: 2,147,483,647 |
| 10 | 임베디드 | 기록은 소유자 내부에 포함됩니다. 포함 된 레코드에 RecordId가 없습니다. Java types: 오 레코드 |
| 11 | 포함 된 목록 | 기록은 소유자 내부에 포함됩니다. 포함 된 레코드에는 RecordId가 없으며 소유자 레코드를 탐색해야만 연결할 수 있습니다. Java types: 목록 <개체> Min: 0 Max: 41,000,000 개 항목 |
| 12 | 임베디드 세트 | 기록은 소유자 내부에 포함됩니다. 포함 된 레코드에는 RecordId가 없으며 소유자 레코드를 탐색해야만 연결할 수 있습니다. Java types: set <객체> Min: 0 Max: 41,000,000 개 항목 |
| 13 | 포함 된지도 | 레코드는 항목의 값으로 소유자 내부에 포함되지만 키는 문자열 만 될 수 있습니다. 포함 된 레코드에는 RecordId가 없으며 소유자 레코드를 탐색해야만 연결할 수 있습니다. Java types: Map <문자열, ORecord> Min: 0 Max: 41,000,000 개 항목 |
| 14 | 링크 | 다른 레코드에 연결합니다. 일반적인 일대일 관계입니다. Java Types: ORID, <? ORecord> 확장 Min: 1 Max: 32767 : 2 ^ 63-1 |
| 15 | 링크 목록 | 다른 기록에 대한 링크. RecordId 만 저장되는 일반적인 일대 다 관계입니다. Java types: 목록 <? ORecord 확장> Min: 0 Max: 41,000,000 개 항목 |
| 16 | 링크 세트 | 다른 기록에 대한 링크. 일반적인 일대 다 관계입니다. Java types: 설정 <? ORecord> 확장 Min: 0 Max: 41,000,000 개 항목 |
| 17 | 링크 맵 | 항목 값으로 다른 레코드에 연결하는 반면 키는 문자열 만 가능합니다. 일반적인 일대 다 관계입니다. RecordId 만 저장됩니다. Java types: Map <문자열,? 기록 확장> Min: 0 Max: 41,000,000 개 항목 |
| 18 | 바이트 | 단일 바이트. 작은 8 비트 부호있는 정수를 저장하는 데 유용합니다. Java types: java.lang.Byte Min: -128 Max: +127 |
| 19 | 과도 현상 | 데이터베이스에 저장되지 않은 모든 값. |
| 20 | 데이트 | 연도, 월, 일과 같은 모든 날짜. Java Types: java.util.Date |
| 21 | 커스텀 | Marshall 및 Unmarshall 메서드를 제공하는 사용자 지정 형식을 저장하는 데 사용됩니다. Java types: OSerializableStream Min: 0 Max: x |
| 22 | 소수 | 반올림이없는 10 진수. Java types: java.math.BigDecimal |
| 23 | LinkBag | 특정 RidBag로서의 RecordId 목록. Java types: ORidBag |
| 24 | 어떤 | 유형을 결정하지 않고 혼합 유형의 컬렉션을 지정하는 데 사용되며 null입니다. |
다음 장에서는 OrientDB에서 이러한 데이터 유형을 사용하는 방법에 대해 설명합니다.
OrientDB 콘솔은 OrientDB 데이터베이스 및 서버 인스턴스에 대해 작동하도록 만들어진 Java 애플리케이션입니다. OrientDB가 지원하는 여러 콘솔 모드가 있습니다.
대화 형 모드
이것이 기본 모드입니다. 다음 스크립트를 실행하여 콘솔을 시작하십시오.bin/console.sh (또는 bin/console.batMS Windows 시스템). 실행 권한이 있는지 확인하십시오.
OrientDB console v.1.6.6 www.orientechnologies.com
Type 'help' to display all the commands supported.
orientdb>완료되면 콘솔은 명령을 수락 할 준비가됩니다.
배치 모드
배치 모드에서 명령을 실행하려면 다음을 실행하십시오. bin/console.sh (또는 bin/console.bat MS Windows 시스템에서) 세미콜론 ";"으로 구분 된 모든 명령을 전달하는 스크립트.
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에코 활성화
파이프 라인에서 콘솔 명령을 실행할 때 해당 명령을 표시해야합니다. 처음에 속성으로 설정하여 명령의 "에코"를 활성화합니다. 다음은 OrientDB 콘솔에서 echo 속성을 활성화하는 구문입니다.
orientdb> set echo trueOrientDB 데이터베이스의 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}>데이터베이스는 요구 사항에 따라 수정할 수있는 다양한 속성을 가진 중요한 데이터 모델 중 하나입니다.
다음 명령문은 Alter Database 명령의 기본 구문입니다.
ALTER DATABASE <attribute-name> <attribute-value>어디 <attribute-name> 수정하려는 속성을 정의하고 <attributevalue> 해당 속성에 대해 설정하려는 값을 정의합니다.
다음 표는 데이터베이스 변경에 지원되는 속성 목록을 정의합니다.
| Sr. 아니. | 속성 이름 | 기술 |
|---|---|---|
| 1 | 상태 | 서로 다른 속성 간의 데이터베이스 상태를 정의합니다. |
| 2 | 가져 오기 | 가져 오기 상태를 설정합니다. |
| 삼 | DEFAULTCLUSTERID | ID를 사용하여 기본 클러스터를 설정합니다. 기본적으로 2입니다. |
| 4 | 날짜 형식 | 특정 날짜 형식을 기본값으로 설정합니다. 기본적으로 "yyyy-MM-dd"입니다. |
| 5 | DATETIMEFORMAT | 특정 날짜 시간 형식을 기본값으로 설정합니다. 기본적으로 "yyyy-MM-dd HH : mm : ss"입니다. |
| 6 | 시간대 | 특정 시간대를 설정합니다. 기본적으로 Java Virtual Machine (JVM)의 기본 시간대입니다. |
| 7 | LOCALECOUNTRY | 기본 로케일 국가를 설정합니다. 기본적으로 JVM의 기본 로케일 국가입니다. 예 : "GB". |
| 8 | 현지 언어 | 기본 로케일 언어를 설정합니다. 기본적으로 JVM의 기본 로케일 언어입니다. 예 : "en". |
| 9 | 문자셋 | 문자 집합의 유형을 설정합니다. 기본적으로 JVM의 기본 문자 집합입니다. 예 : "utf8". |
| 10 | 클러스터 선택 | 클러스터 선택에 사용되는 기본 전략을 설정합니다. 이러한 전략은 클래스 생성과 함께 생성됩니다. 지원되는 전략은 기본, 라운드 로빈 및 균형입니다. |
| 11 | 미니멈 클러스터 | 새 클래스가 생성 될 때 자동으로 생성 할 최소 클러스터 수를 설정합니다. 기본적으로 1입니다. |
| 12 | 커스텀 | 사용자 지정 속성을 설정합니다. |
| 13 | 확인 | 전체 데이터베이스에 대한 유효성 검사를 비활성화하거나 활성화합니다. |
예
OrientDB-2.2 버전에서 새로운 SQL 파서가 추가되어 경우에 따라 정규 구문을 허용하지 않습니다. 따라서 경우에 따라 새 SQL 파서 (StrictSQL)를 비활성화해야합니다. 다음 Alter database 명령을 사용하여 StrictSQL 구문 분석기를 비활성화 할 수 있습니다.
orientdb> ALTER DATABASE custom strictSQL = false명령이 성공적으로 실행되면 다음 출력이 표시됩니다.
Database updated successfullyRDBMS와 마찬가지로 OrientDB는 백업 및 복원 작업도 지원합니다. 백업 작업을 실행하는 동안 ZIP 알고리즘을 사용하여 현재 데이터베이스의 모든 파일을 압축 된 zip 형식으로 가져옵니다. 이 기능 (백업)은 자동 백업 서버 플러그인을 활성화하여 자동으로 사용할 수 있습니다.
데이터베이스 백업을 수행하거나 데이터베이스를 내보내는 방법은 동일하지만 백업 사용시기와 내보내기 사용시기를 알아야하는 절차에 따라 다릅니다.
백업을 수행하는 동안 데이터베이스의 일관된 복사본을 만들고 모든 추가 쓰기 작업이 잠기고 백업 프로세스가 완료 될 때까지 대기합니다. 이 작업에서는 읽기 전용 백업 파일을 생성합니다.
백업을 수행하는 동안 동시 읽기 및 쓰기 작업이 필요한 경우 데이터베이스를 백업하는 대신 데이터베이스 내보내기를 선택해야합니다. 내보내기는 데이터베이스를 잠그지 않으며 내보내기 프로세스 중에 동시 쓰기를 허용합니다.
다음은 데이터베이스 백업의 기본 구문입니다.
./backup.sh <dburl> <user> <password> <destination> [<type>]다음은 위 구문의 옵션에 대한 세부 정보입니다.
<dburl> − 데이터베이스가 로컬 또는 원격 위치에있는 데이터베이스 URL.
<user> − 백업을 실행할 사용자 이름을 지정합니다.
<password> − 특정 사용자의 비밀번호를 제공합니다.
<destination> − 백업 zip 파일을 저장할 위치를 나타내는 대상 파일 위치.
<type>− 선택적 백업 유형. 두 가지 옵션 중 하나가 있습니다.
기본값-백업하는 동안 데이터베이스를 잠급니다.
LVM-백그라운드에서 LVM copy-on-write 스냅 샷을 사용합니다.
예
로컬 파일 시스템 / opt / orientdb / databases / demo에있는 데이터베이스 데모를 sample-demo.zip이라는 파일로 백업하고 현재 디렉토리에 있습니다.
다음 명령을 사용하여 데이터베이스 데모를 백업 할 수 있습니다.
$ 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 secondsRDBMS와 마찬가지로 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 명령 줄에서 특정 데이터베이스에 연결하는 방법을 설명합니다. 데이터베이스가 열립니다.
다음 명령문은 Connect 명령의 기본 구문입니다.
CONNECT <database-url> <user> <password>다음은 위 구문의 옵션에 대한 세부 정보입니다.
<database-url>− 데이터베이스의 URL을 정의합니다. URL에는 두 부분이 포함됩니다. 하나는 <mode>이고 두 번째 부분은 <path>입니다.
<mode> − 모드, 즉 로컬 모드 또는 원격 모드를 정의합니다.
<path> − 데이터베이스 경로를 정의합니다.
<user> − 데이터베이스에 연결하려는 사용자를 정의합니다.
<password> − 데이터베이스에 연결하기위한 암호를 정의합니다.
예
이전 장에서 이미 'demo'라는 데이터베이스를 만들었습니다. 이 예에서는 사용자 admin을 사용하여 연결합니다.
다음 명령을 사용하여 데모 데이터베이스에 연결할 수 있습니다.
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 명령 줄에서 특정 데이터베이스 연결을 끊는 방법을 설명합니다. 현재 열려있는 데이터베이스를 닫습니다.
다음 문은 Disconnect 명령의 기본 구문입니다.
DISCONNECTNote −이 명령은 특정 데이터베이스에 연결 한 후에 만 사용할 수 있으며 현재 실행중인 데이터베이스 만 닫습니다.
예
이 예에서는 이전 장에서 만든 'demo'라는 동일한 데이터베이스를 사용합니다. 데모 데이터베이스에서 연결을 끊습니다.
다음 명령을 사용하여 데이터베이스 연결을 끊을 수 있습니다.
orientdb {db = demo}> DISCONNECT연결이 성공적으로 끊어지면 다음과 같은 출력이 표시됩니다.
Disconnecting to database [plocal:/opt/orientdb/databases/demo] with user 'admin'…OK
orientdb>이 장에서는 OrientDB 명령 줄에서 특정 데이터베이스의 정보를 얻는 방법에 대해 설명합니다.
다음 명령문은 Info 명령의 기본 구문입니다.
infoNote −이 명령은 특정 데이터베이스에 연결 한 후에 만 사용할 수 있으며 현재 실행중인 데이터베이스의 정보 만 검색합니다.
예
이 예에서는 이전 장에서 만든 '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 명령 줄에서 인스턴스의 모든 데이터베이스 목록을 가져 오는 방법을 설명합니다.
다음 명령문은 info 명령의 기본 구문입니다.
LIST DATABASESNote −이 명령어는 로컬 또는 원격 서버에 연결 한 후에 만 사용할 수 있습니다.
예
데이터베이스 목록을 검색하기 전에 원격 서버를 통해 로컬 호스트 서버에 연결해야합니다. localhost 인스턴스에 연결하기위한 사용자 이름과 비밀번호는 각각 게스트와 게스트이며orintdb/config/orientdb-server-config.xml 파일.
다음 명령을 사용하여 localhost 데이터베이스 서버 인스턴스에 연결할 수 있습니다.
orientdb> connect remote:localhost 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 명령의 기본 구문입니다.
FREEZE DATABASENote −이 명령은 원격 또는 로컬 데이터베이스에서 특정 데이터베이스에 연결 한 후에 만 사용할 수 있습니다.
예
이 예에서는 이전 장에서 만든 'demo'라는 동일한 데이터베이스를 사용합니다. CLI에서이 데이터베이스를 고정합니다.
다음 명령을 사용하여 데이터베이스를 고정 할 수 있습니다.
Orientdb {db = demo}> FREEZE DATABASE성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Database 'demo' was frozen successfully이 장에서는 OrientDB 명령 줄을 통해 고정 상태에서 데이터베이스를 해제하는 방법을 배울 수 있습니다.
다음 명령문은 데이터베이스 릴리스 명령의 기본 구문입니다.
RELEASE DATABASENote −이 명령어는 동결 상태 인 특정 데이터베이스에 접속 한 후에 만 사용할 수 있습니다.
예
이 예에서는 이전 장에서 만든 'demo'라는 동일한 데이터베이스를 사용합니다. 이전 장에서 동결 된 데이터베이스를 해제합니다.
다음 명령을 사용하여 데이터베이스를 해제 할 수 있습니다.
Orientdb {db = demo}> RELEASE DATABASE성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Database 'demo' was release successfully이 장에서는 OrientDB 명령 줄을 통해 특정 데이터베이스의 구성을 표시하는 방법을 배울 수 있습니다. 이 명령은 로컬 및 원격 데이터베이스 모두에 적용됩니다.
구성 정보에는 활성화 여부에 관계없이 기본 캐시, 해당 캐시의 크기,로드 요소 값, 맵의 최대 메모리, 노드 페이지 크기, 풀 최소 및 최대 크기 등이 포함됩니다.
다음 명령문은 config database 명령의 기본 구문입니다.
CONFIGNote −이 명령어는 특정 데이터베이스에 접속 한 후에 만 사용할 수 있습니다.
예
이 예에서는 이전 장에서 만든 '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 −이 명령어는 특정 데이터베이스에 접속 한 후에 만 사용할 수 있습니다.
예
이 예에서는 이전 장에서 만든 'demo'라는 동일한 데이터베이스를 사용합니다. 'tx.autoRetry'변수 값을 5로 수정합니다.
다음 명령을 사용하여 데모 데이터베이스의 구성을 설정할 수 있습니다.
orientdb {db = demo}> CONFIG SET tx.autoRetry 5성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Local configuration value changed correctly구성 가져 오기
다음을 사용하여 구성 변수 값을 표시 할 수 있습니다. CONFIG GET 명령.
다음 명령문은 config get 명령의 기본 구문입니다.
CONFIG GET <config-variable>Note −이 명령어는 특정 데이터베이스에 접속 한 후에 만 사용할 수 있습니다.
예
이 예에서는 이전 장에서 만든 'demo'라는 동일한 데이터베이스를 사용합니다. 'tx.autoRetry'변수 값 검색을 시도합니다.
다음 명령을 사용하여 데모 데이터베이스의 구성을 표시 할 수 있습니다.
orientdb {db = demo}> CONFIG GET tx.autoRetry성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Local configuration: tx.autoRetry = 5RDBMS와 마찬가지로 OrientDB는 데이터베이스 내보내기 및 가져 오기와 같은 기능도 제공합니다. OrientDB는 JSON 형식을 사용하여 데이터를 내 보냅니다. 기본적으로 내보내기 명령은 GZIP 알고리즘을 사용하여 파일을 압축합니다.
데이터베이스를 내보내는 동안 데이터베이스를 잠그지 않습니다. 즉, 동시에 읽기 및 쓰기 작업을 수행 할 수 있습니다. 또한 동시 읽기 및 쓰기 작업으로 인해 해당 데이터의 정확한 복사본을 만들 수 있음을 의미합니다.
이 장에서는 OrientDB 명령 줄에서 데이터베이스를 내보내는 방법을 배울 수 있습니다.
다음 명령문은 데이터베이스 내보내기 명령의 기본 구문입니다.
EXPORT DATABASE <output file>Note −이 명령어는 특정 데이터베이스에 접속 한 후에 만 사용할 수 있습니다.
예
이 예에서는 이전 장에서 만든 '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데이터베이스를 가져올 때마다 내보내기 명령으로 생성 된 JSON 형식의 내보내기 파일을 사용해야합니다.
이 장에서는 OrientDB 명령 줄에서 데이터베이스를 가져 오는 방법을 배울 수 있습니다.
다음 명령문은 데이터베이스 가져 오기 명령의 기본 구문입니다.
IMPORT DATABASE <input file>Note −이 명령어는 특정 데이터베이스에 접속 한 후에 만 사용할 수 있습니다.
예
이 예에서는 이전 장에서 만든 'demo'라는 동일한 데이터베이스를 사용합니다. 다음 명령을 사용하여 데이터베이스를 'export-demo.gz'라는 파일로 가져올 수 있습니다.
orientdb {db = demo}> IMPORT DATABASE ./export-demo.export.gz성공적으로 실행되면 성공 알림과 함께 다음과 같은 출력이 표시됩니다.
Database import completed in 11612msRDBMS와 마찬가지로 OrientDB는 Commit 및 Rollback과 같은 트랜잭션 개념도 제공합니다. Commit 모든 변경 사항을 데이터베이스에 저장하여 트랜잭션을 닫는 것을 말합니다. Rollback 트랜잭션을 연 지점으로 데이터베이스 상태를 복구하는 것을 의미합니다.
다음 명령문은 Commit database 명령의 기본 구문입니다.
COMMITNote −이 명령은 특정 데이터베이스에 연결 한 후 트랜잭션을 시작한 후에 만 사용할 수 있습니다.
예
이 예에서는 이전 장에서 만든 '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 명령 줄 인터페이스를 통해 커밋되지 않은 트랜잭션을 롤백하는 방법을 배웁니다.
다음 명령문은 데이터베이스 롤백 명령의 기본 구문입니다.
ROLLBACKNote −이 명령은 특정 데이터베이스에 연결 한 후 트랜잭션을 시작한 후에 만 사용할 수 있습니다.
예
이 예에서는 이전 장에서 만든 '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직원 테이블에서 동일한 레코드를 검색하려면 선택 쿼리를 다시 확인하십시오.
orientdb> SELECT FROM employee WHERE name LIKE '%.P'롤백이 성공적으로 실행되면 출력에서 0 개의 레코드를 찾을 수 있습니다.
0 item(s) found. Query executed in 0.037 sec(s).기술 용어에 따라 Optimization"가장 빠른 시간에 더 나은 성능을 달성한다"는 의미입니다. 데이터베이스와 관련하여 최적화에는 데이터를 검색하는 속도와 효율성을 극대화하는 것이 포함됩니다.
OrientDB는 데이터 엔티티 간의 직접적인 관계를 의미하는 경량 에지를 지원합니다. 간단히 말해서 필드 대 필드 관계입니다. OrientDB는 데이터베이스를 최적화하는 다양한 방법을 제공합니다. 일반 모서리를 경량 모서리로 변환 할 수 있습니다.
다음 명령문은 Optimize database 명령의 기본 구문입니다.
OPTMIZE DATABASE [-lwedges] [-noverbose]어디 lwedges 일반 모서리를 경량 모서리로 변환하고 noverbose 출력을 비활성화합니다.
예
이 예에서는 이전 장에서 만든 'demo'라는 동일한 데이터베이스를 사용합니다. 다음 optimize database 명령을 사용할 수 있습니다.
OPTIMIZE DATABASE -lwedges성공적으로 실행되면 완료 메시지와 함께 성공적인 알림을 받게됩니다.
Database Optimization completed in 35msRDBMS와 유사하게 OrientDB는 데이터베이스를 삭제하는 기능을 제공합니다. Drop database 데이터베이스를 완전히 제거하는 것을 말합니다.
다음 명령문은 Drop database 명령의 기본 구문입니다.
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 successfullyOR
다음과 같이 다른 명령을 사용하여 데이터베이스를 삭제할 수 있습니다.
orientdb> DROP DATABASE PLOCAL:/opt/orientdb/databases/demo admin admin이 명령이 성공적으로 실행되면 다음 출력이 표시됩니다.
Database 'demo' deleted successfullyOrientDB는 문서와 그래프 지향 데이터를 저장할 수있는 NoSQL 데이터베이스입니다. NoSQL 데이터베이스에는 테이블이 없으므로 어떻게 데이터를 레코드로 삽입 할 수 있습니까? 여기에서 클래스, 속성, 꼭지점 및 에지의 형태로 테이블 데이터를 볼 수 있습니다. 클래스는 테이블과 같고 속성은 테이블의 파일과 같습니다.
우리는 schemaOrientDB에서. 속성 데이터를 클래스에 삽입 할 수 있습니다. 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 − 레코드 또는 결과 세트를 삽입하려는 위치.
예
다음 필드와 유형이있는 고객 테이블을 고려해 보겠습니다.
| Sr. 아니. | 분야 명 | 유형 |
|---|---|---|
| 1 | 신분증 | 정수 |
| 2 | 이름 | 끈 |
| 삼 | 나이 | 정수 |
다음 명령을 실행하여 스키마 (테이블)를 생성 할 수 있습니다.
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, 이름 및 연령 필드가있는 테이블 이름 Customer가 표시됩니다. Customer 테이블에 대해 select 쿼리를 실행하여 테이블을 확인할 수 있습니다.
OrientDB는 레코드를 삽입하는 다양한 방법을 제공합니다. 샘플 레코드가 포함 된 다음 고객 테이블을 고려하십시오.
| Sr. 아니. | 이름 | 나이 |
|---|---|---|
| 1 | Satish | 25 |
| 2 | 크리슈나 | 26 |
| 삼 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | 라자 | 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
----+-----+--------+----+-------+----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 − 캐시 사용 여부를 정의합니다.
예
이전 장에서 만든 다음 고객 테이블을 살펴 보겠습니다.
| Sr. 아니. | 이름 | 나이 |
|---|---|---|
| 1 | Satish | 25 |
| 2 | 크리슈나 | 26 |
| 삼 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | 라자 | 29 |
고객 테이블에서 데이터 레코드를 검색하려면 다른 선택 쿼리를 시도하십시오.
Method 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
----+-----+--------+----+-------+----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 − 고객 테이블에서 이름이 대문자 인 ID, 이름 레코드를 선택합니다.
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 − 고객 테이블에서 연령이 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 − 필드에 '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 − 연령별로 내림차순으로 정렬 된 고객 테이블에서 모든 레코드를 선택합니다.
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
----+-----+--------+----+-------+----Load Record스키마에서 특정 레코드를로드하는 데 사용됩니다. 레코드로드는 레코드 ID의 도움으로 레코드를로드합니다. 다음과 같이 표현됩니다.@rid 결과 집합의 기호.
다음 명령문은 LOAD Record 명령의 기본 구문입니다.
LOAD RECORD <record-id>어디 <record-id> 로드하려는 레코드의 레코드 ID를 정의합니다.
특정 레코드의 레코드 ID를 모르는 경우 테이블에 대해 쿼리를 실행할 수 있습니다. 결과 세트에서 각 레코드의 레코드 ID (@rid)를 찾을 수 있습니다.
예
이전 장에서 사용한 것과 동일한 고객 테이블을 고려해 보겠습니다.
| Sr. 아니. | 이름 | 나이 |
|---|---|---|
| 1 | Satish | 25 |
| 2 | 크리슈나 | 26 |
| 삼 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | 라자 | 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 |
+---------------------------------------------------------------------------+Reload Record또한 Load Record 명령과 유사하게 작동하며 스키마에서 특정 레코드를로드하는데도 사용됩니다. 레코드로드는 레코드 ID의 도움으로 레코드를로드합니다. 다음과 같이 표현됩니다.@rid결과 세트의 기호. 주요 차이점은 Reload record는 외부 동시 트랜잭션을 적용하여 레코드를 변경할 때 유용한 캐시를 무시한다는 것입니다. 최신 업데이트를 제공합니다.
다음 명령문은 RELOAD Record 명령의 기본 구문입니다.
RELOAD RECORD <record-id>어디 <record-id> 다시로드하려는 레코드의 레코드 ID를 정의합니다.
특정 레코드의 레코드 ID를 모르는 경우 테이블에 대해 쿼리를 실행할 수 있습니다. 결과 세트에서 각 레코드의 레코드 ID (@rid)를 찾을 수 있습니다.
예
이전 장에서 사용한 것과 동일한 고객 테이블을 고려해 보겠습니다.
| Sr. 아니. | 이름 | 나이 |
|---|---|---|
| 1 | Satish | 25 |
| 2 | 크리슈나 | 26 |
| 삼 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | 라자 | 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 |
+---------------------------------------------------------------------------+Export Record로드 된 레코드를 요청되고 지원되는 형식으로 내보내는 데 사용되는 명령입니다. 잘못된 구문을 실행하는 경우 지원되는 형식 목록이 제공됩니다. OrientDB는 문서 데이터베이스 제품군이므로 JSON이 기본 지원 형식입니다.
다음 명령문은 레코드 내보내기 명령의 기본 구문입니다.
EXPORT RECORD <format>어디 <Format> 레코드를 가져올 형식을 정의합니다.
Note − 내보내기 명령은 레코드 ID를 기준으로로드 된 레코드를 내 보냅니다.
예
이전 장에서 사용한 것과 동일한 고객 테이블을 고려해 보겠습니다.
| Sr. 아니. | 이름 | 나이 |
|---|---|---|
| 1 | Satish | 25 |
| 2 | 크리슈나 | 26 |
| 삼 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | 라자 | 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
}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 − 시간이 초과되기 전에 업데이트 실행을 허용 할 시간을 정의합니다.
예
이전 장에서 사용한 것과 동일한 고객 테이블을 고려해 보겠습니다.
| Sr. 아니. | 이름 | 나이 |
|---|---|---|
| 1 | Satish | 25 |
| 2 | 크리슈나 | 26 |
| 삼 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | 라자 | 29 |
고객 'Raja'의 나이를 업데이트하려면 다음 쿼리를 시도하십시오.
Orientdb {db = demo}> UPDATE Customer SET age = 28 WHERE name = 'Raja'위 쿼리가 성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Updated 1 record(s) in 0.008000 sec(s).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 |28
----+-----+--------+----+-------+----Truncate Record 명령은 특정 레코드의 값을 삭제하는 데 사용됩니다.
다음 명령문은 Truncate 명령의 기본 구문입니다.
TRUNCATE RECORD <rid>*어디 <rid>*는자를 레코드 ID를 나타냅니다. 쉼표로 구분 된 여러 Rid를 사용하여 여러 레코드를자를 수 있습니다. 잘린 레코드 수를 반환합니다.
예
이전 장에서 사용한 것과 동일한 고객 테이블을 고려해 보겠습니다.
| Sr. 아니. | 이름 | 나이 |
|---|---|---|
| 1 | Satish | 25 |
| 2 | 크리슈나 | 26 |
| 삼 | Kiran | 29 |
| 4 | Javeed | 21 |
| 5 | 라자 | 28 |
레코드 ID # 11 : 4를 가진 레코드를 자르려면 다음 쿼리를 시도하십시오.
Orientdb {db = demo}> TRUNCATE RECORD #11:4위 쿼리가 성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Truncated 1 record(s) in 0.008000 sec(s).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
----+-----+--------+----+-------+----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를 사용하여 Vertices 또는 Edges를 제거하지 마십시오.
예
고객 테이블을 고려해 보겠습니다.
| Sr. 아니. | 이름 | 나이 |
|---|---|---|
| 1 | Satish | 25 |
| 2 | 크리슈나 | 26 |
| 삼 | 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).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
----+-----+--------+----+-------+----OrientDB는 다중 모델 기능을 지원하고 데이터베이스의 기본 개념에 접근하고 이해하는 다양한 방법을 제공합니다. 그러나 문서 데이터베이스 API의 관점에서 이러한 모델에 쉽게 액세스 할 수 있습니다. RDBMS와 마찬가지로 OrientDB는 레코드를 저장 요소로 사용하지만 문서 유형을 사용합니다. 문서는 키 / 값 쌍의 형태로 저장됩니다. 개념 클래스에 속하는 키 / 값 쌍으로 필드와 속성을 저장합니다.
Class데이터 모델의 한 유형이며 개념은 객체 지향 프로그래밍 패러다임에서 도출되었습니다. 기존 문서 데이터베이스 모델을 기반으로 데이터는 컬렉션의 형태로 저장되고 관계형 데이터베이스 모델 데이터에서는 테이블에 저장됩니다. OrientDB는 OPPS 패러다임과 함께 Document API를 따릅니다. 개념적으로 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− 클래스가 추상임을 정의합니다. 이것은 선택 사항입니다.
예
논의했듯이 클래스는 테이블과 관련된 개념입니다. 따라서 여기에서 테이블 계정을 생성합니다. 그러나 클래스를 생성하는 동안 필드, 즉 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 명령.
다음은 Alter Class Command의 기본 구문입니다.
ALTER CLASS <class> <attribute-name> <attribute-value>다음은 위 구문의 옵션에 대한 세부 정보입니다.
<class> − 클래스 이름을 정의합니다.
<attribute-name> − 변경할 속성을 정의합니다.
<attribute-value> − 속성에 설정하려는 값을 정의합니다.
다음 표는 Alter Class 명령을 지원하는 속성 목록을 정의합니다.
| 속성 | 유형 | 기술 |
|---|---|---|
| 이름 | 끈 | 클래스 이름을 변경합니다. |
| SHORTNAME | 끈 | 클래스의 짧은 이름 (즉, 별칭)을 정의합니다. 짧은 이름 할당을 제거하려면 NULL을 사용하십시오. |
| 슈퍼 클래스 | 끈 | 클래스의 수퍼 클래스를 정의합니다. 새 클래스를 추가하려면 + <class> 구문을 사용하고 제거하려면-<class>를 사용하십시오. |
| 특대 | 십진수 | 특대 요인을 정의합니다. |
| ADDCLUSTER | 끈 | 클래스에 클러스터를 추가합니다. 클러스터가 존재하지 않으면 물리적 클러스터를 생성합니다. 클래스에 클러스터를 추가하면 분산 서버에 레코드를 저장할 때도 유용합니다. |
| REMOVECLUSTER | 끈 | 클래스에서 클러스터를 제거합니다. 클러스터를 삭제하지 않고 클래스에서만 제거합니다. |
| STRICTMODE | - | 엄격 모드를 활성화하거나 비활성화합니다. Strict 모드에서는 스키마 전체 모드로 작업하며 클래스 스키마 정의의 일부인 경우 레코드에 새 속성을 추가 할 수 없습니다. |
| 클러스터 선택 | - | 새 레코드에 사용할 클러스터를 선택할 때 선택 전략을 정의합니다. |
| 커스텀 | - | 사용자 지정 속성을 정의합니다. 속성 이름과 값은 이름과 값 사이에 공백없이 <propertyname> = <value> 구문을 따라야합니다. |
| 요약 | 부울 | 클래스를 추상 클래스 또는 그 반대로 변환합니다. |
예
기존 클래스의 속성을 업데이트하거나 수정하는 몇 가지 예를 시도해 보겠습니다.
다음 쿼리는 기존 클래스 'Employee'에 대한 수퍼 클래스 'Person'을 정의하는 데 사용됩니다.
orientdb> ALTER CLASS Employee SUPERCLASS Person위 쿼리가 성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Class altered successfully다음 쿼리는 기존 클래스 'Employee'에 대한 수퍼 클래스 'Person'을 추가하는 데 사용됩니다.
orientdb> ALTER CLASS Employee SUPERCLASS +Person위 쿼리가 성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Class altered successfullyTruncate class클래스의 일부로 정의 된 클러스터의 모든 레코드를 삭제합니다. OrientDB에서 모든 클래스에는 동일한 이름의 연결된 클러스터가 있습니다. 클래스 계층 구조에서도 모든 레코드를 제거하려면 POLYMORPHIC 키워드를 사용해야합니다.
다음 문장은 Truncate Class Command의 기본 구문입니다.
TRUNCATE CLASS <class> [ POLYMORPHIC ] [ UNSAFE ]다음은 위 구문의 옵션에 대한 세부 정보입니다.
<class> − 자르려는 클래스를 정의합니다.
POLYMORPHIC − 명령이 계층 구조도 잘리는 지 여부를 정의합니다.
UNSAFE − 명령을 정의하여 꼭지점 또는 모서리 클래스에서 자르기를 강제합니다.
예
클래스를 자르는 다음 쿼리 Profile.
orientdb> TRUNCATE CLASS Profile위 쿼리가 성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Class truncated successfully그만큼 Drop Class명령은 스키마에서 클래스를 제거합니다. 주의를 기울이고 일관된 스키마를 유지하는 것이 중요합니다. 예를 들어, 다른 사람의 수퍼 클래스 인 클래스를 제거하지 마십시오. 연결된 클러스터는 삭제되지 않습니다.
다음은 Drop Class 명령의 기본 구문입니다.
DROP CLASS <class>클래스 이름이있는 클래스를 삭제하십시오.
예
Employee 클래스를 삭제하려면 다음 쿼리를 시도하십시오.
Orientdb> DROP CLASS Employee위 쿼리가 성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Class dropped successfullyCluster레코드, 문서 또는 정점을 저장하는 데 사용되는 OrientDB의 중요한 개념입니다. 간단히 말해서 클러스터는 레코드 그룹이 저장되는 장소입니다. 기본적으로 OrientDB는 클래스 당 하나의 클러스터를 생성합니다. 클래스의 모든 레코드는 클래스와 이름이 같은 동일한 클러스터에 저장됩니다. 데이터베이스에 최대 32,767 (2 ^ 15-1) 클러스터를 만들 수 있습니다.
CREATE 클래스는 특정 이름으로 클러스터를 만드는 데 사용되는 명령입니다. 클러스터가 생성되면 데이터 모델을 생성하는 동안 이름을 지정하여 클러스터를 사용하여 레코드를 저장할 수 있습니다. 새 클러스터를 클래스에 추가하려면 Alter Class 명령과 ADDCLUSTER 명령을 사용하십시오.
다음은 클러스터 생성 명령의 기본 구문입니다.
CREATE CLUSTER <cluster> [ID <cluster-id>]어디 <cluster> 만들려는 클러스터의 이름을 정의하고 <cluster-id> 클러스터에 사용할 숫자 ID를 정의합니다.
다음 표는 클러스터 선택 전략 목록을 제공합니다.
| Sr. 아니. | 전략 및 설명 |
|---|---|
| 1 | Default 클래스 속성 default ClusterId를 사용하여 클러스터를 선택합니다. |
| 2 | Round-robin 다음 클러스터를 순환 순서로 선택합니다. 완료되면 다시 시작됩니다. |
| 삼 | Balanced 가장 작은 클러스터를 선택합니다. 클래스가 모든 기본 클러스터의 크기가 균형을 이루도록합니다. 기존 클래스에 새 클러스터를 추가 할 때 먼저 새 클러스터를 채 웁니다. |
예
sales라는 클러스터를 만드는 예를 들어 보겠습니다.
orientdb> CREATE CLUSTER sales위 쿼리가 성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Cluster created correctly with id #12Alter Cluster명령은 기존 클러스터의 속성을 업데이트하는 것입니다. 이 장에서는 클러스터의 속성을 추가하거나 수정하는 방법을 배울 수 있습니다.
다음은 Alter Cluster 명령의 기본 구문입니다.
ALTER CLUSTER <cluster> <attribute-name> <attribute-value>다음은 위 구문의 옵션에 대한 세부 정보입니다.
<cluster> − 클러스터 이름을 정의합니다.
<attribute-name> − 변경할 속성을 정의합니다.
<attribute-value> −이 속성에 대해 설정하려는 값을 정의합니다.
다음 표 형식은 Alter cluster 명령과 함께 사용할 수있는 지원되는 속성 목록을 제공합니다.
| 이름 | 유형 | 기술 |
|---|---|---|
| 이름 | 끈 | 클러스터 이름을 변경합니다. |
| 상태 | 끈 | 클러스터 상태를 변경합니다. 허용되는 값은 ONLINE 및 OFFLINE입니다. 기본적으로 클러스터는 온라인 상태입니다. |
| 압축 | 끈 | 사용할 압축 유형을 정의합니다. 허용되는 값은 NOTHING, SNAPPY, GZIP 및 OCompressionFactory 클래스에 등록 된 기타 압축 유형입니다. |
| USE_WAL | 부울 | OrientDB가 클러스터에 대해 작동 할 때 Journal 사용 여부를 정의합니다. |
| RECORD_GROW_FACTO R | 정수 | 레코드 생성시 더 많은 공간을 절약하기 위해 성장 인자를 정의합니다. 추가 정보로 레코드를 업데이트 할 때 유용 할 수 있습니다. |
| RECORD_OVERFLOW_GR OW_FACTOR | 정수 | 업데이트시 성장 요인을 정의합니다. 크기 제한에 도달하면 is는이 설정을 사용하여 더 많은 공간을 확보합니다 (인수> 1). |
| 갈등 전략 | 끈 | OrientDB MVCC가 이전 레코드에 대해 실행하는 업데이트 또는 삭제 작업을 찾은 경우 충돌을 처리하는 데 사용하는 전략을 정의합니다. |
다음 표는 충돌 전략 목록을 제공합니다.
| Sr. 아니. | 전략 및 설명 |
|---|---|
| 1 | Version 버전이 다른 경우 예외가 발생합니다. 이것이 기본 설정입니다. |
| 2 | Content 버전이 다른 경우 콘텐츠의 변경 사항을 확인하고 그렇지 않으면 예외 발생을 방지하기 위해 가장 높은 버전을 사용합니다. |
| 삼 | Automerge 변경 사항을 병합합니다. |
예
클러스터 변경 명령을 배우려면 다음 예제 쿼리를 시도하십시오.
다음 명령을 실행하여 클러스터 이름을 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그만큼 Truncate Cluster 명령은 클러스터의 모든 레코드를 삭제합니다.
다음은 Truncate Cluster Command의 기본 구문입니다.
TRUNCATE CLUSTER <cluster-name>어디 <cluster-name> 클러스터의 이름입니다.
예
다음 쿼리를 사용하여 sales라는 클러스터를 자릅니다.
Orientdb {db = demo}> TRUNCATE CLUSTER Profile위 쿼리가 성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Cluster truncated successfully.그만큼 Drop Cluster명령은 클러스터 및 모든 관련 컨텐츠를 제거합니다. 이 작업은 영구적이며 롤백됩니다.
다음은 Drop Cluster 명령의 기본 구문입니다.
DROP CLUSTER <cluster-name>|<cluster-id>어디 <cluster-name> 제거하려는 클러스터의 이름을 정의하고 <cluster-id> 제거하려는 클러스터의 ID를 정의합니다.
예
다음 명령을 사용하여 Sales 클러스터를 제거하십시오.
orientdb> DROP CLUSTER Sales위 쿼리가 성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Cluster dropped successfullyPropertyOrientDB에서 데이터베이스 테이블의 클래스 및 열 필드처럼 작동합니다. 속성 만들기는 특정 클래스에 대한 속성을 만드는 데 사용되는 명령입니다. 명령에 사용한 클래스 이름이 있어야합니다.
다음은 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가 저장할 데이터 유형을 알 수 있도록 속성에 대한 데이터 유형을 제공합니다.
| 부울 | 정수 | 짧은 | 긴 |
| 흙손 | 데이트 | 끈 | 임베디드 |
| 링크 | 바이트 | 바이너리 | 더블 |
이 외에도 컨테이너로 작동하는 몇 가지 다른 속성 유형이 있습니다.
| 내재 목록 | EMBEDDEDSET | EMBEDDEDMAP |
| 링크 목록 | LINKSET | 링크 맵 |
예
다음 예제를 사용하여 Employee 클래스에 String 유형의 속성 이름을 만듭니다.
orientdb> CREATE PROPERTY Employee.name STRING위 쿼리가 성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Property created successfully with id = 1Alter Property특정 클래스의 속성을 수정하거나 업데이트하는 데 사용되는 명령입니다. 속성을 변경하는 것은 테이블의 필드를 수정하는 것을 의미합니다. 이 장에서는 속성을 업데이트하는 방법을 배울 수 있습니다.
다음은 Alter Property Command의 기본 구문입니다.
ALTER PROPERTY <class>.<property> <attribute-name> <attribute-value>다음은 위 구문의 옵션에 대한 세부 정보입니다.
<class> − 속성이 속한 클래스를 정의합니다.
<property> − 업데이트 할 속성을 정의합니다.
<attribute-name> − 업데이트하려는 속성의 속성을 정의합니다.
<attribute-value> − 속성에 설정할 값을 정의합니다.
다음 표는 속성을 변경하기위한 속성 목록을 정의합니다.
| 속성 | 유형 | 기술 |
|---|---|---|
| LINKEDCLASS | 끈 | 연결된 클래스 이름을 정의합니다. 기존 값을 제거하려면 NULL을 사용하십시오. |
| LINKEDTYPE | 끈 | 링크 유형을 정의합니다. 기존 값을 제거하려면 NULL을 사용하십시오. |
| 분 | 정수 | 최소값을 제약 조건으로 정의합니다. 기존 제약 조건을 제거하려면 NULL을 사용하십시오. |
| 필수 | 부울 | 속성에 값이 필요한지 여부를 정의합니다. |
| MAX | 정수 | 최대 값을 제약 조건으로 정의합니다. 기존 제약 조건을 제거하려면 NULL을 사용하십시오. |
| 이름 | 끈 | 속성 이름을 정의합니다. |
| NOTNULL | 부울 | 속성이 NULL 값을 가질 수 있는지 여부를 정의합니다. |
| 정규식 | 끈 | 정규식을 제약 조건으로 정의합니다. 기존 제약 조건을 제거하려면 NULL을 사용하십시오. |
| 유형 | 끈 | 속성 유형을 정의합니다. |
| 함께 합치다 | 끈 | 정의 된 비교 전략 중 하나로 대조를 설정합니다. 기본적으로 대소 문자 구분 (cs)으로 설정됩니다. 대소 문자 구분 (ci)으로 설정할 수도 있습니다. |
| 읽기 전용 | 부울 | 속성 값이 변경 불가능한지 여부를 정의합니다. 즉, 첫 번째 할당 후 변경할 수있는 경우입니다. DEFAULT와 함께 사용하면 생성시 변경할 수없는 값이 있습니다. |
| 커스텀 | 끈 | 사용자 지정 속성을 정의합니다. 사용자 정의 특성의 구문은 stereotype = icon과 같은 <custom-name> = <custom-value>입니다. |
| 기본 | 기본값 또는 기능을 정의합니다. |
Note − NAME 또는 TYPE을 변경하는 경우이 명령은 데이터 양에 따라 업데이트하는 데 약간의 시간이 걸립니다.
예
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 successfully그만큼 Drop property명령은 스키마에서 속성을 제거합니다. 레코드에서 속성 값을 제거하지 않고 스키마 만 변경합니다.
다음은 Drop Property Command의 기본 구문입니다.
DROP PROPERTY <class>.<property> [FORCE]다음은 위 구문의 옵션에 대한 세부 정보입니다.
<class> − 속성이 존재하는 클래스를 정의합니다.
<property> − 제거 할 속성을 정의합니다.
[Force] − 속성에 하나 이상의 인덱스가 정의 된 경우.
예
다음 명령을 사용하여 'Customer'클래스에서 'age'속성을 제거하십시오.
orientdb> DROP PROPERTY Customer.age위의 명령이 성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Property dropped successfullyOrientDB 데이터베이스는 문서 데이터베이스 일뿐만 아니라 그래프 데이터베이스이기도합니다. 데이터를 그래프 형태로 저장하기 위해 Vertex 및 Edge와 같은 새로운 개념이 사용됩니다. 정점에 다형성을 적용합니다. Vertex의 기본 클래스는 V입니다.
이 장에서는 그래프 데이터를 저장하기 위해 정점을 만드는 방법을 배울 수 있습니다.
다음은 Create Vertex Command의 기본 구문입니다.
CREATE VERTEX [<class>] [CLUSTER <cluster>] [SET <field> = <expression>[,]*]다음은 위 구문의 옵션에 대한 세부 정보입니다.
<class> − 정점이 속한 클래스를 정의합니다.
<cluster> − 정점을 저장하는 클러스터를 정의합니다.
<field> − 설정하려는 필드를 정의합니다.
<expression> − 필드에 설정할 익스프레스를 정의합니다.
예
정점을 만드는 방법을 이해하려면 다음 예제를 시도하십시오.
다음 쿼리를 실행하여 '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 명령은 하나 이상의 정점을 현재 위치에서 다른 클래스 또는 클러스터로 이동하는 것입니다. 특정 정점에 이동 명령을 적용하면이 정점에 연결된 모든 가장자리가 업데이트됩니다. 정점을 이동할 클러스터를 지정하는 경우 정점을 대상 클러스터의 서버 소유자로 이동합니다.
다음은 정점 이동 명령의 기본 구문입니다.
MOVE VERTEX <source> TO <destination>
[SET [<field>=<value>]* [,]]
[MERGE <JSON>]
[BATCH <batch-size>]다음은 위 구문의 옵션에 대한 세부 정보입니다.
<source>− 이동하려는 정점을 정의합니다. 특정 정점의 레코드 ID 또는 정점에 대한 레코드 ID 배열을 허용합니다.
<destination>− 정점을 이동할 위치를 정의합니다. 클래스 또는 클러스터를 대상으로 지원합니다.
SET − 필드에 값을 설정합니다.
MERGE − JSON을 통해 필드에 값을 설정합니다.
BATCH − 배치 크기를 정의합니다.
Note−이 명령은 연결된 모든 모서리를 업데이트하지만 링크는 업데이트하지 않습니다. Graph API를 사용할 때는 꼭지점에 연결된 Edge를 사용하는 것이 좋습니다.
예
정점을 이동하는 방법을 배우려면 다음 예제를 시도하십시오.
다음 쿼리를 실행하여 레코드 ID가 # 11 : 2 인 단일 정점을 현재 위치에서 Class 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)Delete Vertex명령은 데이터베이스에서 정점을 제거하는 데 사용됩니다. 삭제하는 동안 가장자리와의 일관성을 확인 및 유지하고 삭제 된 정점에 대한 모든 상호 참조 (가장자리 포함)를 제거합니다.
다음은 정점 삭제 명령의 기본 구문입니다.
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)다음 명령을 실행하여 'isSpam'속성으로 표시된 'Customer'클래스에서 모든 정점을 제거합니다.
orientdb> DELETE VERTEX Customer WHERE isSpam = TRUE위의 명령이 성공적으로 실행되면 다음과 같은 출력이 표시됩니다.
Delete record(s) '3' in 0.005000 sec(s)OrientDB에서 개념은 Edge일부 속성의 도움으로 정점 간의 관계처럼 작동합니다. 모서리와 꼭지점은 그래프 데이터베이스의 주요 구성 요소입니다. Edges에 다형성을 적용합니다. Edge의 기본 클래스는 E입니다. Edge를 구현하는 동안 원본 또는 대상 꼭지점이 없거나 존재하지 않으면 트랜잭션이 롤백됩니다.
다음은 Create Edge Command의 기본 구문입니다.
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 − 명령을 더 작은 블록과 배치 크기로 분할할지 여부를 정의합니다.
예
다음 쿼리를 실행하여 두 정점 # 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)Update edge명령은 현재 데이터베이스의 에지 레코드를 업데이트하는 데 사용됩니다. 이것은 실제 업데이트 명령과 동일하며, 정점과의 그래프 일관성을 확인하고 유지하는 것 외에out 과 in 속성.
다음은 Update Edge Command의 기본 구문입니다.
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 − 최대 레코드 수를 정의합니다.
예
영역 Id = 001이고 사람 이름 = 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)Delete edge명령은 데이터베이스를 제거하는 데 사용됩니다. 이는 'in'및 'out'정점 속성 모두에서 가장자리에 대한 모든 상호 참조를 제거하여 정점과의 일관성을 확인하고 유지하는 추가 기능을 포함하는 delete 명령과 동일합니다.
다음은 Delete Edge 명령어의 기본 구문입니다.
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 − 작업을위한 블록 크기를 정의합니다.
예
다음 예제를 사용하여 가장자리를 삭제하는 방법을 알아보십시오.
다음 쿼리를 실행하여 두 정점 (# 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의 다양한 유형의 함수에 대한 전체 참조를 설명합니다. 다음 표는 기능별로 분류 된 기능 목록을 정의합니다.
그래프 기능
| Sr. 아니. | 기능 이름 및 설명 |
|---|---|
| 1 | Out(): 현재 레코드에서 시작하는 인접한 나가는 정점을 Vertex로 가져옵니다. Syntax − out ([<라벨 -1>] [, <라벨 -n>] *) |
| 2 | In(): 현재 레코드에서 시작하는 인접한 들어오는 정점을 Vertex로 가져옵니다. Syntax − in ([<라벨 -1>] [, <라벨 -n>] *) |
| 삼 | Both(): 현재 레코드에서 시작하는 인접한 나가는 정점과 들어오는 정점을 Vertex로 가져옵니다. Syntax − 모두 ([<라벨 1>] [, <라벨 -n>] *) |
| 4 | outE(): 현재 레코드에서 시작하는 인접한 나가는 가장자리를 Vertex로 가져옵니다. Syntax − outE ([<라벨 1>] [, <라벨 -n>] *) |
| 5 | inE(): 현재 레코드에서 시작하는 인접한 들어오는 가장자리를 Vertex로 가져옵니다. Syntax − inE ([<라벨 1>] [, <라벨 -n>] *) |
| 6 | bothE(): 현재 레코드에서 시작하는 인접한 나가는 가장자리와 들어오는 가장자리를 Vertex로 가져옵니다. Syntax − 모두 E ([<라벨 1>] [, <라벨 -n>] *) |
| 7 | outV(): 현재 레코드에서 시작하는 나가는 정점을 Edge로 가져옵니다. Syntax − outV () |
| 8 | inV(): 현재 레코드에서 들어오는 정점을 Edge로 가져옵니다. Syntax − inV () |
| 9 | traversedElement(): 트래버스 명령에서 트래버스 된 요소를 반환합니다. Syntax − traversedElement (<인덱스> [, <항목>]) |
| 10 | traversedVertex(): 트래버스 명령에서 트래버스 된 정점을 반환합니다. Syntax − traversedVertex (<인덱스> [, <항목>]) |
| 11 | traversedEdge(): 트래버스 명령에서 트래버스 된 에지를 반환합니다. Syntax − traversedEdge (<인덱스> [, <항목>]) |
| 12 | shortestPath(): 두 정점 사이의 최단 경로를 반환합니다. 방향은 OUT (기본값), IN 또는 BOTH 일 수 있습니다. Synatx − shortestPath (<sourceVertex>, <destinationVertex> [, <direction> [, <edgeClassName>]]) |
| 13 | dijkstra(): Dijkstra 알고리즘을 사용하여 두 정점 사이의 가장 저렴한 경로를 반환합니다. Syntax − dijkstra (<sourceVertex>, <destinationVertex>, <weightEdgeFieldName> [, <direction>]) |
다음 쿼리와 함께 몇 가지 그래프 함수를 사용해보십시오.
다음 쿼리를 실행하여 모든 차량 정점에서 나가는 모든 정점을 가져옵니다.
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
---+----------+-------+-------수학 함수
| Sr. 아니. | 기능 이름 및 설명 |
|---|---|
| 1 | eval(): 따옴표 (또는 큰 따옴표) 사이의 표현식을 평가합니다. Syntax − eval ( '<표현식>') |
| 2 | min(): 최소값을 반환합니다. 둘 이상의 매개 변수로 호출되면 모든 인수 사이의 최소 인수 값을 반환합니다. Syntax − min (<필드> [, <필드 -n>] *) |
| 삼 | max(): 최대 값을 반환합니다. 둘 이상의 매개 변수를 사용하여 호출하면 모든 인수 사이의 최대 값을 반환합니다. Syntax − max (<필드> [, <필드 -n>] *) |
| 4 | sum() 반환 된 모든 값의 합계를 반환합니다. Syntax − sum (<필드>) |
| 5 | abs(): 절대 값을 반환합니다. Integer, Long, Short, Double, Float, BigInteger, BigDecimal, null과 함께 작동합니다. Syntax − abs (<필드>) |
| 6 | avg(): 평균값을 반환합니다. Syntax − avg (<필드>) |
| 7 | count(): 쿼리 조건과 일치하는 레코드를 계산합니다. *가 필드로 사용되지 않으면 내용이 null이 아닌 경우에만 레코드가 계산됩니다. Syntax − count (<필드>) |
| 8 | mode(): 가장 높은 빈도로 발생하는 값을 반환합니다. 계산에서 Null은 무시됩니다. Syntax − mode (<필드>) |
| 9 | median(): 값이 정렬 된 후 중간 값 또는 중간 값을 나타내는 보간 된 값을 반환합니다. 계산에서 Null은 무시됩니다. Syntax − 중앙값 (<필드>) |
| 10 | percentile(): n 번째 백분위 수를 반환합니다. 계산에서 Null은 무시됩니다. Syntax − 백분위 수 (<필드> [, <분위수 -n>] *) |
| 11 | variance() 중간 분산을 반환합니다. 평균에서 제곱 된 차이의 평균입니다.
Syntax − variance (<필드>) |
| 12 | stddev() 표준 편차를 반환합니다. 값이 얼마나 분산되어 있는지 측정합니다. 계산에서 Null은 무시됩니다. Syntax − stddev (<필드>) |
다음 쿼리를 사용하여 몇 가지 수학 함수를 시도해보십시오.
다음 쿼리를 실행하여 모든 직원의 급여 합계를 가져옵니다.
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
---+----------+---------컬렉션 기능
| Sr. 아니. | 기능 이름 및 설명 |
|---|---|
| 1 | set(): 세트에 값을 추가합니다. 값이 컬렉션이면 집합과 병합되고 그렇지 않으면 <value>가 추가됩니다. Syntax − set (<필드>) |
| 2 | map(): 맵을 처음 만들 때 맵에 값을 추가합니다. <value>가 맵이면 맵과 병합되고 그렇지 않으면 쌍 <key> 및 <value>가 새 항목으로 맵에 추가됩니다. Syntax − map (<키>, <값>) |
| 삼 | ist(): 목록이 처음 생성 될 때 목록에 값을 추가합니다. <value>가 컬렉션이면 목록과 병합되고 그렇지 않으면 <value>가 목록에 추가됩니다. Syntax − list (<필드>) |
| 4 | difference(): 집계 또는 인라인으로 작동합니다. 인수가 하나만 전달되면 집계되고, 그렇지 않으면 실행되고 매개 변수로 수신 된 컬렉션 간의 DIFFERENCE를 반환합니다. Syntax − 차이 (<필드> [, <필드 -n>] *) |
| 5 | first(): 다중 값 필드 (배열, 컬렉션 및 맵)의 첫 번째 항목 만 검색합니다. 다중 값 유형이 아닌 경우 값을 반환합니다. Syntax − first (<필드>) |
| 6 | intersect(): 집계 또는 인라인으로 작동합니다. 인수가 하나만 전달되면 집계되고, 그렇지 않으면 실행 및 반환되며 매개 변수로 수신 된 컬렉션의 INTERACTION이 반환됩니다. Syntax − intersect (<필드> [, <필드 -n>] *) |
| 7 | distinct(): 인수로 지정한 필드에 따라 고유 한 데이터 항목 만 검색합니다. 표준 SQL DISTINCT와 비교하여 가장 큰 차이점은 OrientDB를 사용하면 괄호가있는 함수와 하나의 필드 만 지정할 수 있다는 것입니다. Syntax − distinct (<필드>) |
| 8 | expand(): 이 기능에는 두 가지 의미가 있습니다.
Syntax − expand (<필드>) |
| 9 | unionall(): 집계 또는 인라인으로 작동합니다. 인수가 하나만 전달되면 집계되고, 그렇지 않으면 매개 변수로 수신 된 모든 컬렉션의 UNION이 실행되고 반환됩니다. 컬렉션 값 없이도 작동합니다. Syntax − unionall (<필드> [, <필드 -n>] *) |
| 10 | flatten(): 필드에서 컬렉션을 추출하여 결과로 사용합니다. 더 이상 사용되지 않으므로 대신 expand ()를 사용하십시오. Syntax − flatten (<필드>) |
| 11 | last(): 다중 값 필드 (배열, 컬렉션 및 맵)의 마지막 항목 만 검색합니다. 다중 값 유형이 아닌 경우 값을 반환합니다. Syntax − last (<필드>) |
| 12 | symmetricDifference(): 집계 또는 인라인으로 작동합니다. 인수가 하나만 전달되면 집계되고, 그렇지 않으면 실행되고 반환되며 매개 변수로 수신 된 컬렉션 간의 SYMMETRIC DIFFERENCE가 반환됩니다. Syntax − symmetricDifference (<필드> [, <필드 -n>] *) |
다음 쿼리를 사용하여 일부 수집 기능을 시도하십시오.
다음 쿼리를 실행하여 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
---+----------+-------+---------------------------기타 기능
| Sr. 아니. | 기능 이름 및 설명 |
|---|---|
| 1 | date(): 문자열 형식을 지정하는 날짜를 반환합니다. <date-as-string>은 문자열 형식의 날짜이고 <format>은 이러한 규칙을 따르는 날짜 형식입니다. Syntax − date (<문자열로 날짜> [<형식>] [, <시간대>]) |
| 2 | sysdate(): 현재 날짜와 시간을 반환합니다. Syntax − sysdate ([<형식>] [, <시간대>]) |
| 삼 | format(): String.format () 규칙을 사용하여 값을 형식화합니다. Syntax − 형식 (<형식> [, <인수 1>] (, <인수 -n>] *. md) |
| 4 | distance(): Haversine 알고리즘을 사용하여 지구본의 두 지점 사이의 거리를 반환합니다. 좌표는도 여야합니다. Syntax − 거리 (<x- 필드>, <y- 필드>, <x- 값>, <y- 값>) |
| 5 | ifnull(): 전달 된 필드 / 값 (또는 선택적 매개 변수 return_value_if_not_null)을 반환합니다. 필드 / 값이 null이 아니면 return_value_if_null을 반환합니다. Syntax − ifnull (<field | value>, <return_value_if_null> [, <return_value_if_not_null>] (, <field & .md # 124; value>] *) |
| 6 | coalesce(): null이 아닌 첫 번째 필드 / 값 매개 변수를 반환합니다. null이 아닌 필드 / 값이 없으면 null을 반환합니다. Syntax − coalesce (<필드 | 값> [, <필드 -n | 값 -n>] *) |
| 7 | uuid(): Leach-Salz 변형을 사용하여 UUID를 128 비트 값으로 생성합니다. Syntax − uuid () |
| 8 | if(): 조건 (첫 번째 매개 변수)을 평가하고 조건이 참이면 두 번째 매개 변수를 반환하고 그렇지 않으면 세 번째 매개 변수를 반환합니다. Syntax − if (<표현식>, <참인 경우 결과>, <거짓 인 경우 결과>) |
다음 쿼리를 사용하여 일부 기타 기능을 시도하십시오.
다음 쿼리를 실행하여 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 데이터를 쉽게 조작 할 수 있습니다.
Sequences자동 증가 메커니즘에 사용되는 개념이며 OrientDB v2.2에서 도입되었습니다. 데이터베이스 용어에서 시퀀스는 카운터 필드를 관리하는 구조입니다. 간단히 말해 시퀀스는 항상 증가하는 숫자가 필요할 때 주로 사용됩니다. 두 가지 유형에 대응-
ORDERED − 포인터가 새 값을 반환하는 .next 메서드를 호출 할 때마다.
CACHED− 시퀀스는 각 노드에서 'N'항목을 캐시합니다. 우리가 사용하는 각 항목을 호출하려면.next(), 캐시에 두 개 이상의 항목이 포함 된 경우 선호됩니다.
시퀀스 생성
시퀀스는 일반적으로 사람의 ID 값을 자동으로 증가시키는 데 사용됩니다. OrientDB의 다른 SQL 개념과 마찬가지로 RDBMS의 Sequence와 유사한 작업을 수행합니다.
다음 문은 시퀀스를 만드는 기본 구문입니다.
CREATE SEQUENCE <sequence> TYPE <CACHED|ORDERED> [START <start>]
[INCREMENT <increment>] [CACHE <cache>]다음은 위 구문의 옵션에 대한 세부 정보입니다.
<Sequence> − 시퀀스의 로컬 이름.
TYPE − 시퀀스 유형 ORDERED 또는 CACHED를 정의합니다.
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 <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 successfullyIndex 데이터베이스의 데이터 위치를 가리키는 포인터입니다. Indexing데이터베이스의 모든 레코드를 검색하지 않고도 데이터를 빠르게 찾는 데 사용되는 개념입니다. OrientDB는 4 개의 인덱스 알고리즘과 각각의 여러 유형을 지원합니다.
네 가지 유형의 인덱스는 다음과 같습니다.
SB- 트리 인덱스
다른 인덱스 유형에서 사용할 수있는 다양한 기능을 제공합니다. 일반적인 유틸리티에 이것을 사용하는 것이 좋습니다. 내구성이 뛰어나고 트랜잭션이 가능하며 범위 쿼리를 지원합니다. 기본 색인 유형입니다. 이 알고리즘을 지원하는 다른 유형의 플러그인은 다음과 같습니다.
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)인덱스 쿼리
선택 쿼리를 사용하여 인덱스의 레코드를 가져올 수 있습니다.
'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 successfullyRDBMS와 마찬가지로 OrientDB는 트랜잭션 ACID 속성을 지원합니다. ㅏtransaction데이터베이스 관리 시스템 내에서 수행되는 작업 단위로 구성됩니다. 데이터베이스 환경에서 트랜잭션을 유지해야하는 두 가지 주요 이유가 있습니다.
장애로부터 동시 복구를 허용하고 시스템 장애가 발생하더라도 데이터베이스를 일관되게 유지합니다.
데이터베이스에 동시에 액세스하는 프로그램간에 격리를 제공합니다.
기본적으로 데이터베이스 트랜잭션은 Atomic, Consistent, Isolated 및 Durable 속성과 같은 ACID 속성을 따라야합니다. 그러나 OrientDB는 ACID 호환 데이터베이스이므로 ACID 개념을 모순하거나 부정하지 않지만 NoSQL 데이터베이스를 처리하는 동안 인식을 변경합니다. ACID 속성이 NoSQL 데이터베이스와 함께 작동하는 방식을 살펴보십시오.
Atomic − 데이터베이스를 변경하기 위해 어떤 작업을 수행하면 변경 사항이 전체적으로 작동하거나 실패해야합니다.
Consistent − 데이터베이스는 일관성을 유지해야합니다.
Isolated − 다른 트랜잭션 실행이 동시에 실행되는 경우 사용자는 동시에 실행중인 레코드를 볼 수 없습니다.
Durable − 시스템이 충돌하면 (하드웨어 또는 소프트웨어) 데이터베이스 자체가 백업을 수행 할 수 있어야합니다.
Commit 및 Rollback 명령을 사용하여 데이터베이스 트랜잭션을 수행 할 수 있습니다.
범하다
커밋은 모든 변경 사항을 데이터베이스에 저장하여 트랜잭션을 닫는 것을 의미합니다. 롤백은 트랜잭션을 연 시점으로 데이터베이스 상태를 복구하는 것을 의미합니다.
다음 명령문은 COMMIT 데이터베이스 명령의 기본 구문입니다.
COMMITNote −이 명령은 특정 데이터베이스에 연결 한 후 트랜잭션을 시작한 후에 만 사용할 수 있습니다.
예
이 예에서는이 자습서의 이전 장에서 만든 '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롤백
롤백은 트랜잭션을 연 시점으로 데이터베이스 상태를 복구하는 것을 의미합니다.
다음 명령문은 ROLLBACK 데이터베이스 명령의 기본 구문입니다.
ROLLBACKNote −이 명령은 특정 데이터베이스에 연결 한 후 트랜잭션을 시작한 후에 만 사용할 수 있습니다.
예
이 예에서는 자습서의 이전 장에서 만든 '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> ROLLBACKEmployee 테이블에서 동일한 레코드를 검색하려면 선택 쿼리를 다시 확인하십시오.
orientdb> SELECT FROM employee WHERE name LIKE '%.P'롤백이 성공적으로 실행되면 출력에서 0 개의 레코드를 찾을 수 있습니다.
0 item(s) found. Query executed in 0.037 sec(s).OrientDB Hooks사용자 애플리케이션의 각 CRUD 작업 전후에 내부 이벤트를 활성화하는 데이터베이스 용어의 트리거 일뿐입니다. 후크를 사용하여 사용자 지정 유효성 검사 규칙을 작성하거나 보안을 적용하거나 관계형 DBMS에 대한 복제와 같은 외부 이벤트를 정렬 할 수 있습니다.
OrientDB는 두 종류의 후크를 지원합니다.
Dynamic Hook − 클래스 수준 및 / 또는 문서 수준에서 구축 할 수있는 트리거.
Java (Native) Hook − Java 클래스를 사용하여 구축 할 수있는 트리거.
동적 후크
동적 후크는 런타임에 변경 될 수 있고 필요한 경우 문서별로 실행할 수 있지만 Java 후크보다 느리기 때문에 Java 후크보다 유연합니다.
문서에 대해 후크를 실행하려면 먼저 클래스가 OTriggered기본 클래스. 나중에 관심있는 이벤트에 대한 사용자 지정 속성을 정의합니다. 다음은 사용 가능한 이벤트입니다.
onBeforeCreate − 부름 before 새 문서 만들기.
onAfterCreate − 부름 after 새 문서 만들기.
onBeforeRead − 부름 before 문서 읽기.
onAfterRead − 부름 after 문서 읽기.
onBeforeUpdate − 부름 before 문서 업데이트.
onAfterUpdate − 부름 after 문서 업데이트.
onBeforeDelete − 부름 before 문서 삭제.
onAfterDelete − 부름 after 문서 삭제.
동적 후크는 호출 할 수 있습니다-
SQL, Javascript 또는 OrientDB 및 JVM에서 지원하는 모든 언어로 작성된 함수.
자바 정적 메서드.
클래스 레벨 후크
클래스 레벨 후크는 클래스와 관련된 모든 문서에 대해 정의됩니다. 다음은 송장 문서에 대해 클래스 수준에서 작동하는 후크를 설정하는 예입니다.
CREATE CLASS Invoice EXTENDS OTriggered
ALTER CLASS Invoice CUSTOM onAfterCreate = invoiceCreated함수를 만들어 봅시다 invoiceCreated 생성 된 송장 번호를 서버 콘솔에 인쇄하는 Javascript에서.
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 수업.
예를 들어 속성 계정이 'Premium'인 모든 문서에 대해 기존 프로필 클래스에 대해 Javascript 함수로 트리거를 실행 해 보겠습니다. 문서 삭제를 방지하기 위해 트리거가 호출됩니다.
ALTER CLASS Profile SUPERCLASS OTriggered UPDATE Profile
SET onBeforeDelete = 'preventDeletion' WHERE account = 'Premium'만들자 preventDeletion() 자바 스크립트 기능.
CREATE FUNCTION preventDeletion "throw new java.lang.RuntimeException('Cannot
delete Premium profile ' + doc)" LANGUAGE Javascript그런 다음 '프리미엄'계정을 삭제하여 후크를 테스트하십시오.
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 후크
OrientDB 후크 (트리거)의 일반적인 사용 사례 중 하나는 모든 클래스의 생성 및 업데이트 날짜를 관리하는 것입니다. 예를 들어,CreatedDate 레코드가 생성 될 때마다 필드를 만들고 UpdatedDate 레코드가 업데이트 될 때마다 필드를 작성하고 데이터베이스 계층에서 논리를 한 번 구현하고 애플리케이션 계층에서 다시는 걱정할 필요가없는 방식으로 수행합니다.
만들기 전에 다운로드해야합니다. orientdb-core.jar다음 링크를 방문하여 파일 다운로드 OrientDB core . 나중에 해당 jar 파일을 Java 소스 파일을 저장할 폴더에 복사하십시오.
후크 파일 생성
다음과 같은 Java 파일을 만듭니다. HookTest.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 만 설정됩니다.
자바 후크 컴파일
다음 명령을 사용하여 Java 코드를 컴파일하십시오. Note: 다운로드 한 jar 파일과 이러한 Java 파일을 동일한 폴더에 보관합니다.
$ jar cf hooks-1.0-SNAPSHOT.jar *.java컴파일 된 코드를 OrientDB 서버가 찾을 수있는 곳으로 이동
완성 된 .jar 파일을 OrientDB 서버가 찾을 디렉토리에 복사해야합니다. 이것은 './lib'OrientDB Server 루트 디렉토리 아래의 폴더는 다음과 같습니다.
$ 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 Server를 다시 시작하면 정의한 후크 orientdb-server-config.xml이제 활성화되었습니다. OrientDB 콘솔을 시작하고 데이터베이스에 연결하고 다음 명령을 실행하십시오.
INSERT INTO V SET ID = 1;이 명령이 성공적으로 실행되면 다음 출력이 표시됩니다.
Ran create hook이제 다음 명령을 실행하십시오-
UPDATE V SET ID = 2 WHERE ID = 1;이 명령이 성공적으로 실행되면 다음 출력이 표시됩니다.
Ran update hookOrientDB 서버 구성 파일에서 실제 후크 활성화
편집하다 $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 Hooks는 애플리케이션 코드에서 수행해야하는 작업을 자동화하는 데 매우 유용한 도구가 될 수 있습니다. 많은 DBA가 항상 Java 전문가는 아니기 때문에이 튜토리얼에 포함 된 정보가 도움이되고 기술에 익숙해 지므로 필요에 따라 데이터베이스 트리거를 성공적으로 만들 수 있습니다.
Caching사용자 애플리케이션에 편안한 환경을 제공하는 데이터베이스 테이블 구조의 사본을 작성하는 개념입니다. OrientDB에는 다양한 수준의 여러 캐싱 메커니즘이 있습니다.
다음 그림은 캐싱이 무엇인지에 대한 아이디어를 제공합니다.
위 그림에서 DB1, DB2, DB3 응용 프로그램에서 사용되는 세 가지 데이터베이스 인스턴스입니다.
Level-1 캐시는 Local cache특정 세션에 알려진 모든 엔티티를 저장합니다. 이 세션에 세 개의 트랜잭션이있는 경우 세 트랜잭션 모두에서 사용하는 모든 항목이 보관됩니다. 이 캐시는 세션을 닫거나 "지우기"방법을 수행 할 때 지워집니다. 응용 프로그램과 데이터베이스 간의 I / O 작업 부담을 줄이고 성능을 향상시킵니다.
Level-2 캐시는 Real cache타사 공급자를 사용하여 작동합니다. 캐시의 내용을 완전히 제어 할 수 있습니다. 즉, 제거해야 할 항목, 더 오래 저장해야하는 항목 등을 지정할 수 있습니다. 여러 스레드 간의 전체 공유 캐시입니다.
Storage model 디스크, 메모리 또는 원격 서버 인 저장 장치 일뿐입니다.
OrientDB에서 캐시는 어떻게 작동합니까?
OrientDB 캐싱은 다양한 환경에서 다양한 방법론을 제공합니다. 캐싱은 주로 빠른 데이터베이스 트랜잭션에 사용되어 트랜잭션 처리 시간을 줄이고 성능을 향상시킵니다. 다음 흐름도는 로컬 모드와 클라이언트-서버 모드에서 캐싱이 작동하는 방식을 보여줍니다.
로컬 모드 (내장 데이터베이스)
다음 순서도는 레코드가 로컬 모드에서 스토리지와 사용 된 애플리케이션 사이에있는 방법, 즉 데이터베이스 서버가 로컬 호스트에있는 경우를 보여줍니다.
클라이언트 응용 프로그램이 레코드를 요청할 때 OrientDB는 다음 사항을 확인합니다.
트랜잭션이 시작된 경우 트랜잭션 내부에서 변경된 레코드를 검색하고 발견되면 반환합니다.
로컬 캐시가 활성화되고 요청 된 레코드가 포함 된 경우 반환합니다.
이 시점에서 레코드가 캐시에 없으면 저장소 (디스크, 메모리)에 요청합니다.
클라이언트 서버 모드 (원격 데이터베이스)
다음 흐름도는 클라이언트-서버 모드에서 즉, 데이터베이스 서버가 원격 위치에있을 때 레코드가 스토리지와 사용 된 애플리케이션 사이에있는 방법을 보여줍니다.
클라이언트 응용 프로그램이 레코드를 요청할 때 OrientDB는 다음 사항을 확인합니다.
트랜잭션이 시작된 경우 트랜잭션 내부에서 변경된 레코드를 검색하고 발견되면 반환합니다.
로컬 캐시가 활성화되고 요청 된 레코드가 포함 된 경우 반환합니다.
이 시점에서 레코드가 캐시에 없으면 TCP / IP 호출을 통해 서버에 레코드를 요청합니다.
서버에서 로컬 캐시가 활성화되고 요청 된 레코드가 포함 된 경우 반환합니다.
이 시점에서 여전히 레코드는 서버에 캐시되지 않고 스토리지 (디스크, 메모리)에 요청합니다.
OrientDB는 Java Virtual Machine과 함께 번들로 제공되는 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, 응용 프로그램 / 서버를 시작하는 쉘 / 명령 프롬프트의 출력으로. 'log.console.level'변수를 설정하여 변경할 수 있습니다.
File, 로그 파일에 대한 출력으로. 'log.file.level'을 설정하여 변경할 수 있습니다.
로깅 구성
로깅 전략 및 정책은 Java를 따르는 파일을 사용하여 구성 할 수 있습니다.
syntax − 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) 스크립트
시스템 속성 설정 "log.console.level"및"log.file.level"java의 -D 매개 변수를 사용하여 원하는 레벨로.
$ java -Dlog.console.level = FINE ...런타임에 로깅
다음은 시작 수준에서 다양한 방법으로 로깅을 설정하는 절차입니다.
Java 코드 사용
시스템 변수는 System.setProperty () API를 사용하여 시작할 때 설정할 수 있습니다. 다음 코드 조각은 Java 코드를 사용하여 로깅 수준을 설정하는 구문입니다.
public void main(String[] args){
System.setProperty("log.console.level", "FINE");
...
}원격 서버에서
URL : /server/log.<type> / <level>에 대해 HTTP POST를 실행합니다.
- <type>은 "console"또는 "file"일 수 있습니다.
- <level>은 지원되는 수준 중 하나입니다.
예
다음 예제는 cURLOrientDB 서버에 대해 HTTP POST 명령을 실행합니다. 서버의 "루트"사용자 및 암호가 사용되었습니다. 자신의 암호로 바꿉니다.
콘솔에 대한 최상의 추적 수준 활성화-
curl -u root:root -X POST http://localhost:2480/server/log.console/FINEST파일에 대한 최상의 추적 수준 활성화-
curl -u root:root -X POST http://localhost:2480/server/log.file/FINEST이 장에서는 OrientDB를 사용하는 애플리케이션을 최적화하는 방법에 대한 몇 가지 일반적인 팁을 얻을 수 있습니다. 다양한 유형의 데이터베이스에 대한 성능을 향상시키는 세 가지 방법이 있습니다.
Document Database Performance Tuning − 모든 새 문서에 대한 문서 생성을 방지하는 기술을 사용합니다.
Object Database Performance Tuning − 일반적인 기술을 사용하여 성능을 향상시킵니다.
Distributed Configuration Tuning − 분산 구성에서 성능을 향상시키기 위해 다른 방법론을 사용합니다.
메모리, JVM 및 원격 연결 설정을 변경하여 일반 성능 튜닝을 수행 할 수 있습니다.
메모리 설정
성능 향상을위한 메모리 설정에는 다양한 전략이 있습니다.
서버 및 임베디드 설정
이 설정은 직접 사용하여 임베디드 모드에서 OrientDB를 사용하여 Java 애플리케이션이 실행되는 서버 구성 요소 및 JVM 모두에 유효합니다. plocal.
튜닝에서 가장 중요한 것은 메모리 설정이 올바른지 확인하는 것입니다. 실제 차이를 만들 수있는 것은 메모리 매핑에 사용되는 가상 메모리와 힙 사이의 적절한 균형이며, 특히 인 메모리 캐시 구조가 원시 IO보다 적은 수의 대규모 데이터 세트 (GB, TB 등)에서 사용됩니다.
예를 들어 Java 프로세스에 최대 8GB를 할당 할 수있는 경우 일반적으로 작은 힙과 큰 디스크 캐시 버퍼 (오프 힙 메모리)를 할당하는 것이 좋습니다.
힙 메모리를 늘리려면 다음 명령을 시도하십시오.
java -Xmx800m -Dstorage.diskCache.bufferSize=7200 ...그만큼 storage.diskCache.bufferSize 설정 (이전 "로컬"스토리지 사용시 file.mmap.maxMemory)는 MB 단위이며 디스크 캐시 구성 요소에 사용할 메모리 양을 알려줍니다. 기본적으로 4GB입니다.
NOTE − 최대 힙과 디스크 캐시 버퍼의 합이 너무 높으면 OS가 크게 느려지면서 스왑 될 수 있습니다.
JVM 설정
JVM 설정은 server.sh (및 server.bat) 배치 파일로 인코딩됩니다. 사용량 및 hw / sw 설정에 따라 JVM을 조정하도록 변경할 수 있습니다. server.bat 파일에 다음 줄을 추가합니다.
-server -XX:+PerfDisableSharedMem이 설정은 JVM에 대한 디버그 정보 쓰기를 비활성화합니다. JVM을 프로파일 링해야하는 경우이 설정을 제거하십시오.
원격 연결
원격 연결을 사용하여 데이터베이스에 액세스 할 때 성능을 향상시킬 수있는 여러 가지 방법이 있습니다.
가져 오기 전략
원격 데이터베이스로 작업 할 때 사용 된 가져 오기 전략에주의를 기울여야합니다. 기본적으로 OrientDB 클라이언트는 결과 집합에 포함 된 레코드 만로드합니다. 예를 들어 쿼리가 100 개의 요소를 반환하지만 클라이언트에서 이러한 요소를 교차하는 경우 OrientDB 클라이언트는 누락 된 각 레코드에 대해 서버에 한 번 이상의 네트워크 호출을 사용하여 요소를 느리게로드합니다.
네트워크 연결 풀
기본적으로 각 클라이언트는 하나의 네트워크 연결 만 사용하여 서버와 통신합니다. 동일한 클라이언트의 여러 스레드가 동일한 네트워크 연결 풀을 공유합니다.
여러 스레드가있는 경우 무료 네트워크 연결을 기다리는 데 많은 시간이 소요되므로 병목 현상이 발생할 수 있습니다. 이것이 네트워크 연결 풀을 구성하는 것이 중요한 이유입니다.
구성은 매우 간단합니다. 단지 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");분산 구성 조정
분산 구성에서 성능을 향상시키는 방법에는 여러 가지가 있습니다.
거래 사용
그래프를 업데이트하더라도 항상 트랜잭션에서 작업해야합니다. OrientDB를 사용하면 외부에서 작업 할 수 있습니다. 일반적인 경우는 읽기 전용 쿼리이거나 실패시 대량 및 비 동시 작업을 복원 할 수 있습니다. 분산 구성에서 실행할 때 트랜잭션을 사용하면 대기 시간을 줄이는 데 도움이됩니다. 이는 분산 작업이 커밋 시간에만 발생하기 때문입니다. 대기 시간으로 인해 하나의 큰 작업을 배포하는 것이 작은 여러 작업을 전송하는 것보다 훨씬 효율적입니다.
복제 대 샤딩
OrientDB 분산 구성은 전체 복제로 설정됩니다. 확장 읽기에는 동일한 데이터베이스 복사본이있는 여러 노드가 있어야합니다. 실제로 각 서버는 읽기 및 쿼리 실행에 독립적입니다. 10 개의 서버 노드가있는 경우 읽기 처리량은 10 배입니다.
쓰기의 경우 그 반대입니다. 전체 복제가있는 여러 노드가 있으면 복제가 동기식 인 경우 작업 속도가 느려집니다. 이 경우 여러 노드에서 데이터베이스를 분할하면 노드의 하위 집합 만 쓰기에 관련되므로 쓰기를 확장 할 수 있습니다. 또한 하나의 서버 노드 HD보다 큰 데이터베이스를 가질 수 있습니다.
쓰기 확장
네트워크가 느리고 동기 (기본) 복제가있는 경우 지연 비용을 지불 할 수 있습니다. 실제로 OrientDB가 동기식으로 실행될 때 최소한writeQuorum. 즉, writeQuorum이 3이고 노드가 5 개인 경우 코디네이터 서버 노드 (분산 작업이 시작된 위치)는 클라이언트에 응답을 제공하기 위해 3 개 이상의 노드에서 응답을 기다려야합니다.
일관성을 유지하려면 writeQuorum을 과반수로 설정해야합니다. 5 개 노드가있는 경우 대부분은 3 개입니다. 4 개 노드에서는 3 개입니다. writeQuorum을 4 개 또는 5 개 대신 3 개로 설정하면 대기 시간 비용을 줄이고 일관성을 유지할 수 있습니다.
비동기 복제
속도를 높이기 위해 대기 시간 병목 현상을 제거하도록 비동기 복제를 설정할 수 있습니다. 이 경우 코디네이터 서버 노드는 로컬에서 작업을 실행하고 클라이언트에게 응답을 제공합니다. 전체 복제는 백그라운드에 있습니다. 쿼럼에 도달하지 않은 경우 변경 사항이 투명하게 롤백됩니다.
읽기 확장
이미 대부분의 노드에 writeQuorum을 설정 한 경우 readQuorum1 (기본값)입니다. 이것은 모든 읽기 속도를 높입니다.
업그레이드하는 동안 버전 번호와 형식을 고려해야합니다. 형식에는 MAJOR, MINOR, PATCH의 세 가지 유형이 있습니다.
MAJOR 버전이 호환되지 않는 API 변경을 수반합니다.
MINOR 버전은 이전 버전과 호환되는 방식으로 기능을 수반합니다.
PTCH 버전은 이전 버전과 호환되는 버그 수정을 수반합니다.
부 버전과 주 버전간에 동기화하려면 데이터베이스를 내보내고 가져와야 할 수 있습니다. 때때로 많은 사람들이 LOCAL에서 PLOCAL로 데이터베이스를 마이그레이션하고 그래프를 RidBag로 마이그레이션해야합니다.
LOCAL 스토리지 엔진에서 PLOCAL로 마이그레이션
버전 1.5.x부터 OrientDB는 완전히 새로운 스토리지 엔진 인 PLOCAL (페이징 된 LOCAL)과 함께 제공됩니다. LOCAL과 같이 지속적이지만 정보를 다른 방식으로 저장합니다. 다음 포인트는 PLOCAL과 LOCAL 사이의 비교를 보여줍니다-
PLOCAL에서 레코드는 클러스터 파일에 저장되는 반면 LOCAL은 클러스터와 데이터 세그먼트로 분할되었습니다.
PLOCAL은 쓰기시 추가 모드로 인해 LOCAL보다 내구성이 높습니다.
PLOCAL에는 쓰기에 대한 경합 잠금이 있으며 이는 더 많은 동시성을 의미합니다.
PLOCAL은 MMap (메모리 매핑 기술)을 사용하지 않으므로 동작이 더 "예측 가능"합니다.
LOCAL 저장소를 새 PLOCAL로 마이그레이션하려면 PLOCAL을 저장소 엔진으로 사용하여 데이터베이스를 내보내고 다시 가져와야합니다. 다음은 절차입니다.
Step 1 − 새 셸 (Linux / Mac) 또는 명령 프롬프트 (Windows)를 엽니 다.
Step 2− 콘솔을 사용하여 데이터베이스를 내 보냅니다. 주어진 명령에 따라 데이터베이스 데모를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 :"로 변경해야합니다.
그래프를 RidBag로 마이그레이션
OrientDB 1.7부터 RidBag는 그래프에서 인접 관계를 관리하는 기본 컬렉션입니다. MVRB-Tree에 의해 관리되는 이전 데이터베이스는 완전히 호환되지만 데이터베이스를 최신 형식으로 업데이트 할 수 있습니다.
콘솔을 통해 또는 다음을 사용하여 그래프를 업그레이드 할 수 있습니다. ORidBagMigration 수업.
CONNECT 데이터베이스에 연결 plocal:databases/<graphdb-name>
업그레이드 그래프 명령 실행
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으로 지정된 두 가지 유형이 있습니다.
Allow All But (Rules)− 기본적으로 슈퍼 유저 모드입니다. 규칙을 사용하여 이에 대한 예외를 지정하십시오. OrientDB가 요청 된 리소스에 대한 규칙을 찾지 못하면 사용자가 작업을 실행할 수 있습니다. 이 모드는 주로 고급 사용자와 관리자에게 사용됩니다. 기본 역할 관리자는 기본적으로이 모드를 사용하며 예외 규칙이 없습니다. 데이터베이스에서 1로 기록됩니다.
Deny All But (Rules)− 기본적으로이 모드는 아무것도 허용하지 않습니다. 규칙을 사용하여 이에 대한 예외를 지정하십시오. OrientDB가 요청 된 리소스에 대한 규칙을 찾으면 사용자가 작업을 실행할 수 있습니다. 이 모드를 모든 클래식 사용자의 기본값으로 사용하십시오. 기본 역할 (reader 및 writer)은이 모드를 사용합니다. 데이터베이스에서 0으로 기록됩니다.
OrientDB는 GUI를 통해 데이터베이스 작업을 수행 할 수있는 웹 UI를 제공합니다. 이 장에서는 OrientDB에서 사용할 수있는 다양한 옵션에 대해 설명합니다.
Studio 홈페이지
Studio는 OrientDB 배포판과 함께 번들로 제공되는 OrientDB 관리를위한 웹 인터페이스입니다.
먼저 다음 명령을 사용하여 OrientDB 서버를 시작해야합니다.
$ server.sh컴퓨터에서 OrientDB를 실행하면 URL을 통해 웹 인터페이스에 액세스 할 수 있습니다.
http://localhost:2480명령이 성공적으로 실행되면 다음과 같은 화면이 출력됩니다.
기존 데이터베이스에 연결
로그인하려면 데이터베이스 목록에서 데이터베이스를 선택하고 데이터베이스 사용자를 사용하십시오. 기본적으로 (사용자 이름 / 암호)reader/reader 데이터베이스에서 레코드를 읽을 수 있습니다. writer/writer 레코드를 읽고, 만들고, 업데이트하고, 삭제할 수 있습니다. admin/admin 모든 권리가 있습니다.
기존 데이터베이스 삭제
데이터베이스 목록에서 데이터베이스를 선택하고 휴지통 아이콘을 클릭하십시오. Studio는 서버 사용자 및 서버 비밀번호를 입력해야하는 확인 팝업을 엽니 다.
그런 다음 "데이터베이스 삭제"버튼을 클릭합니다. 서버 자격 증명은$ORIENTDB_HOME/config/orientdb-server-config.xml 파일.
<users>
<user name = "root" password = "pwd" resources = "*" />
</users>새 데이터베이스 생성
새 데이터베이스를 생성하려면 홈페이지에서 "새 DB"버튼을 클릭하십시오.
새 데이터베이스를 생성하려면 다음 정보가 필요합니다-
- 데이터베이스 이름
- 데이터베이스 유형 (문서 / 그래프)
- 스토리지 유형 (plocal / 메모리)
- 서버 사용자
- 서버 암호
서버 자격 증명은 $ORIENTDB_HOME/config/orientdbserver-config.xml 파일.
<users>
<user name = "root" password = "pwd" resources = "*" />
</users>생성되면 Studio는 자동으로 새 데이터베이스에 로그인합니다.
쿼리 실행
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가 기록에 보관할 쿼리 수를 구성 할 수 있습니다. 또한 이전에 실행 한 쿼리를 검색하거나 기록에서 모든 쿼리를 삭제하거나 단일 쿼리를 삭제할 수도 있습니다.
정점 편집
그래프의 정점을 편집하려면 그래프 섹션으로 이동하십시오. 그런 다음 다음 쿼리를 실행하십시오.
Select From Customer쿼리를 성공적으로 실행하면 다음은 출력 스크린 샷입니다. 그래프 캔버스에서 편집 할 특정 정점을 선택합니다.
특정 정점에서 편집 기호를 선택합니다. 정점을 편집하는 옵션이 포함 된 다음 화면이 표시됩니다.
스키마 관리자
OrientDB는 스키마없는 모드, 스키마 모드 또는 두 가지를 혼합하여 작동 할 수 있습니다. 여기서는 스키마 모드에 대해 설명합니다. 웹 UI 상단의 스키마 섹션을 클릭합니다. 다음 스크린 샷이 표시됩니다.
새 클래스 만들기
새 클래스를 만들려면 New Class단추. 다음 스크린 샷이 나타납니다. 새 클래스를 만들려면 스크린 샷에 표시된대로 다음 정보를 제공해야합니다.
모든 인덱스보기
데이터베이스에 생성 된 모든 색인의 개요를 보려면 스키마 UI에서 모든 색인 버튼을 클릭하면됩니다. 이렇게하면 인덱스 (이름, 유형, 속성 등)에 대한 일부 정보에 빠르게 액세스 할 수 있으며 여기에서이를 삭제하거나 다시 작성할 수 있습니다.
수업 수정
스키마 섹션에서 클래스를 클릭하면 다음 스크린 샷이 표시됩니다.
클래스를 편집하는 동안 속성을 추가하거나 새 색인을 추가 할 수 있습니다.
속성 추가
새 속성 버튼을 클릭하여 속성을 추가합니다. 다음 스크린 샷이 표시됩니다.
속성을 추가하려면 스크린 샷에 표시된대로 다음 세부 정보를 제공해야합니다.
색인 추가
새 색인 버튼을 클릭합니다. 다음 스크린 샷이 표시됩니다. 인덱스를 추가하려면 스크린 샷에 표시된대로 다음 세부 정보를 제공해야합니다.
그래프 편집기
그래프 섹션을 클릭하십시오. 데이터를 그래프 스타일로 시각화 할 수있을뿐만 아니라 그래프와 상호 작용하고 수정할 수도 있습니다.
그래프 영역을 채우려면 쿼리 편집기에 쿼리를 입력하거나 찾아보기 UI에서 그래프로 보내기 기능을 사용합니다.
정점 추가
그래프 데이터베이스와 그래프 캔버스 영역에 새 정점을 추가하려면 버튼을 눌러야합니다. Add Vertex. 이 작업은 두 단계로 수행됩니다.
첫 번째 단계에서 새 정점에 대한 클래스를 선택하고 다음을 클릭해야합니다.
두 번째 단계에서는 새 정점의 필드 값을 삽입해야합니다. OrientDB는 스키마없는 모드를 지원하므로 사용자 지정 필드를 추가 할 수도 있습니다. 새 정점을 영구적으로 만들기 위해 '변경 사항 저장'을 클릭하면 정점이 데이터베이스에 저장되고 캔버스 영역에 추가됩니다.
정점 삭제
삭제할 정점을 클릭하여 원형 메뉴를 엽니 다. 메뉴 항목 더보기 (...)에 마우스를 올려 하위 메뉴를 연 다음 휴지통 아이콘을 클릭합니다.
캔버스에서 정점 제거
원형 메뉴를 열고 메뉴 항목 더보기 (...)에 마우스를 올려 하위 메뉴를 연 다음 지우개 아이콘을 클릭합니다.
정점 검사
Vertex 속성을 빠르게 살펴 보려면 눈 모양 아이콘을 클릭하십시오.
보안
Studio 2.0에는 그래픽 방식으로 사용자 및 역할을 관리 할 수있는 새로운 보안 관리가 포함되어 있습니다.
사용자
다음 작업을 수행하여 데이터베이스 사용자를 관리 할 수 있습니다.
- 사용자 검색
- 사용자 추가
- 사용자 삭제
- 사용자 편집 : 역할은 이름, 상태 및 암호에 대해 인라인으로 편집 할 수 있습니다. Edit 단추
사용자 추가
새 사용자를 추가하려면 Add User 버튼을 클릭하고 새 사용자에 대한 정보 (이름, 암호, 상태, 역할)를 작성한 다음 저장하여 새 사용자를 데이터베이스에 추가합니다.
역할
당신은 데이터베이스 역할을 관리하기 위해 다음 작업을 수행 할 수 있습니다-
- 역할 검색
- 역할 추가
- 역할 삭제
- 역할 편집
역할 추가
새 사용자를 추가하려면 Add Role 버튼을 누르고 새 역할 (이름, 상위 역할, 모드)에 대한 정보를 입력 한 다음 저장하여 새 역할을 데이터베이스에 추가합니다.
역할에 규칙 추가
선택한 역할에 대한 새 보안 규칙을 추가하려면 Add Rule단추. 보안하려는 리소스의 문자열을 묻습니다. 그런 다음 새로 생성 된 리소스에 대한 CRUD 권한을 구성 할 수 있습니다.
RDBMS와 유사하게 OrientDB는 JDBC를 지원합니다. 이를 위해 먼저 JDBC 프로그래밍 환경을 구성해야합니다. 다음은 응용 프로그램과 데이터베이스 간의 연결을 만드는 절차입니다.
먼저 JDBC 드라이버를 다운로드해야합니다. 다음 링크를 방문하십시오https://code.google.com/archive/p/orient/downloads OrientDB-JDBC를 다운로드합니다.
다음은 OrientDB-jdbc 연결을 달성하기위한 기본 5 단계입니다.
- JDBC 드라이버로드
- 연결 만들기
- 문 만들기
- 문 실행
- 연결 닫기
예
OrientDB-JDBC 연결을 이해하려면 다음 예제를 시도하십시오. 다음 필드와 그 유형을 포함하는 직원 테이블이 있다고 가정 해 보겠습니다.
| Sr. 아니. | 분야 명 | 유형 |
|---|---|---|
| 1 | 신분증 | 정수 |
| 2 | 이름 | 끈 |
| 삼 | 봉급 | 정수 |
| 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, age 및 join_date 필드가있는 직원 이름이있는 Employee 테이블이 표시됩니다.
다음 코드를 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 InsertedPython 용 OrientDB 드라이버는 바이너리 프로토콜을 사용합니다. PyOrient는 OrientDB를 Python과 연결하는 데 도움이되는 git 허브 프로젝트 이름입니다. OrientDB 버전 1.7 이상에서 작동합니다.
다음 명령은 PyOrient를 설치하는 데 사용됩니다.
pip install pyorient다음과 같은 스크립트 파일을 사용할 수 있습니다. demo.py 다음 작업을 수행하려면-
클라이언트 인스턴스 만들기는 연결을 만드는 것을 의미합니다.
이름이 지정된 DB 만들기 DB_Demo.
DB_Demo라는 이름의 DB를 엽니 다.
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