Version 1.0 (Feb 15, 2018)
Arcade Analytics is a graph visualization tool that enables users to have more control over their data. Arcade sits on top of the user’s database and allows the user to query data and show it in a graph. Arcade currently integrates with all major graph and relational databases. Our connectors allow users to visually see relationships and connections within their datasets in our dashboard. Within Arcade’s dashboard, users have a variety of customization options to assist the user in finding meaningful connections and relationships. Users can change the size, color, background image, and layout of nodes, or they can filter the visualization to only see certain sections of their data. Once users have found a meaningful connection, the graph can be exported so the user can share their analysis with others.
To access the Arcade Demo click on this link. The Demo allows users to test all of the visualization tools Arcade has to offer in a limited and pre-determined environment. Users can access multiple databases and use Arcade to see this data visually. The Demo is read only and limited to 300 nodes per query and 5,000 nodes total.
Upon subscription to Arcade Analytics, users will receive an email with information on how to access their account. A welcome email will include your new username and temporary password. Make sure to change your account password through the account settings tab once you login.
If you need login assistance please contact us at firstname.lastname@example.org
How to integrate with your database
Users can configure connections to their database in the Arcade Dashboard selecting the Datasource menu.
Once selected the menu, the list of configured data-sources is showed:
Click on the create a new Data Source button to create a new entry
- name: give the data source a name of your choice
- description(optional): a meaningful description
- type: select the type of database
- if the RDBMS type is selected, select the database
- server: server name or IP address
- port: the ports (e.g.: 5432 for Postgres)
- database: the name of the database
- username and password: credentials to access your DB
- Use ssh tunnel: if the database isn’t exposed on the internet, select this flag
- gateway: IP address or the name of the ssh gateway
- ssh user: user name to be used to create the tunnel (default: player)
- ssh port: usually 22
To enable connection through ssh tunnelling:
- Download our public key
- whitelist on your firewall our IP: 188.8.131.52
- add the key to the authorized_keys file for the given ssh user configured, so add it to /home/<sshUser>/.ssh/authorized_keys
Arcade Analytics allows you to connect to relational databases through a specific RDBMS connector, which allows you to perform graph analyses over your Relational Database.
You can integrate Arcade with all major relational databases: at the moment it is compatible and fully-tested with Oracle, Microsoft SQLServer, MySQL, PostgreSQL and HyperSQL*.
Connections and data within your RDBMS are treated as a graph through a model mapping between the source data model, the Entity-Relationship Model, and the target data model, the Graph Model.
Once a coherent and effective model mapping is performed, you can query your source dataset and play with it as if it was a graph:
- each record is transformed in a correspondent vertex.
- each connection between two records, inferred through a relationship between two tables and computed through a join operation, generates an edge.
The ER model is built starting from the source DB schema: each table, known also as Entity, and each Relationship in the DB is inferred from these metadata. Because of this, if you didn’t define constraints, such as foreign keys between the tables on which you usually perform join operations, you will lose this kind of information during the querying process. If foreign keys are missing, you will not have any edges in your final Graph Model, and you will not able to traverse any relationship.
This automated mapping strategy adopts a basic approach: the source DB schema is directly translated as follows:
- each Entity in the source DB is converted into a Vertex Type.
- each Relationship between two Entities in the source DB is converted into an Edge Type (remember, relationships in your source DB schema are represented by the foreign keys).
All the records of each table are handled according to the following schemas-mapping: each pair of records on which it’s possible to perform a join operation will correspond to a pair of vertices connected by an edge of a specific Edge Type.
Example: 1-N Relationship
The Film and Language source tables are translated in two correspondent Vertex Types; the properties contained in the Film and Language Vertex Types directly come from the columns belonging to the two source tables.
The logical relationship between the two tables generates the HasLanguage Edge Type.
Source data and relationships will be retrieved and visualized as shown below.
Example: N-N Relationship
In RDBMSs N-N Relationships are expressed through join tables. In the sample schema below you can see how the N-N relationship between actors and movies is modelled through the join table Film_Actor.
As you can see, the central join table is translated in a specific Vertex Type allowing you to traverse the N-N relationship between actors and movies.
Then, starting from the following tables:
We will obtain the following graph:
Now we can say that traversing N-N relationships is equivalent to traverse two 1-N relationships, like in the relational world:
- 1-N relationship between Film and Film_Actor
- 1-N relationship between Film_Actor and Film
The Graph Model is more expressive than the ER Model. In the Graph Model N-N Relationship don’t need redundant structures like the join tables used in the SQL world, instead you just have edges. For this reason Arcade offers the capability to aggregate some redundant information in order to obtain a simpler and more efficient model.
This makes it possible to choose a specific mapping strategy that performs aggregation on join tables of dimension equals to 2, that is to say those tables which map two tables together by referencing the primary keys of each data table through a foreign key. The join tables of dimension greater than 2 are ignored by the aggregation algorithm. This process allows each candidate join table to be converted into an appropriate edge, and each field not involved in any relationship with other tables (hence not involved in any foreign key in the source DB schema) is aggregated in the properties of the new built edge.
Referring to the scenario in the last example, even if the new DB does not reflect the original DB schema, the aggregation leads to a great saving in terms of resources and avoids a substantial overhead. The OrientDB schema after the aggregation process comes out simpler, hence also the analysis is easier.
Let’s examine the same N-N relationship reported in the previous example. Here the join table is not translated into a Vertex Type, but rather into an Edge Type. The last_update column, the only one not involved in any relationship, becomes a field in the resulting “aggregator edge”.
By starting from the previous scenario, but this time using the aggregate function, we will get cleaner and simpler results.
This time we will obtain a less complex graph:
A simpler graph means better performance: to navigate the relationship between films and actors we will not need two jumps, but just one.
How to aggregate aggregate join tables of your source database
In order to aggregate all the join tables in your source database you simply have to flag the specific option in the Datasource options.
In this way all the widgets connected to this specific Datasource will come out with an aggregated model that will be reflected during the analysis.
Let’s focus on the N-N relationship between actors and movies: starting from a specific actor we will be able to expand all the related movies by traversing just one relationship, called with the same name of the original aggregated join table, in this case film_actor.
Arcade Features and source RDBMS meaning
In Arcade you can enjoy all the features offered for graph databases while using a relational database.
Below is a list of some useful features for you to review:
You have three main ways to interact with your source dataset:
- Text Search (https://arcadeanalytics.com/usermanual/#search): search your target data through a text search bar.
When you load one or more items a correspondent query is performed against the source relational database according to the external keys mapping. This allows eventual indices to be used which makes retrieving records and building vertices very fast.
- Type Query (https://arcadeanalytics.com/usermanual/#search):
Just scan queries are allowed. Let’s suppose we want to fetch the first 100 items from the actor table, then we have to type:
select * from actor limit 100
You can add also some conditions by using the where statement, but don’t get crazy with join operations, this kind of queries are not allowed and it is much simpler to use the traverse tool to traverse your relationships.
select * from actor where actor.first_name=Ben
- Traverse (https://arcadeanalytics.com/usermanual/#traverse): you can expand all the available relationships starting from one or more nodes with just one click.
In this example we want to get the language of a specific movie. Selecting the outgoing has_language edge type on the left we will expand the relationship. This operation corresponds to a join operation between the film and the language tables.
Here is the result of the traverse, we will obtain a new language node and an edge connecting the two vertices.
We can fetch some other movies having English as language simply by selecting the new vertex and clicking the ingoing has_language edge.
Below is the result:
From this point you can continue to explore your data and customize it to your needs.
*All company names and logos used on this website are for identification purposes only and do not imply endorsement.
The dashboard shows all of the datasets the user is currently visualizing. Each dataset is shown as a widget that can be edited, moved around, and deleted. The user can add as many widgets as their subscription plan allows.
Users also have access to a text widget which can be used to make notes about specific datasets.
Users can access their media library through the Arcade Dashboard. Users can choose from a number of pre-uploaded images for node customization, or they can upload an image using the media library.
Each account will have an admin user who will have control over the account settings. From account settings on the dashboard, the admin can manage their personal information and login details.
From the dashboard, admin users can manage all other users from the administration tab. From here the admin can view or edit user details. Admin users can also create or delete user accounts from this page. The number of users allowed depends on the subscription plan associated with the account.
The user can visualize their data through the Arcade interface. The data will be shown on the right and the toolbar is shown on the left. The toolbar can expand and collapse for convenience.
Arcade has a number of shortcuts designed to assist users in visualizing their data.
Users can right click on a specific node or edge and view a pop up window that shows common functions, including: view selected node/edge properties, delete or hide selected node/edge, and traverse selected node.
Click + Drag
By clicking on the dashboard, users can move the entire visualization within the dashboard.
Ctrl + Click and Drag
This command allows the user to select multiple nodes and edges at once. Once elements have been selected they can be traversed, moved, or deleted.
Text Search Bar
Users have the ability to search their database with a text search bar. The first 10 results are returned for the user.
Arcade uses a connector that allows the user’s dataset to be shown visually on the dashboard. The connector used is based off of whichever language is used by the user’s database. Users can use the language of the database (SQL, Cypher, Gremlin, etc.) to make queries and pull data. After data is queried, the data will be shown in a visual graph. The entities will be shown as nodes and the each connection between entities will be shown as edges.
Users can delete nodes and edges by selecting the desired elements and then selecting the delete tool on the toolbar. Be certain of which elements you want to delete because this action cannot be undone.
Users can hide or show specific sections of the visualized data. This allows the user more control over their data.
Users can select and deselect all, or some, of the nodes and edges. Users can also use this tool to find the shortest path between two selected nodes.
Use the traverse tool on the toolbar to see all incoming and outgoing connections of a specific node.
The Graph Element allows the user to see the property information of a selected node. All of the data about a specific entity in the user’s database will be displayed under the properties section.
Users can also edit both the label and size of the nodes from this section. Users can change which identifier is used as the label for the node. Users can also change the font type, size, location, and color.
Users can also change the nodes themselves. The size, color, and background image can all be customized. The background images are stored in the user’s media library. The media library can also be accessed on the menu bar at the top of the screen. Users can use the pre-uploaded images or upload new images to use as the background.
Remember all changes made need to be saved in order for them to be applied and seen on the screen. You can save your changes by clicking on the blue save tab seen at the bottom of the Graph Element tool as seen below.
Users can filter the visualized data based off of which class each data point belongs to. This allows the user to see the data in specific ways.
Layouts can be seen from the Layout section of the toolbar. Each layout has a unique algorithm that allows the user to view the data from different perspectives.
Below is a list of the available layouts and examples of a few of them:
Users can also hide or show the legend and labels and change the spacing between nodes. This allows the nodes and edges to be spread further apart or be closer together.
Users have the ability to export their graph as a PNG, JPEG, or JSON file.
Users can save their current visualization by clicking the save icon at the bottom of the toolbar. Arcade does not have an autosave feature, so be sure to save your progress before exiting out of the browser.