Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Doc - Training material links (#6683)

This commit is contained in:
Simran 2018-10-17 23:52:35 +02:00 committed by sleto-it
parent ff06f449db
commit c83d74e384
18 changed files with 178 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Documentation/Books/AQL/ExecutionAndPerformance/Optimizer.md
View File

@ -135,7 +135,7 @@ Here is the meaning of these rules in context of this query:
* `use-indexes`: use an index to iterate over a collection instead of performing a
full collection scan. In the example case this makes sense, as the index can be
used for filtering and sorting.
* `remove-filter-covered-by-index`: remove an unnessary filter whose functionality
* `remove-filter-covered-by-index`: remove an unnecessary filter whose functionality
is already covered by an index. In this case the index only returns documents
matching the filter.
* `use-index-for-sort`: removes a `SORT` operation if it is already satisfied by

4
Documentation/Books/AQL/ExecutionAndPerformance/README.md
View File

@ -16,3 +16,7 @@ parts of the plan are responsible. The query-profiler can show you execution sta
stage of the query execution.
* [The AQL query result cache](QueryCache.md): an optional query results cache can be used to avoid repeated calculation of the same query results.
Be sure to check out the
[ArangoDB Performance Course](https://www.arangodb.com/arangodb-performance-course/)
for freshers as well.

2
Documentation/Books/AQL/Fundamentals/README.md
View File

@ -10,3 +10,5 @@ AQL Fundamentals
* [Query Results](QueryResults.md): the result of an AQL query is an array of values.
* [Query Errors](QueryErrors.md): errors may arise from the AQL parsing or execution.
Learn more about optimizing your queries by going through the
[Performance Course](https://www.arangodb.com/arangodb-performance-course/).

7
Documentation/Books/AQL/Tutorial/Traversal.md
View File

@ -124,7 +124,7 @@ INSERT { _from: "Characters/robb", _to: "Characters/ned" } INTO ChildOf
```
However, creating the edges programmatically based on character names is a
good excercise. Breakdown of the query:
good exercise. Breakdown of the query:
- Assign the relations in form of an array of objects with a *parent* and
a *child* attribute each, both with sub-attributes *name* and *surname*,
@ -273,6 +273,11 @@ to return each value only once. Keep in mind though, that there are
[traversal options](../Graphs/Traversals.md#syntax) to suppress duplicate
vertices early on.
Also check out the
[ArangoDB Graph Course](https://www.arangodb.com/arangodb-graph-course)
which covers the basics, but also explains different traversal options
and advanced graph queries.
Traverse with variable depth
----------------------------

6
Documentation/Books/AQL/Views/README.md
View File

@ -30,4 +30,8 @@ Views can be defined and administered on a per view-type basis via
the [web interface](../../Manual/Programs/WebInterface/index.html).
Currently there is a single supported view implementation, namely
`arangosearch` as described in [ArangoSearch View](ArangoSearch/README.md).
`arangosearch` as described in [ArangoSearch View](ArangoSearch/README.md).
Also see the detailed
[ArangoSearch tutorial](https://www.arangodb.com/tutorials/arangosearch/)
to learn more.

8
Documentation/Books/Manual/Administration/Cluster/README.md
View File

@ -6,7 +6,11 @@ This _Section_ includes information related to the administration of an ArangoDB
For a general introduction to the ArangoDB Cluster, please refer to the
Cluster [chapter](../../Architecture/DeploymentModes/Cluster/README.md).
Please also check the following talks:
There is also a detailed
[Cluster Administration Course](https://www.arangodb.com/arangodb-cluster-course/)
for download.
Please check the following talks as well:
| # | Date | Title | Who | Link |
|---|-----------------|-----------------------------------------------------------------------------|-----------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------|
@ -19,7 +23,7 @@ Enabling synchronous replication
For an introduction about _Synchronous Replication_ in Cluster, please refer
to the [_Cluster Architecture_](../../Architecture/DeploymentModes/Cluster/Architecture.md#synchronous-replication) section.
Synchronous replication can be enabled per _collection_. When creating a
_collection_ you may specify the number of _replicas_ using the
*replicationFactor* parameter. The default value is set to `1` which

4
Documentation/Books/Manual/Architecture/DeploymentModes/Cluster/README.md
View File

@ -14,3 +14,7 @@ For further information about the Cluster, please refer to the following section
- [Cluster Deployment](../../../Deployment/Cluster/README.md)
- [Cluster Administration](../../../Administration/Cluster/README.md)
- [Cluster Troubleshooting](../../../Troubleshooting/Cluster/README.md)
Be sure to check out the
[ArangoDB Cluster Administration Course](https://www.arangodb.com/arangodb-cluster-course/)
as well.

9
Documentation/Books/Manual/DataModeling/GraphsVerticesEdges.md
View File

@ -3,9 +3,8 @@ Graphs, Vertices & Edges
Graphs, vertices & edges are defined in the [Graphs](../Graphs/README.md) chapter in details.
Related blog posts:
Related blog posts and learning material:
- [Graphs in data modeling - is the emperor naked?](
https://medium.com/@neunhoef/graphs-in-data-modeling-is-the-emperor-naked-2e65e2744413#.x0a5z66ji)
- [Index Free Adjacency or Hybrid Indexes for Graph Databases](
https://www.arangodb.com/2016/04/index-free-adjacency-hybrid-indexes-graph-databases/)
- [Graphs in data modeling - is the emperor naked?](https://medium.com/@neunhoef/graphs-in-data-modeling-is-the-emperor-naked-2e65e2744413#.x0a5z66ji)
- [Index Free Adjacency or Hybrid Indexes for Graph Databases](https://www.arangodb.com/2016/04/index-free-adjacency-hybrid-indexes-graph-databases/)
- [ArangoDB Performance Course](https://www.arangodb.com/arangodb-performance-course/)

10
Documentation/Books/Manual/Deployment/Cluster/README.md
View File

@ -3,10 +3,16 @@ Cluster Deployment
This _Chapter_ describes how to deploy an _ArangoDB Cluster_.
For a general introduction to the _ArangoDB Cluster_, please refer to the [Cluster](../../Architecture/DeploymentModes/Cluster/README.md) chapter.
For a general introduction to the _ArangoDB Cluster_, please refer to the
[Cluster](../../Architecture/DeploymentModes/Cluster/README.md) chapter.
- [Preliminary Information](PreliminaryInformation.md)
- [Using the ArangoDB Starter](UsingTheStarter.md)
- [Manual Start](ManualStart.md)
- [Kubernetes](Kubernetes.md)
- [Mesos, DC/OS](Mesos.md)
- [Mesos, DC/OS](Mesos.md)
Go through the detailed
[ArangoDB Cluster Administration Course](https://www.arangodb.com/arangodb-cluster-course/)
to dig deeper into maintenance, resilience and troubleshooting of your
distributed environment.

4
Documentation/Books/Manual/Graphs/GeneralGraphs/README.md
View File

@ -6,7 +6,9 @@ It allows you to define a graph that is spread across several edge and document
This allows you to structure your models in line with your domain and group them logically in collections giving you the power to query them in the same graph queries.
There is no need to include the referenced collections within the query, this module will handle it for you.
New to ArangoDB? Take [Free ArangoDB Graph course](https://www.arangodb.com/arangodb-graph-course) for freshers.
New to ArangoDB? Take the free
[ArangoDB Graph Course](https://www.arangodb.com/arangodb-graph-course)
for freshers.
Three Steps to create a graph
-----------------------------

176
Documentation/Books/Manual/Graphs/Pregel/README.md
View File

@ -2,13 +2,18 @@ Distributed Iterative Graph Processing (Pregel)
===============================================
Distributed graph processing enables you to do online analytical processing
directly on graphs stored into arangodb. This is intended to help you gain analytical insights
on your data, without having to use external processing sytems. Examples of algorithms
directly on graphs stored into ArangoDB. This is intended to help you gain analytical insights
on your data, without having to use external processing systems. Examples of algorithms
to execute are PageRank, Vertex Centrality, Vertex Closeness, Connected Components, Community Detection.
This system is not useful for typical online queries, where you just do work on a small set of vertices.
These kind of tasks are better suited for AQL.
The processing system inside ArangoDB is based on: [Pregel: A System for Large-Scale Graph Processing](http://www.dcs.bbk.ac.uk/~dell/teaching/cc/paper/sigmod10/p135-malewicz.pdf) – Malewicz et al. (Google) 2010
Check out the hands-on
[ArangoDB Pregel Tutorial](https://www.arangodb.com/pregel-community-detection/)
to learn more.
The processing system inside ArangoDB is based on:
[Pregel: A System for Large-Scale Graph Processing](http://www.dcs.bbk.ac.uk/~dell/teaching/cc/paper/sigmod10/p135-malewicz.pdf) – Malewicz et al. (Google), 2010.
This concept enables us to perform distributed graph processing, without the need for distributed global locking.
Prerequisites
@ -26,7 +31,7 @@ ensure correct results. For more information see the next section.
To enable iterative graph processing for your data, you will need to ensure
that your vertex and edge collections are sharded in a specific way.
The pregel computing model requires all edges to be present on the DB Server where
The Pregel computing model requires all edges to be present on the DB Server where
the vertex document identified by the `_from` value is located.
This means the vertex collections need to be sharded by '_key' and the edge collection
will need to be sharded after an attribute which always contains the '_key' of the vertex.
@ -36,6 +41,7 @@ additionally you will need to specify the key `distributeShardsLike` and an **eq
Only if these requirements are met can ArangoDB place the edges and vertices correctly.
For example you might create your collections like this:
```javascript
// Create main vertex collection:
db._create("vertices", {
@ -58,18 +64,18 @@ db._createEdgeCollection("edges", {
```
You will need to ensure that edge documents contain the proper values in their sharding attribute.
For a vertex document with the following content ```{_key:"A", value:0}```
For a vertex document with the following content `{ _key: "A", value: 0 }`
the corresponding edge documents would have look like this:
```
{"_from":"vertices/A", "_to": "vertices/B", vertex:"A"}
{"_from":"vertices/A", "_to": "vertices/C", vertex:"A"}
{"_from":"vertices/A", "_to": "vertices/D", vertex:"A"}
...
```js
{ "_from":"vertices/A", "_to": "vertices/B", "vertex": "A" }
{ "_from":"vertices/A", "_to": "vertices/C", "vertex": "A" }
{ "_from":"vertices/A", "_to": "vertices/D", "vertex": "A" }
...
```
This will ensure that outgoing edge documents will be placed on the same DBServer as the vertex.
Without the correct placement of the edges, the pregel graph processing system will not work correctly, because
Without the correct placement of the edges, the Pregel graph processing system will not work correctly, because
edges will not load correctly.
Arangosh API
@ -77,7 +83,7 @@ Arangosh API
### Starting an Algorithm Execution
The pregel API is accessible through the `@arangodb/pregel` package.
The Pregel API is accessible through the `@arangodb/pregel` package.
To start an execution you need to specify the **algorithm** name and the vertex and edge collections.
Alternatively you can specify a named graph. Additionally you can specify custom parameters which
vary for each algorithm.
@ -85,31 +91,31 @@ The `start` method will always a unique ID which can be used to interact with th
The below version of the `start` method can be used for named graphs:
```javascript
var pregel = require("@arangodb/pregel");
var params = {};
var execution = pregel.start("<algorithm>", "<yourgraph>", params);
var pregel = require("@arangodb/pregel");
var params = {};
var execution = pregel.start("<algorithm>", "<yourgraph>", params);
```
Params needs to be an object, the valid keys are mentioned below in the section [Algorithms]()
`params` needs to be an object, the valid keys are mentioned below in the section
[Available Algorithms](#available-algorithms)
Alternatively you might want to specify the vertex and edge collections directly. The call-syntax of the `start``
Alternatively you might want to specify the vertex and edge collections directly. The call-syntax of the `start`
method changes in this case. The second argument must be an object with the keys `vertexCollections`and `edgeCollections`.
```javascript
var pregel = require("@arangodb/pregel");
var params = {};
var execution = pregel.start("<algorithm>", {vertexCollections:["vertices"], edgeCollections:["edges"]}, {});
var pregel = require("@arangodb/pregel");
var params = {};
var execution = pregel.start("<algorithm>", {vertexCollections:["vertices"], edgeCollections:["edges"]}, {});
```
The last argument is still the parameter object. See below for a list of algorithms and parameters.
### Status of an Algorithm Execution
The code returned by the `pregel.start(...)` method can be used to
track the status of your algorithm.
```javascript
var execution = pregel.start("sssp", "demograph", {source: "vertices/V"});
var status = pregel.status(execution);
var execution = pregel.start("sssp", "demograph", {source: "vertices/V"});
var status = pregel.status(execution);
```
The result will tell you the current status of the algorithm execution.
@ -120,36 +126,35 @@ Valid values for the `state` field include:
- "running" algorithm is still running
- "done": The execution is done, the result might not be written back into the collection yet.
- "canceled": The execution was permanently canceled, either by the user or by an error.
- "in error": The exeuction is in an error state. This can be caused by primary DBServers being not reachable or being non responsive.
The execution might recover later, or switch to "canceled" if it was not able to recover successfuly
- "in error": The execution is in an error state. This can be caused by primary DBServers being not reachable or being non responsive.
The execution might recover later, or switch to "canceled" if it was not able to recover successfully
- "recovering": The execution is actively recovering, will switch back to "running" if the recovery was successful
The object returned by the `status` method might for example look something like this:
```javascript
{
"state" : "running",
"gss" : 12,
"totalRuntime" : 123.23,
"aggregators" : {
"converged" : false,
"max" : true,
"phase" : 2
},
"sendCount" : 3240364978,
"receivedCount" : 3240364975
}
{
"state" : "running",
"gss" : 12,
"totalRuntime" : 123.23,
"aggregators" : {
"converged" : false,
"max" : true,
"phase" : 2
},
"sendCount" : 3240364978,
"receivedCount" : 3240364975
}
```
### Canceling an Execution / Discarding results
To cancel an execution which is still runnning, and discard any intermediare results you can use the `cancel` method.
This will immediatly free all memory taken up by the execution, and will make you lose all intermediary data.
To cancel an execution which is still running, and discard any intermediate results you can use the `cancel` method.
This will immediately free all memory taken up by the execution, and will make you lose all intermediary data.
You might get inconsistent results if you cancel an execution while it is already in it's `done` state. The data is written
multi-threaded into all collection shards at once, this means there are multiple transactions simultaniously. A transaction might
already be commited when you cancel the execution job, therefore you might see the result in your collection. This does not apply
multi-threaded into all collection shards at once, this means there are multiple transactions simultaneously. A transaction might
already be committed when you cancel the execution job, therefore you might see the result in your collection. This does not apply
if you configured the execution to not write data into the collection.
```javascript
@ -161,26 +166,29 @@ pregel.cancel(execution);
AQL integration
---------------
ArangoDB supports retrieving temporary pregel results through the ArangoDB query language (AQL).
ArangoDB supports retrieving temporary Pregel results through the ArangoDB query language (AQL).
When our graph processing subsystem finishes executing an algorithm, the result can either be written back into the
database or kept in memory. In both cases the result can be queried via AQL. If the data was not written to the database
store it is only held temporarily, until the user calls the `cancel` methodFor example a user might want to query
only nodes with the most rank from the result set of a PageRank execution.
FOR v IN PREGEL_RESULT(<handle>)
FILTER v.value >= 0.01
RETURN v._key
```js
FOR v IN PREGEL_RESULT(<handle>)
FILTER v.value >= 0.01
RETURN v._key
```
Available Algorithms
--------------------
There are a number of general parameters which apply to almost all algorithms:
* `store`: Is per default *true*, the pregel engine will write results back to the database.
if the value is *false* then you can query the results via AQLk, see AQL integration.
* `store`: Is per default *true*, the Pregel engine will write results back to the database.
If the value is *false* then you can query the results via AQL,
see [AQL integration](#aql-integration).
* `maxGSS`: Maximum number of global iterations for this algorithm
* `parallelism`: Number of parellel threads to use per worker. Does not influence the number of threads used to load
or store data from the database (this depends on the number of shards).
* `async`: Algorithms wich support async mode, will run without synchronized global iterations,
* `parallelism`: Number of parallel threads to use per worker. Does not influence the number of threads used to load
or store data from the database (this depends on the number of shards).
* `async`: Algorithms which support async mode, will run without synchronized global iterations,
might lead to performance increases if you have load imbalances.
* `resultField`: Most algorithms will write the result into this field
@ -213,11 +221,10 @@ Calculates the distance of each vertex to a certain shortest path. The algorithm
the iterations are bound by the diameter (the longest shortest path) of your graph.
```javascript
var pregel = require("@arangodb/pregel");
pregel.start("sssp", "graphname", {source:"vertices/1337"})
var pregel = require("@arangodb/pregel");
pregel.start("sssp", "graphname", {source:"vertices/1337"})
```
### Connected Components
There are two algorithms to find connected components in a graph. To find weakly connected components (WCC)
@ -225,24 +232,25 @@ you can use the algorithm named "connectedcomponents", to find strongly connecte
named "scc". Both algorithm will assign a component ID to each vertex.
A weakly connected components means that there exist a path from every vertex pair in that component.
WCC is a very simple and fast algorithm, which will only work correctly on undirected graphs. Your results on directed graphs may vary, depending on how connected your components are.
WCC is a very simple and fast algorithm, which will only work correctly on undirected graphs.
Your results on directed graphs may vary, depending on how connected your components are.
In the case of SCC a component means every vertex is reachable from any other vertex in the same component. The algorithm is more complex than the WCC algorithm and requires more RAM, because each vertex needs to store much more state.
In the case of SCC a component means every vertex is reachable from any other vertex in the same component.
The algorithm is more complex than the WCC algorithm and requires more RAM, because each vertex needs to store much more state.
Consider using WCC if you think your data may be suitable for it.
```javascript
var pregel = require("@arangodb/pregel");
// weakly connected components
pregel.start("connectedcomponents", "graphname")
// strongly connected components
pregel.start("scc", "graphname")
var pregel = require("@arangodb/pregel");
// weakly connected components
pregel.start("connectedcomponents", "graphname")
// strongly connected components
pregel.start("scc", "graphname")
```
### Hyperlink-Induced Topic Search (HITS)
HITS is a link analysis algorithm that rates Web pages, developed by Jon Kleinberg (The algorithm is also known as hubs and authorities).
The idea behind Hubs and Authorities comes from the typical structure of the web: Certain websites known as hubs, serve as large directories that are not actually
authoritative on the information that they hold. These hubs are used as compilations of a broad catalog of information that leads users direct to other authoritative webpages.
The algorithm assigns each vertex two scores: The authority-score and the hub-score. The authority score rates how many good hubs point to a particular
@ -251,14 +259,13 @@ vertex (or webpage), the hub score rates how good (authoritative) the vertices p
Our version of the algorithm
converges after a certain amount of time. The parameter *threshold* can be used to set a limit for the convergence (measured as maximum absolute difference of the hub and
authority scores between the current and last iteration)
When you specify the result field name, the hub score will be stored in "<result field>_hub" and the authority score in
"<result field>_auth".
When you specify the result field name, the hub score will be stored in `<result field>_hub` and the authority score in
`<result field>_auth`.
The algorithm can be executed like this:
```javascript
var pregel = require("@arangodb/pregel");
var handle = pregel.start("hits", "yourgraph", {threshold:0.00001, resultField: "score"});
var pregel = require("@arangodb/pregel");
var handle = pregel.start("hits", "yourgraph", {threshold:0.00001, resultField: "score"});
```
### Vertex Centrality
@ -269,10 +276,8 @@ There are various definitions for centrality, the simplest one being the vertex
These definitions were not designed with scalability in mind. It is probably impossible to discover an efficient algorithm which computes them in a distributed way.
Fortunately there are scalable substitutions available, which should be equally usable for most use cases.
![Illustration of an execution of different centrality measures (Freeman 1977)](centrality_visual.png)
#### Effective Closeness
A common definitions of centrality is the **closeness centrality** (or closeness).
@ -292,8 +297,8 @@ This should work well on large graphs and on smaller ones as well. The memory re
algorithm. The algorithm can be used like this
```javascript
const pregel = require("@arangodb/pregel");
const handle = pregel.start("effectivecloseness", "yourgraph", {resultField: "closeness"});
const pregel = require("@arangodb/pregel");
const handle = pregel.start("effectivecloseness", "yourgraph", {resultField: "closeness"});
```
#### LineRank
@ -309,17 +314,16 @@ number of paths also passing through a vertex *v*. By intuition a vertex with hi
passing through it.
**LineRank** approximates the random walk betweenness of every vertex in a graph. This is the probability that someone starting on
an arbitary vertex, will visit this node when he randomly chooses edges to visit.
The algoruthm essentially builds a line graph out of your graph (switches the vertices and edges), and then computes a score similar to PageRank.
an arbitrary vertex, will visit this node when he randomly chooses edges to visit.
The algorithm essentially builds a line graph out of your graph (switches the vertices and edges), and then computes a score similar to PageRank.
This can be considered a scalable equivalent to vertex betweeness, which can be executed distributedly in ArangoDB.
The algorithm is from the paper *Centralities in Large Networks: Algorithms and Observations (U Kang et.al. 2011)*
```javascript
const pregel = require("@arangodb/pregel");
const handle = pregel.start("linerank", "yourgraph", {"resultField": "rank"});
const pregel = require("@arangodb/pregel");
const handle = pregel.start("linerank", "yourgraph", {"resultField": "rank"});
```
### Community Detection
Graphs based on real world networks often have a community structure. This means it is possible to find groups of vertices such that each each vertex group is internally more densely connected than outside the group.
@ -329,8 +333,8 @@ Social networks include community groups (the origin of the term, in fact) based
#### Label Propagation
*Label Propagation* can be used to implement community detection on large graphs. The idea is that each
vertex should be in the community that most of his neighbours are in. We iteratively detemine this by first
assigning random Community ID's. Then each itertation, a vertex will send it's current community ID to all his neighbor vertices.
vertex should be in the community that most of his neighbors are in. We iteratively determine this by first
assigning random Community ID's. Then each iteration, a vertex will send it's current community ID to all his neighbor vertices.
Then each vertex adopts the community ID he received most frequently during the iteration.
The algorithm runs until it converges,
@ -339,14 +343,14 @@ The default bound is 500 iterations, which is likely too large for your applicat
Should work best on undirected graphs, results on directed graphs might vary depending on the density of your graph.
```javascript
const pregel = require("@arangodb/pregel");
const handle = pregel.start("labelpropagation", "yourgraph", {maxGSS:100, resultField: "community"});
const pregel = require("@arangodb/pregel");
const handle = pregel.start("labelpropagation", "yourgraph", {maxGSS:100, resultField: "community"});
```
#### Speaker-Listener Label Propagation
The [Speaker-listener Label Propagation](https://arxiv.org/pdf/1109.5720.pdf) (SLPA) can be used to implement community detection. It works similar to the label propagation algorithm,
The [Speaker-listener Label Propagation](https://arxiv.org/pdf/1109.5720.pdf) (SLPA) can be used to implement community detection.
It works similar to the label propagation algorithm,
but now every node additionally accumulates a memory of observed labels (instead of forgetting all but one label).
Before the algorithm run, every vertex is initialized with an unique ID (the initial community label).
@ -354,7 +358,7 @@ During the run three steps are executed for each vertex:
1. Current vertex is the listener all other vertices are speakers
2. Each speaker sends out a label from memory, we send out a random label with a probability
proportional to the number of times the vertex observed the label
proportional to the number of times the vertex observed the label
3. The listener remembers one of the labels, we always choose the most frequently observed label
```javascript
@ -362,7 +366,7 @@ const pregel = require("@arangodb/pregel");
const handle = pregel.start("slpa", "yourgraph", {maxGSS:100, resultField: "community"});
```
You can also execute SLPA with the `maxCommunities` parameter to limit the number of ouput communities.
You can also execute SLPA with the `maxCommunities` parameter to limit the number of output communities.
Internally the algorithm will still keep the memory of all labels, but the output is reduced to just he `n` most frequently
observed labels.
@ -372,5 +376,3 @@ const handle = pregel.start("slpa", "yourgraph", {maxGSS:100, resultField:"commu
// check the status periodically for completion
pregel.status(handle);
```

4
Documentation/Books/Manual/Graphs/SmartGraphs/README.md
View File

@ -18,6 +18,10 @@ The optimizer is clever enough to identify if we are on a SmartGraph or not.
The difference is only in the management section: creating and modifying the underlying collections of the graph.
For a detailed API reference please refer to [SmartGraph Management](../SmartGraphs/Management.md).
Do the hands-on
[ArangoDB SmartGraphs Tutorial](https://www.arangodb.com/using-smartgraphs-arangodb/)
to learn more.
What makes a graph smart?
-------------------------

7
Documentation/Books/Manual/Graphs/Traversals/README.md
View File

@ -6,8 +6,8 @@ Very simple operations can be composed with the low-level edge methods *edges*,
[edge collections](../Edges/README.md). These work on named and anonymous graphs. For more complex operations,
ArangoDB provides predefined traversal objects.
Also Traversals have been added to AQL.
Please read the [chapter about AQL traversersals](../../../AQL/Graphs/Traversals.html) before you continue reading here.
Traversals have also been added to AQL.
Please read the [chapter about AQL traversals](../../../AQL/Graphs/Traversals.html) before you continue reading here.
Most of the traversal cases are covered by AQL and will be executed in an optimized way.
Only if the logic for your is too complex to be defined using AQL filters you can use the traversal object defined
here which gives you complete programmatic access to the data.
@ -15,6 +15,9 @@ here which gives you complete programmatic access to the data.
For any of the following examples, we'll be using the example collections *v* and *e*,
populated with continents, countries and capitals data listed below (see [Example Data](ExampleData.md)).
To learn more about graphs in ArangoDB take the free
[ArangoDB Graph Course](https://www.arangodb.com/arangodb-graph-course).
Starting from Scratch
---------------------

3
Documentation/Books/Manual/Indexing/IndexBasics.md
View File

@ -11,6 +11,9 @@ can be created by specifying the names of the index attributes.
Some index types allow indexing just one attribute (e.g. fulltext index) whereas
other index types allow indexing multiple attributes at the same time.
Learn how to use different indexes efficiently by going through the
[ArangoDB Performance Course](https://www.arangodb.com/arangodb-performance-course/).
The system attributes `_id`, `_key`, `_from` and `_to` are automatically indexed
by ArangoDB, without the user being required to create extra indexes for them.
`_id` and `_key` are covered by a collection's primary key, and `_from` and `_to`

3
Documentation/Books/Manual/Indexing/WorkingWithIndexes.md
View File

@ -1,6 +1,9 @@
Working with Indexes
====================
Learn how to use different indexes efficiently by going through the
[ArangoDB Performance Course](https://www.arangodb.com/arangodb-performance-course/).
Index Identifiers and Handles
-----------------------------

41
Documentation/Books/Manual/Troubleshooting/Cluster/README.md
View File

@ -2,24 +2,27 @@ Cluster Troubleshooting
=======================
* Cluster frontend is unresponsive
* Check if the _Coordinator_/s in question are started up.
* Check if the _Agency_ is up and a _leader_ has been elected. If not
ensure that all or a majority of _Agents_ are up and running.
* Check if all processes have been started up with the same
`JWT_SECRET`. If not ensure that the `JWT_SECRET` used across
the cluster nodes is ideantical for every process.
* Check if all cluster nodes have been started with SSL either
dis- or enabled. If not decide what mode of operation you would
like to run your cluster in, and consistently stick with for all
_Agents_, _Coordinators_ and _DBServers_.
* Check if network communication between the cluster nodes is such
that all processes can directly access their peers. Do not
operate proxies between the cluster nodes.
* Check if the _Coordinator_/s in question are started up.
* Check if the _Agency_ is up and a _leader_ has been elected. If not
ensure that all or a majority of _Agents_ are up and running.
* Check if all processes have been started up with the same
`JWT_SECRET`. If not ensure that the `JWT_SECRET` used across
the cluster nodes is identical for every process.
* Check if all cluster nodes have been started with SSL either
dis- or enabled. If not decide what mode of operation you would
like to run your cluster in, and consistently stick with for all
_Agents_, _Coordinators_ and _DBServers_.
* Check if network communication between the cluster nodes is such
that all processes can directly access their peers. Do not
operate proxies between the cluster nodes.
* Cluster front end announces errors on any number of nodes
* This is an indication that the _Agency_ is running but either
_Coordinators_ or _DBServers_ are disconnected or shut
down. Establish network connection to or start the according
nodes.
* Make sure that the nodes in question share the same `JWT_SECRET`
and SSL operation mode with the functioning nodes.
* This is an indication that the _Agency_ is running but either
_Coordinators_ or _DBServers_ are disconnected or shut
down. Establish network connection to or start the according
nodes.
* Make sure that the nodes in question share the same `JWT_SECRET`
and SSL operation mode with the functioning nodes.
Dig deeper into cluster troubleshooting by going through the
[ArangoDB Cluster Administration Course](https://www.arangodb.com/arangodb-cluster-course/).

11
Documentation/Books/Manual/Tutorials/README.md
View File

@ -6,6 +6,9 @@ Tutorials
- [AQL](../../AQL/Tutorial/index.html):
Introduction to ArangoDB's query language AQL
- [Performance Course](https://www.arangodb.com/arangodb-performance-course/):
Performance Optimization Basics: How to make your queries faster
- [Geo Queries](https://www.arangodb.com/using-arangodb-geo-index-cursor-via-aql/):
How to use the ArangoDB Geo Index Cursor via AQL
@ -15,9 +18,9 @@ Tutorials
- [ArangoSearch](https://www.arangodb.com/tutorials/arangosearch/):
The implementation of ArangoDB's view engine
Deployment
----------
Deployment & Administration
---------------------------
- [ArangoDB Starter](Starter/README.md):
Starting an ArangoDB Cluster or database the easy way
@ -34,6 +37,8 @@ Deployment
- [Monitor ArangoDB](https://www.arangodb.com/tutorials/monitoring-collectd-prometheus-grafana/):
Set up a monitoring system for ArangoDB using _collectd_, _Prometheus_ and _Grafana_
- [Cluster Administration Course](https://www.arangodb.com/arangodb-cluster-course/):
Concepts, maintenance, resilience and troubleshooting
Graphs
------

2
Documentation/Books/Manual/Views/ArangoSearch/DetailedOverview.md
View File

@ -157,7 +157,7 @@ of removing unused segments after release of internal resources.
i.e. the candidate segment's valid document count is less than the average
segment's total document count multiplied by the `{threshold}`.
- **tier**: Consolidate based on segment byte size and live document count
as dicated by the customization attributes.
as dictated by the customization attributes.
## Link properties