Professional Documents
Culture Documents
Báo cáo hệ quản trị Neo4j
Báo cáo hệ quản trị Neo4j
1 | Page
II.3.2. Tính trong suốt với ứng dụng mức cao.................26
II.4. Yêu cầu về môi trường hoạt động....................................27
II.4.1. Yêu cầu phần cứng.........................................................27
II.4.2. Yêu cầu phần mềm.........................................................28
II.4.3. Chi phí.................................................................................28
II.5. Tính mở........................................................................................30
II.6. Khả năng và giới hạn.............................................................31
II.6.1. Khả năng.............................................................................31
II.6.2. Giới hạn:.............................................................................31
II.7. Ưu nhược điểm.........................................................................33
II.7.1. Ưu điểm...............................................................................33
II.7.2. Nhược điểm........................................................................34
III. Chương trình mô phỏng thao tác với Neo4j trên ngôn
ngữ Java.....................................................................................................37
III.1. Tương tác với cơ sở dữ liệu Neo4J.................................37
III.2. So sánh giữa cơ sở dữ liệu MySQL và cơ sở dữ liệu
Neo4J tương đương..........................................................................38
IV. Khó khăn và kết quả đạt được.................................................38
2 | Page
IV.1. Khó khăn...................................................................................38
IV.2. Kết quả đạt được....................................................................38
3 | Page
NEO4J
2010, Neo4j Server đã được tạo ra (trước đây chỉ có một DB nhúng)
2011, tài trợ hoàn toàn khởi động công nghệ Neo
Đối tượng lưu trữ của một cơ sở dữ liệu dạng đồ thị là một nút (node) trong
đó các node sẽ giống như một bản ghi dữ liệu chứa các thông tin về node.
Relationships là các quan hệ để liên kết các node với nhau, người dùng định
nghĩa các quan hệ này và hoàn toàn tự mình tổ chức để tạo ra một cấu trúc lưu trữ
riêng như tree, danh sách, bảng ma trận…..
Ví dụ: node {id:1; name: node1; class: myNode} node này lưu các thông tin
gồm id, name, class của bản ghi này. Id, name, class là các thuộc tính của bản ghi
đó và cũng là key tương ứng với các value: {1,node1,myNode}.
4 | Page
Hình 1.1. Mô tả mô hình của một node dữ liệu.
5 | Page
II.1.2. Mô hình lưu trữ và tổ chức dữ liệu trên Neo4j.
Neo4j là cơ sở dữ liệu dạng đồ thị nên mô hình lưu trữ, cấu trúc lưu trữ và
đối tượng mang đặc điểm của cơ sở dữ liệu dạng đồ thị nói chung. Tức là Neo4j
lưu trữ dữ liệu trên các nút (node), xây dựng lên các cấu trúc dữ liệu khác nhau
bằng các relationships.
II.1.2.1.Node
Các đơn vị cơ bản đã hình thành một đồ thị là các nút và các mối quan
hệ. Trong Neo4j, cả nút và các mối quan hệ đều có thể chứa thuộc tính. Các
nút thường được sử dụng để đại diện cho các thực thể, nhưng tùy thuộc vào
mối quan hệ miền có thể được sử dụng cho mục đích đó là hợp lí.
II.1.2.2. Quan hệ
Mối quan hệ giữa các nút trong đồ thị là một phần quan trọng, dựa vào đó có
thể tìm kiếm dữ liệu có liên quan. Mối quan hệ cũng có thể có thuộc tính
6 | Page
Mối quan hệ kết nối 2 nút được đảm bảo hợp lệ từ nút bắt đầu đến nút kết
thúc
Mối quan hệ luôn có hướng, được xác định theo hướng đi vào hoặc đi ra một
nút. Đây là yếu tố quan trọng được sử dụng khi duyệt đồ thị.
Mối quan hệ là như nhau khi đi qua một trong hai hướng. Điều này có
nghĩa rằng không có cần phải thêm các mối quan hệ trùng lặp theo hướng
ngược lại. Trong khi mối quan hệ luôn luôn có một hướng, bạn có thể bỏ qua
hướng nếu không sử dụng đến. Lưu ý rằng một nút có thể có mối quan hệ với
chính nó sau đây:
7 | Page
Cả mối quan hệ và nút đều có thể có thuộc tính. Các thuộc tính sẽ là cặp
khóa-giá trị mà khóa chính là một chuỗi. Giá trị của thuộc tính có thể là một kiểu
giá trị nguyên thủy hoặc mảng giá trị nguyên thủy. Ví dụ: String, int, int[].
“null” không phải là giá trị thuộc tính hợp lệ. Null có thể được mô hình hóa
bởi một … (the absence of key).
Nhận xét: Đây sẽ là một cơ sở dữ liệu hết sức mở đối với người dùng, mọi
cấu trúc lưu trữ sẽ phụ thuộc vào mục đích của người dùng, hướng tới người
dùng hơn.
II.1.2.4. Traversal
Traversal của một đồ thị nghĩa là duyệt qua các nút của nó, kế tiếp các mối
quan hệ theo một số quy tắc. Trong nhiều trường hợp chỉ là một đồ thị con được
truy cập, tìm thấy các nút và các mối quan hệ của nó.
8 | Page
II.1.2.5. Đường dẫn
Một đường dẫn là một hoặc nhiều nút với các mối quan hệ kết nối chúng,
thường lấy như một truy vấn.
9 | Page
II.2. Phương pháp, kĩ thuật xử lý truy vấn đồng thời.
II.2.1.Transaction Management.
Để duy trì tính đầy đủ và toàn vẹn dữ liệu và đảm bảo hành vi transaction
tốt, Neo4j hỗ trợ thuộc tính ACID :
Atomicity : bất kỳ một transaction nào không thành công trạng thái cơ sở
dữ liệu không thay đổi.
Consistency (tính thống nhất): bất kỳ một transaction nào đều để lại một
cơ sở dữ liệu thống nhất.
Isolation (tính đọc lập): trong một transaction, dữ liệu được sửa đổi
không thể được truy cập bởi các operator khác.
Durability: DBMS luôn luôn có thể phục hồi một kết quả mà transaction
đã được commited.
Cụ thể là:
Tất cả các sửa đổi dữ liệu phải được bọc trong một transaction.
Mức độ tách biệt mặc định là: READ_COMMITTED
Dữ liệu được lấy bằng phương pháp duyệt không được bảo vệ từ sửa đổi
bởi các transaction khác.
Không lặp lại các lần đọc có thể xảy ra.(ví dụ: chỉ được ghi các lock và
giữ chúng cho đến khi kết thúc transaction).
Có thể làm thủ công việc ghi các lock trên node và quan hệ ở mức độ
tách biệt cao hơn.
Các lock được cài đặt ở mức độ Node và quan hệ.
Phát hiện bế tắc được xây dựng trong quản lý transaction lõi.
10 | P a g e
giấu là transaction cấp cao cho việc rollback, có nghĩa là tất cả transaction sẽ được
rollback.
Transaction sẽ không giải phóng lock hay bộ nhớ cho đến khi nó được hoàn
thành. Transaction sẽ được commit hay rollback tùy thuộc vào trạng thái thành
công hoặc không thành công.
Tất cả các thay đổi của Transaction đều được lưu trong bộ nhớ. Điều này có
nghĩa là các cập nhập lớn sẽ được chia thành các transaction cấp cao để tránh tràn
bộ nhớ. Nó phải là transaction cấp cao nhất trước khi chia công việc thành các
nested transaction có thể thêm các công việc vào transaction cấp cao nhất.
Khi xóa, tạo một node một ghi lock sẽ được thực thi cho một node, quan hệ
cụ thể.
Khi xóa, tạo 1 mối quan hệ một ghi lock sẽ được thực thi trên các quan hệ cụ
thể, và các nút của nó.
11 | P a g e
Các lock sẽ được thêm vào các transaction và được giải phóng khi
transaction kết thúc.
II.2.5. Deadlocks.
Khi các lock được sử dụng – bế tắc có thể xảy ra. Neo4j tự động phát hiện
các bế tắc trước khi chúng xảy ra và ném ra ngoại lệ. Trước khi ngoại lệ được ném,
các transaction được đánh dấu để rollbacks. Tất cả các locks sẽ được dữ bởi các
transactions nhưng được giải phóng khi chúng kết thúc.
Một khi các lock được giải phóng, các transaction đang đợi lock được giữ
bởi các transaction gây ra bế tắc: được tiến hành. Các transation gây ra bế tắc có
thể được dùng lại bởi người sử dụng nếu cần thiết.
Các bế tắc xảy ra thường xuyên là dấu hiệu của các yêu cầu ghi đồng thời
xảy ra cùng 1 lúc mà nó không thể thực hiện chúng trong 1 thời gian mà có thể
đảm bảo tính độc lập và thống nhất. Giải pháp là để đảm bảo đồng thời xảy ra 1
cách hợp lý. Ví dụ: cho 2 node cụ thể A, B thêm hoặc xóa quan hệ của 2 node này
1 cách ngẫu nhiên cho mỗi transaction có thể dẫn đến sự bế tăc khi có 2 hoặc nhiều
hơn transaction thực hiện chúng đồng thời. Một giải pháp là để cho cập nhập được
xảy ra theo 1 thứ tự đứng trước ( vd: A rồi B). Một giải pháp khác là để đảm bảo
cho mỗi luồng/transaction không có bất kì xung đột khi ghi vào node hay quan hệ
như một số giao dịch đồng thời khác. Một ví dụ có thể đạt được điều này : Cho
phép 1 luồng duy nhất làm cho tất cả các bản cập nhập có thể.
Bế tắc gây ra bởi: sự đồng bộ đồng bộ hóa khác với quản lý lock bởi
Neo4j: có thể xảy ra. Vì tất cả các hoạt động trong Neo4j API là luồng an toàn trừ
khi có quy định khác, không cần có sự đồng bộ hóa bên ngoài.Một số code đòi hỏi
sự đồng bộ phải được đồng bộ bởi 1 cách mà nó không được sử dụng các operator
của Neo4j trong khối đồng bộ.
Neo4j có 1 ràng buộc là tất cả các mối quan hệ phải có node bắt đầu và node
kết thúc. Điều này cón nghĩa là, xóa 1 node mà có mối quan hệ gắn liền với nó sẽ
12 | P a g e
ném ra 1 ngoại lệ. Tuy nhiên, nó có thể lựa chọn thứ tự để xóa node và các mối
quan hệ kèm theo miễn là không có các mối quan hệ tồn tại khi thực hiện
transaction.
Tất cả các thuộc tính của 1 node, quan hệ sẽ được loại bỏ khi nó bị
loại bỏ.
Một nút được xóa không có các quan hệ kèm theo khi nó commit.
Có thể tham chiếu đến một mối quan hệ đã bị xóa hoặc hoặc nó chưa
được commit.
Bất kì 1 phương thức viết nào lên một quan hệ khi nó bị xóa sẽ ném ra
1 ngoại lệ.
- Luồng đơn: Bằng cách sử dụng 1 luồng đơn , không có 2 luồng cùng tạo 1
thực thể đặc biệt cùng 1 lúc. Trên HA, một luồng đơn bên ngoài có thể thực
hiện các toán tử trên cụm.
- Get hoặc Create: Bằng cách sử dụng chức năng put-if-absent, thực thể duy
nhất có thể được đảm bảo sử dụg 1 index. Index hoạt động như lock và chỉ
khóa 1 phần nhỏ cần thiết đê đảm bảo tính độc nhất của transaction và
luồng.
- Pessimistic locking.
13 | P a g e
II.2.8. Transaction Event.
Transaction event có thể được đăng ký để nhận các sự kiện transaction.
Đăng ký tại GraphDatabaseService nó sẽ nhận được sự kiện xảy ra ở mỗi
transaction đã commit. Handler không lấy các thông báo về transaction đã không
thực hiện bất kì hoạt động ghi hay chưa commit (hoặc Transaction#success() được
không được gọi hoặc transaction được đánh giấu là thất bại Transaction#failure().
Trước khi Transaction được commit phương thức beforeCommit được gọi với toàn
bộ sự sai khác trong transaction). Tại thời điểm này các transaction đang chạy để
thay đổi vẫn có thể được thực hiện. Tuy nhiên không có gì đảm bảo rang các xử lý
khác sẽ thấy những thay đổi như vậy vì thứ tự xử lý là không xác định. Phương
thức này có thể ném 1 ngoại lệ, trong trường hợp này sẽ không cho các
Transaction được commit (rollback sẽ được áp dụng tiếp theo đó). Nếu
beforeCommit được thực hiện thành công các Transaction sẽ được thực hiện và
phương thức afterCommit sẽ được gọi cùng với 1 dữ liệu transaction như trước
giống như đối tượng được trả về bởi beforeCommit. Điều này đi với giả định là
các xử lý khác cũng được thực hiện beforeCommit thành công.
II.3. Giao diện lập trình ứng dụng (API) và tính trong suốt (transparency) với
các ứng dụng ở mức cao.
REST API là API nhận các Http Request từ phía client và trả về Http
Response tương ứng dưới dạng tập tin json chứa dữ liệu cần thiết cho lần gọi của
client.
Điểm mạnh: Hầu hết REST API truyền qua client chỉ với luồng JSON, vì nó
giúp kết quả trả về nhanh hơn mà lại giảm chi phí bộ nhớ trên server.
Gọi API gốc để lấy về các đường dẫn đến các API chức năng, đây là API
quan trọng nhất cung cấp thông tin cho biết toàn bộ các API chức năng.
Ví dụ:
14 | P a g e
Với quan hệ sau trong CSDL:
Phía dưới là các API mức cao hơn sử dụng các REST API để tạo ra những
cách kết nối và thao tác với cơ sở dữ liệu Neo4j trực quan và phù hợp mục đích
người sử dụng.
A. Cypher API:
REST API cũng cho phép truy vấn với Cypher. Nghĩa là chúng ta sẽ có thể
gửi truy vấn lên trên server để nhận lại kết quả như ý. Giá trị trả về là một danh
sách các column, và 1 phần dữ liệu, bao gồm danh sách các hàng, mỗi hàng bao
15 | P a g e
gồm một danh sách các trường giá trị đại hiện cho REST đó: Node, Relationship,
path hoặc một vài giá trị đơn giản.
Lấy về thông tin 1 node thỏa mãn điều kiện sau “where”.
Ví dụ query sau:
Start x=node:node_auto_index(name={startName})
Match path=(x-[r]-friend)
Where friend.name={name}
Return type (r)
Request sẽ có dạng:
16 | P a g e
Response trả về:
Trả lại PATH của dữ liệu với câu lệnh truy vấn.
Ví dụ:
Start x=node(329)
Match path=(x--friend)
Return path, friend.name
17 | P a g e
Gọi truy vấn lồng nhau:
Khi gửi các truy vấn mà trả về kết quả lồng nhau như danh sách hay đồ thị,
chúng sẽ được trả về lồng nhau.
Ví dụ:
Truy vấn:
Start n = node(337,338)
Return connect(n.name)
18 | P a g e
Ngoài ra còn có các API cho phép tạo node, lấy dữ liệu node, xóa một node,
tạo quan hệ giữa các node.
Được khuyên nên dùng để tận dụng tối đa sức mạnh của neo4j, nó làm tăng
tốc độ xử lý của truy vấn lên rất nhiều, điều này đã được thử nghiệm thực thế.
Đây là 1 trong 3 cách để giao tiếp với neo4j cùng với traverser framwork
và cypher query language.
C. TraverseFramework.
19 | P a g e
Là 1 framework hỗ trợ việc giao tiếp với cơ sở dữ liệu Neo4j, về bản chất nó
vẫn xử dụng giao thức REST để lấy xử lý dữ liệu dưới dạng file json nhưng lại có
những ưu điểm khác biệt so với cypher language.
Traversals được tham chiếu từ một node trong csdl. Nó được điều kiển bằng
địa chỉ URI và body của request.
Returntype
Xác định kiểu giá trị trả về. Nó có thể thuộc các loại sau: node,
relationship,path, fullpath.
Order
Relationships
Quyết định xem kiểu quan hệ nào được dùng. Nó có thể là 1 trong 3:in, out,
all.
NODE_GLOBAL
một Node global, không thể định nghĩa quá 1 lần.
NODE_LEVEL
các đối tượng trên cùng level được đảm bảo là duy nhất.
NODE_PATH
với mỗi node trả về có một path duy nhất từ node bắt đầu đến đó.
20 | P a g e
NODE_RECENT
giống với Node_GLOBAL. Nhưng chỉ đảm bảo tính duy nhất giữa các node
truy cập gần đây nhất (với một số cấu hình cụ thể)
NONE
không bị hạn chế và người dùng phải quản lý nó.
RELATIONSHIP_GLOBAL
relationship không thể được traverser quá 1 lần.
RELATIONSHIP_LEVEL
các thực thể trên cùng level được đảm bảo là duy nhất.
RELATIONSHIP_PATH
với mỗi node trả về có một path quan hệ duy nhất từ node bắt đầu tới nó.
RELATIONSHIP_RECENT
giống NODE_RECENT, nhưng cho relationships.
Prune_evaluator: Quyết định xem traserval có tiếp tục đi theo path đó hay
không, thường sử dụng: built-in none.
Return_filter: Quyết định xem vị trí hiện tại có cần được đóng gói vào
trong kết quả đầu ra hay không. Có thể tự code rule filter hoặc sử dụng 1
trong 2 tùy chọn: all, all_but_start_node.
Max_depth: quy định độ xâu tối đa để cắt lấy kết quả đầu ra (giống limit
trong mysql). nếu không cho thì mặc định sẽ là max_depth=1. Nhưng nếu
prune_evaluator được chỉ định thì sẽ không có giới hạn cho max_depth.
Ví dụ minh họa:
21 | P a g e
Request với phần thân là query của traversal:
22 | P a g e
Giải thích:
Order: truy vấn này sẽ duyệt đồ thị theo kiểu BFS nghĩa là duyệt đồ thị
theo chiều rộng.
Return_filter: truy vấn sẽ lọc và lấy các Node có thuộc tính Name chưa kí
tự t không phân biệt chữ hoa, chữ thường.
Prune_evaluator: yêu cầu là khoảng các từ Node bắt đầu tới Node đang
tham chiếu phải lớn hơn 10.
Uniqueness: sử dụng node_global.
Relationships: ví dụ này lấy theo cả 2 hướng với kiểu knows và loves.
Max_length: giới hạn số lượng trả về là 3(không kể Node bắt đầu).
Chú ý:
Đối tượng position sẽ trả về một path tham chiếu từ Node bắt đầu tới Node
đang xét. Đối tượng bắt đầu được nhìn thấy trong phần header của request,
nó có thể là Node, relationship hoặc path.
Ví dụ:
POST http://localhost:7474/db/data/node/215/traverse/relationship
POST http://localhost:7474/db/data/node/224/traverse/node
Creating a paged traverser:
23 | P a g e
Ví dụ:
Request dạng này sẽ tạo thêm 1 node với data =1, có relationship với tất cả
các node có type = Next. Chú ý paged traverser có thể thuộc 1 trong 3 loại: node,
path, fullpath.
24 | P a g e
POST
http://localhost:7474/db/data/node/577/paged/traverse/node?
leaseTime=10
25 | P a g e
Qua hai đồ thị khảo sát trên ta thấy rằng số query/s của Core java API luôn
là tối ưu nhất.
- Với người dùng thao tác với cơ sở dữ liệu Neo4j thông qua giao diện
console, người dùng thao tác các lệnh truy vấn một cách tự nhiên như khi
thao tác trên mysql hay các cơ sở dữ liệu khác. Họ không hề nhìn thấy được
cũng như không cần biết rằng bên dưới lớp giao diện thao tác lệnh đó Neo4j
đóng gói các truy vấn thành các gói tin theo phương thức REST để trao đổi (
dữ liệu đóng gói dưới dạng các tập tin json ) và gửi đến server và nhận lại
26 | P a g e
reponese sau đó phân tích nó và trả lại dữ liệu cho người dùng (thông qua
RestAPI ).
- Với người dùng lập trình muốn thao tác với Neo4j: Neo4j cung cấp
Tranverser Framework hỗ trợ tương tác với cơ sở dữ liệu, node hay
relationship đều được mô hình hóa thành các đối tượng cho người lập trình
sử dụng, việc thao tác tạo, xóa,update hay truy vấn sẽ mô hình bằng việc sử
dụng các phương thức bên trong đối tượng đã nêu trên mục API. Trong ngôn
ngữ lập trình java, người viết ứng dụng hoàn toàn có thể thao tác và tổ chức
dữ liệu cho ứng dụng của mình thông qua các đối tượng hỗ trợ sẵn này. Xét
về bản chất thì các giao diện ứng dụng Cypher hay Tranverser Framework
đều phải thao tác thông qua RestAPI của Neo4j nhưng tùy vào mục đích mà
sử dụng sao cho phù hợp. Truy vấn bình thường ta nên dùng Cypher nhưng
để truy vấn trong lập trình thì dùng Tranverser Framework là lựa chọn tốt.
Hoạt động trên Linux, UX, Windows XP, Mac OS X để phát triển.
28 | P a g e
uploads
Shell for console access Yes Yes Yes
Graph algorithm package Yes Yes Yes
Native language bindings1 Yes Yes Yes
Web frameworks
Yes Yes Yes
integration 2
29 | P a g e
discount:
Như vậy thì Neo4j gồm 3 bản chính đó là bản dùng miễn phí, bản tính
phí và bản cho doanh nghiệp.
+ Bản dùng miễn phí thì sẽ giới hạn một số tính năng và không có hỗ trợ khi
khách hàng gặp sự cố.
+ Bản tính phí sẽ đầy đủ chức năng và được hỗ trợ khi cần thiết 5x10 giờ
trong tuần, hình thức hỗ trợ qua email.
+ Bản dành cho doanh nghiệp ngoài các chức năng đầy đủ thì sẽ được cung
cấp các dịch vụ tốt hơn như 7x24 giờ trong tuần và hình thức liên hệ sẽ nhanh hơn
đó là điện thoại.
Do Neo4j được thiết kế dưới dạng các đối tượng lưu trữ như node và liên kết
nhau bởi quan hệ (relationships) nên nó trở thành cơ sở dữ liệu cực kì linh hoạt,
điều này làm tăng tính mở của nó đối với người dùng. Theo đó, người dùng hoàn
toàn có thể xây dựng một cấu trúc dữ liệu lưu trữ cho riêng mình tùy vào mục đích
sử dụng, thậm chí có thể thông qua nó để xây dựng một csdl riêng.
Cho phép các plug-in bên ngoài đã được cấu hình trước, hoặc thêm mã
nguồn mở rộng từ người dùng để biến thành CSDL của riêng mình
30 | P a g e
Cho phép lập trình viên làm việc thông qua hướng đối tượng, cấu trúc mạng
linh hoạt, chặt chẽ hơn với các bảng tĩnh - được hưởng tất cả những tiện ích của
cơ sơ dữ liệu có giao dịch truyền tải mạnh mẽ.
Đối với nhiều ứng dụng, Neo4j cung cấp các cải tiến hiệu suất trên thứ tự
của 1000x hoặc nhiều hơn so với relational DBMS.
Neo4j sử dụng hệ thống vào ra không chia theo khối của Java cho việc xử lý
file. Ngoài ra, trong khi bố cục file lưu trí được tối ưu hóa cho các dữ liệu kết nối
lẫn nhau, thì Neo4j không yêu cầu các thiết bị thô. Vì vậy, kích thước file chỉ giới
hạn bằng việc nằm dưới dung lượng của hệ điều hành để xử lý dung lượng trong
Neo4j.
Neo4j cố gắng ánh xạ bộ nhớ càng nhiều file lưu trữ nằm dưới càng tốt. Nếu
số RAM sẵn có không đủ để giữ toàn bộ dữ liệu trong RAM, thì Neo4j sẽ sử dụng
bộ nhớ đệm, chỉ định lại việc ánh xạ bộ nhớ.
Các công ty muốn tối ưu hóa việc sử dụng phần cứng để chuyển các giá trị
nghiệp vụ cực đại từ nguồn cho sẵn. Hướng tiếp cận đọc dữ liệu của Neo4j là cung
cấp các nguồn sử dụng sẵn có tốt nhất có thể. Neo4j không chặn bất kỳ một lệnh
đọc nào. Vì vậy, tránh được các trường hợp deadlock trong việc đọc lệnh và không
cần phải đọc giao tác. Với việc đọc truy cập được phân luồng tới cơ sở dữ liệu, các
truy vấn có thể chạy đồng thời trên càng nhiều bộ xử lý các càng tốt. Điều này
cung cấp một lịch trình cải thiển tốt đối với các server lớn hơn.
Tốc độ ghi là một vấn đề đáng quan tâm đối với nhiều ứng dụng của doanh
nghiệp.
31 | P a g e
- Các lệnh liên tục được duy trì.
- Truy cập lớn ( như backup hay tải file khởi tạo ).
Để hỗ trợ các yêu cầu khác nhau của các kịch bản này, Neo4j hỗ trợ 2 mô
hình ghi vào lớp lưu trữ.
Trong giao tác, các lệnh bình thường phù hợp với ACID, thì mức độ cô lập
được duy trì và các lệnh đọc có thể xảy ra cùng thời điểm với tiến trình ghi. Tại
mỗi giao tác, dữ liệu vẫn tiếp tục trong đĩa cứng và có thể được khôi phục về một
tráng thái cố định khi có sự cố hệ thống. Điều này yêu cầu việc truy cập ghi đĩa và
làm phẳng dữ liệu. Vì vậy, tốc độ ghi của Neo4j trong các server đơn tại chế độ
liên tục bị giới hạn bởi dung lượng vào ra của phần cứng. Kết quả là, việc sử dụng
các ổ SSD tốc độ cao được đề xuất
Neo4j có một bộ cài Batch mà thi hành trực tiếp các file lưu trữ. Chế độ này
không yêu cầu bảo mật giao tác, vì vậy có thể được sử dụng khi có một luồng ghi
đơn. Vì dữ liệu được ghi là tuần tự, và không phẳng đối với các nhật ký logic, việc
tăng hiệu năng lớn có thể xảy ra. Bộ cài Batch được tối ưu hóa cho việc import
lượng lớn dữ liệu không giao tác.
32 | P a g e
II.7. Ưu nhược điểm.
II.7.1. Ưu điểm.
Có tất cả ưu điểm của hệ NoSQL:
+ Cho phép dễ dàng mở rộng. Các dịch vụ dữ liệu mới dựa trên khả năng mở
rộng cấu trúc, được xây dựng cho các đám mây để phân phối.
+ Khắc phục vấn đề của mô hình cơ sở dữ liệu RDBMS về tốc độ, tính năng,
khả năng mở rộng, memory cache,...
Có ưu điểm riêng:
+ Có một hiệu suất cao, cơ sở dữ liệu đồ thị NoSQL với tất cả các tính năng
của một cơ sở dữ liệu có độ trưởng thành và mạnh mẽ.
+ Khả năng mở rộng: Dự đoán được khả năng mở rộng, bằng cách đảm
bảo rằng tất cả các truy vấn chạy với hiệu suất tối đa.
+ Nhờ sử dụng mô hình dữ liệu linh hoạt, một ngôn ngữ truy vấn đồ thị trực
quan, nên Neo4J dễ dàng sử dụng.
33 | P a g e
+ Dễ ánh xạ tự nhiên đồ thị sang một ngôn ngữ hướng đối tượng như: Ruby,
Java, PHP, Python, …
+ Cơ sở dữ liệu nhúng: không chia cấp cơ sở dữ liệu, dễ cài đặt, cấu hình,
triển khai.
+ Neo4j cung cấp đầy đủ trang bị, cũng được thiết kế và tài liệu giao diện
với truy cập thực thể tự động.
+ Gồm nhiều thư viện và mở rộng cho các hoạt động biểu đồ mạnh như
traversals, xác định con đường ngắn nhất, chuyển đổi, dịch chuyển.
+ Cũng bao gồm các trigger, được gọi khi xử lý sự kiện giao dịch.
+ Neo4j kết nối xử lý các truy vấn dữ liệu nhanh hơn hàng ngàn lần so với
nhiều loại cơ sở dữ liệu khác. Ngay cả trên phần cứng rất khiêm tốn, Neo4j
có thể xử lý hàng triệu traversals mỗi giây giữa các nút trong một biểu đồ
trên một máy duy nhất, và hàng ngàn giao dịch ghi được mỗi giây. Tốc độ
này là kết quả của một kiến trúc nguyên bản được thiết kế để lưu trữ dữ liệu
đồ thị.
34 | P a g e
II.7.3. So sánh một số đặc điểm của Neo4J với các cơ sở dữ liệu thông dụng
khác
SQL no no
Hỗ trợ ngôn ngữ lập .Net, Clojure, Go, Groovy, .Net, C, C++, Erlang, Java,
trình Java, JavaScript, Perl, PHP, PHP, Python. Ruby, Scala
Python, Ruby, Scala
Triggers Có Không
Hỗ trợ khóa ngoài Có Không
Transaction ACID Không
concepts
35 | P a g e
Một số so sánh giữa Neo4J và OrientDB
36 | P a g e
nhất
Triggers Có Không
III. Chương trình mô phỏng thao tác với Neo4j trên ngôn ngữ Java.
+ Giao diện hiển thị tương tác giữa người dùng và cơ sở dữ liệu.
37 | P a g e
+ Tạo cơ sở dữ liệu với 100 triệu bản ghi chưa các node với node có thể là:
Person, Address hoặc mối quan hệ giữa chúng. Mối quan hệ giữa 2 đối tượng này
là LIVE_AT.
+ Thực hiện truy vấn trên cơ sở dữ liệu đó: thêm node, xóa node, tìm kiếm
node.
=> So sánh truy vấn và hiệu suất giữa Neo4J và MySQL sử dụng 2 cơ sở dữ liệu
đã tạo ở bên trên.
38 | P a g e