ArangoDB – Discussion

Discuss ArangoDB ”; Previous Next Apparently, the world is becoming more and more connected. And at some point in the very near future, your kitchen bar may well be able to recommend your favorite brands of whiskey! This recommended information may come from retailers, or equally likely it can be suggested from friends on Social Networks; whatever it is, you will be able to see the benefits of using graph databases, if you like the recommendations. This tutorial explains the various aspects of ArangoDB which is a major contender in the landscape of graph databases. Starting with the basics of ArangoDB which focuses on the installation and basic concepts of ArangoDB, it gradually moves on to advanced topics such as CRUD operations and AQL. The last few chapters in this tutorial will help you understand how to deploy ArangoDB as a single instance and/or using Docker. Print Page Previous Next Advertisements ”;

ArangoDB – Useful Resources

ArangoDB – Useful Resources ”; Previous Next The following resources contain additional information on ArangoDB. Please use them to get more in-depth knowledge on this topic. Useful Links on ArangoDB ArangoDB Wiki − Wikipedia Reference for ArangoDB. https://www.arangodb.com/ − ArangoDB Official Website. To enlist your site on this page, please drop an email to [email protected] Print Page Previous Next Advertisements ”;

ArangoDB – AQL Example Queries

ArangoDB – AQL Example Queries ”; Previous Next In this chapter, we will consider a few AQL Example Queries on an Actors and Movies Database. These queries are based on graphs. Problem Given a collection of actors and a collection of movies, and an actIn edges collection (with a year property) to connect the vertex as indicated below − [Actor] <- act in -> [Movie] How do we get − All actors who acted in “movie1” OR “movie2”? All actors who acted in both “movie1” AND “movie2”? All common movies between “actor1” and “actor2”? All actors who acted in 3 or more movies? All movies where exactly 6 actors acted in? The number of actors by movie? The number of movies by actor? The number of movies acted in between 2005 and 2010 by actor? Solution During the process of solving and obtaining the answers to the above queries, we will use Arangosh to create the dataset and run queries on that. All the AQL queries are strings and can simply be copied over to your favorite driver instead of Arangosh. Let us start by creating a Test Dataset in Arangosh. First, download this file − # wget -O dataset.js https://drive.google.com/file/d/0B4WLtBDZu_QWMWZYZ3pYMEdqajA/view?usp=sharing Output … HTTP request sent, awaiting response… 200 OK Length: unspecified [text/html] Saving to: ‘dataset.js’ dataset.js [ <=> ] 115.14K –.-KB/s in 0.01s 2017-09-17 14:19:12 (11.1 MB/s) – ‘dataset.js’ saved [117907] You can see in the output above that we have downloaded a JavaScript file dataset.js. This file contains the Arangosh commands to create the dataset in the database. Instead of copying and pasting the commands one by one, we will use the –javascript.execute option on Arangosh to execute the multiple commands non-interactively. Consider it the life saver command! Now execute the following command on the shell − $ arangosh –javascript.execute dataset.js Supply the password when prompted as you can see in the above screenshot. Now we have saved the data, so we will construct the AQL queries to answer the specific questions raised in the beginning of this chapter. First Question Let us take the first question: All actors who acted in “movie1” OR “movie2”. Suppose, we want to find the names of all the actors who acted in “TheMatrix” OR “TheDevilsAdvocate” − We will start with one movie at a time to get the names of the actors − 127.0.0.1:8529@_system> db._query(“FOR x IN ANY ”movies/TheMatrix” actsIn OPTIONS {bfs: true, uniqueVertices: ”global”} RETURN x._id”).toArray(); Output We will receive the following output − [ “actors/Hugo”, “actors/Emil”, “actors/Carrie”, “actors/Keanu”, “actors/Laurence” ] Now we continue to form a UNION_DISTINCT of two NEIGHBORS queries which will be the solution − 127.0.0.1:8529@_system> db._query(“FOR x IN UNION_DISTINCT ((FOR y IN ANY ”movies/TheMatrix” actsIn OPTIONS {bfs: true, uniqueVertices: ”global”} RETURN y._id), (FOR y IN ANY ”movies/TheDevilsAdvocate” actsIn OPTIONS {bfs: true, uniqueVertices: ”global”} RETURN y._id)) RETURN x”).toArray(); Output [ “actors/Charlize”, “actors/Al”, “actors/Laurence”, “actors/Keanu”, “actors/Carrie”, “actors/Emil”, “actors/Hugo” ] Second Question Let us now consider the second question: All actors who acted in both “movie1” AND “movie2”. This is almost identical to the question above. But this time we are not interested in a UNION but in an INTERSECTION − 127.0.0.1:8529@_system> db._query(“FOR x IN INTERSECTION ((FOR y IN ANY ”movies/TheMatrix” actsIn OPTIONS {bfs: true, uniqueVertices: ”global”} RETURN y._id), (FOR y IN ANY ”movies/TheDevilsAdvocate” actsIn OPTIONS {bfs: true, uniqueVertices: ”global”} RETURN y._id)) RETURN x”).toArray(); Output We will receive the following output − [ “actors/Keanu” ] Third Question Let us now consider the third question: All common movies between “actor1” and “actor2”. This is actually identical to the question about common actors in movie1 and movie2. We just have to change the starting vertices. As an example, let us find all the movies where Hugo Weaving (“Hugo”) and Keanu Reeves are co-starring − 127.0.0.1:8529@_system> db._query( “FOR x IN INTERSECTION ( ( FOR y IN ANY ”actors/Hugo” actsIn OPTIONS {bfs: true, uniqueVertices: ”global”} RETURN y._id ), ( FOR y IN ANY ”actors/Keanu” actsIn OPTIONS {bfs: true, uniqueVertices:”global”} RETURN y._id ) ) RETURN x”).toArray(); Output We will receive the following output − [ “movies/TheMatrixReloaded”, “movies/TheMatrixRevolutions”, “movies/TheMatrix” ] Fourth Question Let us now consider the fourth question. All actors who acted in 3 or more movies. This question is different; we cannot make use of the neighbors function here. Instead we will make use of the edge-index and the COLLECT statement of AQL for grouping. The basic idea is to group all edges by their startVertex (which in this dataset is always the actor). Then we remove all actors with less than 3 movies from the result as here we have included the number of movies an actor has acted in − 127.0.0.1:8529@_system> db._query(“FOR x IN actsIn COLLECT actor = x._from WITH COUNT INTO counter FILTER counter >= 3 RETURN {actor: actor, movies: counter}”). toArray() Output [ { “actor” : “actors/Carrie”, “movies” : 3 }, { “actor” : “actors/CubaG”, “movies” : 4 }, { “actor” : “actors/Hugo”, “movies” : 3 }, { “actor” : “actors/Keanu”, “movies” : 4 }, { “actor” : “actors/Laurence”, “movies” : 3 }, { “actor” : “actors/MegR”, “movies” : 5 }, { “actor” : “actors/TomC”, “movies” : 3 }, { “actor” : “actors/TomH”, “movies” : 3 } ] For the remaining questions, we will discuss the query formation, and provide the queries only. The reader should run the query themselves on the Arangosh terminal. Fifth Question Let us now consider the fifth question: All movies where exactly 6 actors acted in. The same idea as in the query before, but with the equality filter. However, now we need the movie instead of the actor, so we return the _to attribute − db._query(“FOR x IN actsIn COLLECT movie = x._to WITH COUNT INTO counter FILTER counter == 6 RETURN movie”).toArray() The number of actors by movie? We remember in our dataset _to on the edge corresponds to the movie, so we count how often the same _to appears. This is the number of actors. The query is almost identical to the ones before but without the

ArangoDB – How To Deploy

ArangoDB – How to Deploy ”; Previous Next In this chapter, we will describe various possibilities to deploy ArangoDB. Deployment: Single Instance We have already learned how to deploy the single instance of the Linux (Ubuntu) in one of our previous chapters. Let us now see how to make the deployment using Docker. Deployment: Docker For deployment using docker, we will install Docker on our machine. For more information on Docker, please refer our tutorial on Docker. Once Docker is installed, you can use the following command − docker run -e ARANGO_RANDOM_ROOT_PASSWORD = 1 -d –name agdb-foo -d arangodb/arangodb It will create and launch the Docker instance of ArangoDB with the identifying name agdbfoo as a Docker background process. Also terminal will print the process identifier. By default, port 8529 is reserved for ArangoDB to listen for requests. Also this port is automatically available to all Docker application containers which you may have linked. Print Page Previous Next Advertisements ”;

Querying The Data With AQL

Querying the Data with AQL ”; Previous Next In this chapter, we will discuss how to query the data with AQL. We have already discussed in our previous chapters that ArangoDB has developed its own query language and that it goes by the name AQL. Let us now start interacting with AQL. As shown in the image below, in the web interface, press the AQL Editor tab placed at the top of the navigation bar. A blank query editor will appear. When need, you can switch to the editor from the result view and vice-versa, by clicking the Query or the Result tabs in the top right corner as shown in the image below − Among other things, the editor has syntax highlighting, undo/redo functionality, and query saving. For a detailed reference, one can see the official documentation. We will highlight few basic and commonly-used features of the AQL query editor. AQL Fundamentals In AQL, a query represents the end result to be achieved, but not the process through which the end result is to be achieved. This feature is commonly known as a declarative property of the language. Moreover, AQL can query as well modify the data, and thus complex queries can be created by combining both the processes. Please note that AQL is entirely ACID-compliant. Reading or modifying queries will either conclude in whole or not at all. Even reading a document”s data will finish with a consistent unit of the data. We add two new songs to the songs collection we have already created. Instead of typing, you can copy the following query, and paste it in the AQL editor − FOR song IN [ { title: “Air-Minded Executive”, lyricist: “Johnny Mercer”, composer: “Bernie Hanighen”, Year: 1940, _key: “Air-Minded” }, { title: “All Mucked Up”, lyricist: “Johnny Mercer”, composer: “Andre Previn”, Year: 1974, _key: “All_Mucked” } ] INSERT song IN songs Press the Execute button at the lower left. It will write two new documents in the songs collection. This query describes how the FOR loop works in AQL; it iterates over the list of JSON encoded documents, performing the coded operations on each one of the documents in the collection. The different operations can be creating new structures, filtering, selecting documents, modifying, or inserting documents into the database (refer the instantaneous example). In essence, AQL can perform the CRUD operations efficiently. To find all the songs in our database, let us once again run the following query, equivalent to a SELECT * FROM songs of an SQL-type database (because the editor memorizes the last query, press the *New* button to clean the editor) − FOR song IN songs RETURN song The result set will show the list of songs so far saved in the songs collection as shown in the screenshot below. Operations like FILTER, SORT and LIMIT can be added to the For loop body to narrow and order the result. FOR song IN songs FILTER song.Year > 1940 RETURN song The above query will give songs created after the year 1940 in the Result tab (see the image below). The document key is used in this example, but any other attribute can also be used as an equivalent for filtering. Since the document key is guaranteed to be unique, no more than a single document will match this filter. For other attributes this may not be the case. To return a subset of active users (determined by an attribute called status), sorted by name in ascending order, we use the following syntax − FOR song IN songs FILTER song.Year > 1940 SORT song.composer RETURN song LIMIT 2 We have deliberately included this example. Here, we observe a query syntax error message highlighted in red by AQL. This syntax highlights the errors and is helpful in debugging your queries as shown in the screenshot below. Let us now run the correct query (note the correction) − FOR song IN songs FILTER song.Year > 1940 SORT song.composer LIMIT 2 RETURN song Complex Query in AQL AQL is equipped with multiple functions for all supported data types. Variable assignment within a query allows to build very complex nested constructs. This way data-intensive operations move closer to the data at the backend than on to the client (such as browser). To understand this, let us first add the arbitrary durations (length) to songs. Let us start with the first function, i.e., the Update function − UPDATE { _key: “All_Mucked” } WITH { length: 180 } IN songs We can see one document has been written as shown in the above screenshot. Let us now update other documents (songs) too. UPDATE { _key: “Affable_Balding” } WITH { length: 200 } IN songs We can now check that all our songs have a new attribute length − FOR song IN songs RETURN song Output [ { “_key”: “Air-Minded”, “_id”: “songs/Air-Minded”, “_rev”: “_VkC5lbS—“, “title”: “Air-Minded Executive”, “lyricist”: “Johnny Mercer”, “composer”: “Bernie Hanighen”, “Year”: 1940, “length”: 210 }, { “_key”: “Affable_Balding”, “_id”: “songs/Affable_Balding”, “_rev”: “_VkC4eM2—“, “title”: “Affable Balding Me”, “lyricist”: “Johnny Mercer”, “composer”: “Robert Emmett Dolan”, “Year”: 1950, “length”: 200 }, { “_key”: “All_Mucked”, “_id”: “songs/All_Mucked”, “_rev”: “_Vjah9Pu—“, “title”: “All Mucked Up”, “lyricist”: “Johnny Mercer”, “composer”: “Andre Previn”, “Year”: 1974, “length”: 180 }, { “_key”: “Accentchuate_The”, “_id”: “songs/Accentchuate_The”, “_rev”: “_VkC3WzW—“, “title”: “Accentchuate The Politics”, “lyricist”: “Johnny Mercer”, “composer”: “Harold Arlen”, “Year”: 1944, “length”: 190 } ] To illustrate the use of other keywords of AQL such as LET, FILTER, SORT, etc., we now format the song”s durations in the mm:ss format. Query FOR song IN songs FILTER song.length > 150 LET seconds = song.length % 60 LET minutes = FLOOR(song.length / 60) SORT song.composer RETURN { Title: song.title, Composer: song.composer, Duration: CONCAT_SEPARATOR(”:”,minutes, seconds) } This time we will return the song title together with the duration. The Return function lets you create a new JSON object to return for each input document. We will now talk about the ‘Joins’ feature of AQL database. Let us begin by creating

ArangoDB – Web Interface

ArangoDB – Web Interface ”; Previous Next In this chapter, we will learn how to enable/disable the Authentication, and how to bind the ArangoDB to the Public Network Interface. # arangosh –server.endpoint tcp://127.0.0.1:8529 –server.database “_system” It will prompt you for the password saved earlier − Please specify a password: Use the password you created for root, at the configuration. You can also use curl to check that you are actually getting HTTP 401 (Unauthorized) server responses for requests that require authentication − # curl –dump – http://127.0.0.1:8529/_api/version Output HTTP/1.1 401 Unauthorized X-Content-Type-Options: nosniff Www-Authenticate: Bearer token_type = “JWT”, realm = “ArangoDB” Server: ArangoDB Connection: Keep-Alive Content-Type: text/plain; charset = utf-8 Content-Length: 0 To avoid entering the password each time during our learning process, we will disable the authentication. For that, open the configuration file − # vim /etc/arangodb3/arangod.conf You should change the color scheme if the code is not properly visible. :colorscheme desert Set authentication to false as shown in the screenshot below. Restart the service − # service arangodb3 restart On making the authentication false, you will be able to login (either with root or created user like Harry in this case) without entering any password in please specify a password. Let us check the api version when the authentication is switched off − # curl –dump – http://127.0.0.1:8529/_api/version Output HTTP/1.1 200 OK X-Content-Type-Options: nosniff Server: ArangoDB Connection: Keep-Alive Content-Type: application/json; charset=utf-8 Content-Length: 60 {“server”:”arango”,”version”:”3.1.27″,”license”:”community”} Print Page Previous Next Advertisements ”;

ArangoDB – System Requirements

ArangoDB – System Requirements ”; Previous Next In this chapter, we will discuss the system requirements for ArangoDB. The system requirements for ArangoDB are as follows − A VPS Server with Ubuntu Installation RAM: 1 GB; CPU : 2.2 GHz For all the commands in this tutorial, we have used an instance of Ubuntu 16.04 (xenial) of RAM 1GB with one cpu having a processing power 2.2 GHz. And all the arangosh commands in this tutorial were tested for the ArangoDB version 3.1.27. How to Install ArangoDB? In this section, we will see how to install ArangoDB. ArangoDB comes pre-built for many operating systems and distributions. For more details, please refer to the ArangoDB documentation. As already mentioned, for this tutorial we will use Ubuntu 16.04×64. The first step is to download the public key for its repositories − # wget https://www.arangodb.com/repositories/arangodb31/ xUbuntu_16.04/Release.key Output –2017-09-03 12:13:24– https://www.arangodb.com/repositories/arangodb31/xUbuntu_16.04/Release.key Resolving https://www.arangodb.com/ (www.arangodb.com)… 104.25.1 64.21, 104.25.165.21, 2400:cb00:2048:1::6819:a415, … Connecting to https://www.arangodb.com/ (www.arangodb.com)|104.25. 164.21|:443… connected. HTTP request sent, awaiting response… 200 OK Length: 3924 (3.8K) [application/pgpkeys] Saving to: ‘Release.key’ Release.key 100%[===================>] 3.83K – .-KB/s in 0.001s 2017-09-03 12:13:25 (2.61 MB/s) – ‘Release.key’ saved [39 24/3924] The important point is that you should see the Release.key saved at the end of the output. Let us install the saved key using the following line of code − # sudo apt-key add Release.key Output OK Run the following commands to add the apt repository and update the index − # sudo apt-add-repository ”deb https://www.arangodb.com/repositories/arangodb31/xUbuntu_16.04/ /” # sudo apt-get update As a final step, we can install ArangoDB − # sudo apt-get install arangodb3 Output Reading package lists… Done Building dependency tree Reading state information… Done The following package was automatically installed and is no longer required: grub-pc-bin Use ”sudo apt autoremove” to remove it. The following NEW packages will be installed: arangodb3 0 upgraded, 1 newly installed, 0 to remove and 17 not upgraded. Need to get 55.6 MB of archives. After this operation, 343 MB of additional disk space will be used. Press Enter. Now the process of installing ArangoDB will start − Get:1 https://www.arangodb.com/repositories/arangodb31/xUbuntu_16.04 arangodb3 3.1.27 [55.6 MB] Fetched 55.6 MB in 59s (942 kB/s) Preconfiguring packages … Selecting previously unselected package arangodb3. (Reading database … 54209 files and directories currently installed.) Preparing to unpack …/arangodb3_3.1.27_amd64.deb … Unpacking arangodb3 (3.1.27) … Processing triggers for systemd (229-4ubuntu19) … Processing triggers for ureadahead (0.100.0-19) … Processing triggers for man-db (2.7.5-1) … Setting up arangodb3 (3.1.27) … Database files are up-to-date. When the installation of ArangoDB is about to complete, the following screen appears − Here, you will be asked to provide a password for the ArangoDB root user. Note it down carefully. Select the yes option when the following dialog box appears − When you click Yes as in the above dialog box, the following dialog box appears. Click Yes here. You can also check the status of ArangoDB with the following command − # sudo systemctl status arangodb3 Output arangodb3.service – LSB: arangodb Loaded: loaded (/etc/init.d/arangodb3; bad; vendor pre set: enabled) Active: active (running) since Mon 2017-09-04 05:42:35 UTC; 4min 46s ago Docs: man:systemd-sysv-generator(8) Process: 2642 ExecStart=/etc/init.d/arangodb3 start (code = exited, status = 0/SUC Tasks: 22 Memory: 158.6M CPU: 3.117s CGroup: /system.slice/arangodb3.service ├─2689 /usr/sbin/arangod –uid arangodb –gid arangodb –pid-file /va └─2690 /usr/sbin/arangod –uid arangodb –gid arangodb –pid-file /va Sep 04 05:42:33 ubuntu-512 systemd[1]: Starting LSB: arangodb… Sep 04 05:42:33 ubuntu-512 arangodb3[2642]: * Starting arango database server a Sep 04 05:42:35 ubuntu-512 arangodb3[2642]: {startup} starting up in daemon mode Sep 04 05:42:35 ubuntu-512 arangodb3[2642]: changed working directory for child Sep 04 05:42:35 ubuntu-512 arangodb3[2642]: …done. Sep 04 05:42:35 ubuntu-512 systemd[1]: StartedLSB: arang odb. Sep 04 05:46:59 ubuntu-512 systemd[1]: Started LSB: arangodb. lines 1-19/19 (END) ArangoDB is now ready to be used. To invoke the arangosh terminal, type the following command in the terminal − # arangosh Output Please specify a password: Supply the root password created at the time of installation − _ __ _ _ __ __ _ _ __ __ _ ___ | | / | ”__/ _ | ’ / ` |/ _ / | ’ | (| | | | (| | | | | (| | () _ | | | _,|| _,|| ||_, |_/|/| || |__/ arangosh (ArangoDB 3.1.27 [linux] 64bit, using VPack 0.1.30, ICU 54.1, V8 5.0.71.39, OpenSSL 1.0.2g 1 Mar 2016) Copyright (c) ArangoDB GmbH Pretty printing values. Connected to ArangoDB ”http+tcp://127.0.0.1:8529” version: 3.1.27 [server], database: ”_system”, username: ”root” Please note that a new minor version ”3.2.2” is available Type ”tutorial” for a tutorial or ”help” to see common examples 127.0.0.1:8529@_system> exit To log out from ArangoDB, type the following command − 127.0.0.1:8529@_system> exit Output Uf wiederluege! Na shledanou! Auf Wiedersehen! Bye Bye! Adiau! ¡Hasta luego! Εις το επανιδείν! להתראות ! Arrivederci! Tot ziens! Adjö! Au revoir! さようなら До свидания! Até Breve! !خداحافظ Print Page Previous Next Advertisements ”;

ArangoDB – Quick Guide

ArangoDB – Quick Guide ”; Previous Next ArangoDB – A Multi-Model First Database ArangoDB is hailed as a native multi-model database by its developers. This is unlike other NoSQL databases. In this database, the data can be stored as documents, key/value pairs or graphs. And with a single declarative query language, any or all of your data can be accessed. Moreover, different models can be combined in a single query. And, owing to its multi-model style, one can make lean applications, which will be scalable horizontally with any or all of the three data models. Layered vs. Native Multi-Model Databases In this section, we will highlight a crucial difference between native and layered multimodel databases. Many database vendors call their product “multi-model,” but adding a graph layer to a key/value or document store does not qualify as native multi-model. With ArangoDB, the same core with the same query language, one can club together different data models and features in a single query, as we have already stated in previous section. In ArangoDB, there is no “switching” between data models, and there is no shifting of data from A to B to execute queries. It leads to performance advantages to ArangoDB in comparison to the “layered” approaches. The Need for Multimodal Database Interpreting the [Fowler’s] basic idea leads us to realize the benefits of using a variety of appropriate data models for different parts of the persistence layer, the layer being part of the larger software architecture. According to this, one might, for example, use a relational database to persist structured, tabular data; a document store for unstructured, object-like data; a key/value store for a hash table; and a graph database for highly linked referential data. However, traditional implementation of this approach will lead one to use multiple databases in the same project. It can lead to some operational friction (more complicated deployment, more frequent upgrades) as well as data consistency and duplication issues. The next challenge after unifying the data for the three data models, is to devise and implement a common query language that can allow data administrators to express a variety of queries, such as document queries, key/value lookups, graphy queries, and arbitrary combinations of these. By graphy queries, we mean queries involving graph-theoretic considerations. In particular, these may involve the particular connectivity features coming from the edges. For example, ShortestPath, GraphTraversal, and Neighbors. Graphs are a perfect fit as data model for relations. In many real-world cases such as social network, recommendor system, etc., a very natural data model is a graph. It captures relations and can hold label information with each edge and with each vertex. Further, JSON documents are a natural fit to store this type of vertex and edge data. ArangoDB ─ Features There are various notable features of ArangoDB. We will highlight the prominent features below − Multi-model Paradigm ACID Properties HTTP API ArangoDB supports all popular database models. Following are a few models supported by ArangoDB − Document model Key/Value model Graph model A single query language is enough to retrieve data out of the database The four properties Atomicity, Consistency, Isolation, and Durability (ACID) describe the guarantees of database transactions. ArangoDB supports ACID-compliant transactions. ArangoDB allows clients, such as browsers, to interact with the database with HTTP API, the API being resource-oriented and extendable with JavaScript. ArangoDB – Advantages Following are the advantages of using ArangoDB − Consolidation As a native multi-model database, ArangoDB eliminates the need to deploy multiple databases, and thus decreases the number of components and their maintenance. Consequently, it reduces the technology-stack complexity for the application. In addition to consolidating your overall technical needs, this simplification leads to lower total cost of ownership and increasing flexibility. Simplified Performance Scaling With applications growing over time, ArangoDB can tackle growing performance and storage needs, by independently scaling with different data models. As ArangoDB can scale both vertically and horizontally, so in case when your performance demands a decrease (a deliberate, desired slow-down), your back-end system can be easily scaled down to save on hardware as well as operational costs. Reduced Operational Complexity The decree of Polyglot Persistence is to employ the best tools for every job you undertake. Certain tasks need a document database, while others may need a graph database. As a result of working with single-model databases, it can lead to multiple operational challenges. Integrating single-model databases is a difficult job in itself. But the biggest challenge is building a large cohesive structure with data consistency and fault tolerance between separate, unrelated database systems. It may prove nearly impossible. Polyglot Persistence can be handled with a native multi-model database, as it allows to have polyglot data easily, but at the same time with data consistency on a fault tolerant system. With ArangoDB, we can use the correct data model for the complex job. Strong Data Consistency If one uses multiple single-model databases, data consistency can become an issue. These databases aren’t designed to communicate with each other, therefore some form of transaction functionality needs to be implemented to keep your data consistent between different models. Supporting ACID transactions, ArangoDB manages your different data models with a single back-end, providing strong consistency on a single instance, and atomic operations when operating in cluster mode. Fault Tolerance It is a challenge to build fault tolerant systems with many unrelated components. This challenge becomes more complex when working with clusters. Expertise is required to deploy and maintain such systems, using different technologies and/or technology stacks. Moreover, integrating multiple subsystems, designed to run independently, inflict large engineering and operational costs. As a consolidated technology stack, multi-model database presents an elegant solution. Designed to enable modern, modular architectures with different data models, ArangoDB works for cluster usage as well. Lower Total Cost of Ownership Each database technology requires ongoing maintenance, bug fixing patches, and other code changes which are provided by the vendor. Embracing a multi-model database significantly reduces the related maintenance costs simply by eliminating the number

Data Models & Modeling

ArangoDB – Data Models and Modeling ”; Previous Next In this chapter, we will focus on the following topics − Database Interaction Data Model Data Retrieval ArangoDB supports document based data model as well as graph based data model. Let us first describe the document based data model. ArangoDB”s documents closely resemble the JSON format. Zero or more attributes are contained in a document, and a value attached with each attribute. A value is either of an atomic type, such as a number, Boolean or null, literal string, or of a compound data type, such as embedded document/object or an array. Arrays or sub-objects may consist of these data types, which implies that a single document can represent non-trivial data structures. Further in hierarchy, documents are arranged into collections, which may contain no documents (in theory) or more than one document. One can compare documents to rows and collections to tables (Here tables and rows refer to those of relational database management systems – RDBMS). But, in RDBMS, defining columns is a prerequisite to store records into a table, calling these definitions schemas. However, as a novel feature, ArangoDB is schema-less – there is no a priori reason to specify what attributes the document will have. And unlike RDBMS, each document can be structured in a completely different way from another document. These documents can be saved together in one single collection. Practically, common characteristics may exist among documents in the collection, however the database system, i.e., ArangoDB itself, does not bind you to a particular data structure. Now we will try to understand ArangoDB”s [graph data model], which requires two kinds of collections — the first is the document collections (known as vertices collections in group-theoretic language), the second is the edge collections. There is a subtle difference between these two types. Edge collections also store documents, but they are characterized by including two unique attributes, _from and _to for creating relations between documents. In practice, a document (read edge) links two documents (read vertices), both stored in their respective collections. This architecture is derived from the graph-theoretic concept of a labeled, directed graph, excluding edges that can have not only labels, but can be a complete JSON like document in itself. To compute fresh data, delete documents or to manipulate them, queries are used, which select or filter documents as per the given criteria. Either being simple as an “example query” or being as complex as “joins”, queries are coded in AQL – ArangoDB Query Language. Print Page Previous Next Advertisements ”;

ArangoDB – Crud Operations

ArangoDB – Crud Operations ”; Previous Next In this chapter, we will learn the different operations with Arangosh. The following are the possible operations with Arangosh − Creating a Document Collection Creating Documents Reading Documents Updating Documents Let us start by creating a new database. We will use the following line of code to create a new database − 127.0.0.1:8529@_system> db._createDatabase(“song_collection”) true The following line of code will help you shift to the new database − 127.0.0.1:8529@_system> db._useDatabase(“song_collection”) true Prompt will shift to “@@song_collection” 127.0.0.1:8529@song_collection> From here we will study CRUD Operations. Let us create a collection into the new database − 127.0.0.1:8529@song_collection> db._createDocumentCollection(”songs”) Output [ArangoCollection 4890, “songs” (type document, status loaded)] 127.0.0.1:8529@song_collection> Let us add a few documents (JSON objects) to our ”songs” collection. We add the first document in the following way − 127.0.0.1:8529@song_collection> db.songs.save({title: “A Man”s Best Friend”, lyricist: “Johnny Mercer”, composer: “Johnny Mercer”, Year: 1950, _key: “A_Man”}) Output { “_id” : “songs/A_Man”, “_key” : “A_Man”, “_rev” : “_VjVClbW—” } Let us add other documents to the database. This will help us learn the process of querying the data. You can copy these codes and paste the same in Arangosh to emulate the process − 127.0.0.1:8529@song_collection> db.songs.save( { title: “Accentchuate The Politics”, lyricist: “Johnny Mercer”, composer: “Harold Arlen”, Year: 1944, _key: “Accentchuate_The” } ) { “_id” : “songs/Accentchuate_The”, “_key” : “Accentchuate_The”, “_rev” : “_VjVDnzO—” } 127.0.0.1:8529@song_collection> db.songs.save( { title: “Affable Balding Me”, lyricist: “Johnny Mercer”, composer: “Robert Emmett Dolan”, Year: 1950, _key: “Affable_Balding” } ) { “_id” : “songs/Affable_Balding”, “_key” : “Affable_Balding”, “_rev” : “_VjVEFMm—” } How to Read Documents The _key or the document handle can be used to retrieve a document. Use document handle if there is no need to traverse the collection itself. If you have a collection, the document function is easy to use − 127.0.0.1:8529@song_collection> db.songs.document(“A_Man”); { “_key” : “A_Man”, “_id” : “songs/A_Man”, “_rev” : “_VjVClbW—“, “title” : “A Man”s Best Friend”, “lyricist” : “Johnny Mercer”, “composer” : “Johnny Mercer”, “Year” : 1950 } How to Update Documents Two options are available to update the saved data − replace and update. The update function patches a document, merging it with the given attributes. On the other hand, the replace function will replace the previous document with a new one. The replacement will still occur even if completely different attributes are provided. We will first observe a non-destructive update, updating the attribute Production` in a song − 127.0.0.1:8529@song_collection> db.songs.update(“songs/A_Man”,{production: “Top Banana”}); Output { “_id” : “songs/A_Man”, “_key” : “A_Man”, “_rev” : “_VjVOcqe—“, “_oldRev” : “_VjVClbW—” } Let us now read the updated song”s attributes − 127.0.0.1:8529@song_collection> db.songs.document(”A_Man”); Output { “_key” : “A_Man”, “_id” : “songs/A_Man”, “_rev” : “_VjVOcqe—“, “title” : “A Man”s Best Friend”, “lyricist” : “Johnny Mercer”, “composer” : “Johnny Mercer”, “Year” : 1950, “production” : “Top Banana” } A large document can be easily updated with the update function, especially when the attributes are very few. In contrast, the replace function will abolish your data on using it with the same document. 127.0.0.1:8529@song_collection> db.songs.replace(“songs/A_Man”,{production: “Top Banana”}); Let us now check the song we have just updated with the following line of code − 127.0.0.1:8529@song_collection> db.songs.document(”A_Man”); Output { “_key” : “A_Man”, “_id” : “songs/A_Man”, “_rev” : “_VjVRhOq—“, “production” : “Top Banana” } Now, you can observe that the document no longer has the original data. How to Remove Documents The remove function is used in combination with the document handle to remove a document from a collection − 127.0.0.1:8529@song_collection> db.songs.remove(”A_Man”); Let us now check the song”s attributes we just removed by using the following line of code − 127.0.0.1:8529@song_collection> db.songs.document(”A_Man”); We will get an exception error like the following as an output − JavaScript exception in file ”/usr/share/arangodb3/js/client/modules/@arangodb/arangosh.js” at 97,7: ArangoError 1202: document not found ! throw error; ! ^ stacktrace: ArangoError: document not found at Object.exports.checkRequestResult (/usr/share/arangodb3/js/client/modules/@arangodb/arangosh.js:95:21) at ArangoCollection.document (/usr/share/arangodb3/js/client/modules/@arangodb/arango-collection.js:667:12) at <shell command>:1:10 Print Page Previous Next Advertisements ”;