vaticle/typedb 1.5.0

Grakn Core 1.5.0

on GitHub

Install & Run: http://dev.grakn.ai/docs/running-grakn/install-and-run

Distribution

• Now officially built, tested and distributed for:

  • Brew: brew install grakn-core (instructions)
  • APT: sudo apt install grakn-core-all (instructions)
  • RPM: sudo yum install grakn-core-all (instructions)
  • Docker: docker pull graknlabs/grakn:1.5.0 (instructions)

• New modular distributions. There are 3 new distributions for Grakn Core, unique for 3 operating systems (Linux, Mac and Windows):

  • grakn-core-console: the much lighter distribution to just run Grakn console from client-side, and avoids the possibility of running Grakn server locally by mistake.
  • grakn-core-server: the distribution containing just the Grakn server, to install on the server-side machine, and avoids having any users starting a console in a server environment.
  • grakn-core-all: the default distribution containing everything
  • Each distribution ends with -linux, -mac, or -windows depending on the OS.

• New/Simplified Grakn binary:./grakn shell script for Unix and ./grakn.bat for Windows, that is an aggregate of 2 previous binaries:

  • ./grakn that previously ran Grakn server daemon, and
  • ./graql that previously ran the console.

  Now ./grakn runs both Grakn server daemon as well as console, and will continue to be one single entry point of interacting with Grakn through the terminal.

Architecture

• Domain-driven module architecture with better package addresses (starts with grakn.core. followed by module name, e.g. grakn.core.concept):
  • api (grakn.core.api): Session and Transaction interfaces that governs both server and client side Sessions and Transactions.
  • bin: binary files (shell and bat scripts) to interact with Grakn Console and/or Server Daemon for Linux/Mac (shell) and Windows (bat).
  • common (grakn.core.common): Commonly used code shared by other modules in the repository.
  • concept (grakn.core.concept): Grakn's object model, i.e. Concept types, that defines the data structure returned by Grakn answers to a Graql query.
  • config: build and distribution configuration files for Grakn Core.
  • console (grakn.core.console): The console application to interact with Grakn from the terminal. The code base has been heavily simplified from the previous version, and the UX has been improved to display better information, such as keyspace name, as well as improved error messages.
  • daemon (grakn.core.daemon): A daemon application to manage the Grakn server as a process in the operating system. An evolution of Grakn Bootup module, after being heavily simplified and made lighter.
  • protocol (grakn.core.protocol): The RPC protocol (using GRPC) for client-server communication between Grakn client drivers and Grakn server.
  • server (grakn.core.server, and grakn.core.graql): The Grakn Core server module, which is still in a temporary shape. It currently still holds a majority of the codebase, but its sub-components like Reasoner and Analytics will soon be split into their own module.
  • test (grakn.core.test): Higher-level test module for assembly and deployment tests of Grakn distributions.
• REST API and Web Dashboard has been completely deleted. Grakn Workbase is now the default end-user GUI application, and the client drivers (such as client-java, client-python, and client-nodejs) are the default way of communicating with Grakn programmatically. This also allowed us to simplify Grakn's architecture significantly and reduce the number of transitive dependencies, while providing much more performant and robust API. You can easily implement a client-driver in most popular languages with GRPC. Just give us a shout if you need any help!
• Graql Migrator (graql migrate) has been deleted. Given the expressivity of client driver APIs, migration systems are now best to be implemented on the client-side where you can have full control of the migration logic.
• Performance Tracing facilities are now natively embedded in the Grakn server to enable performance benchmarking of any running instance of Grakn.

Session, Transaction, and Concept

• Simplified Session and Transaction API, implementation and architecture for both OLTP and OLAP Transactions.
• Improved consistency and performance of server post-processing (attribute deduplicator), which includes:
  • Re-implementing the data structure to be fully in-memory, and therefore removing the use of RocksDB.
  • Fixed the bug with AttributeDeduplicator where it got into a loop of NullPointerException when an attribute is immediately deleted right after being inserted (and still being "deduplicated").
• Session Cache has been removed and Sessions now behave more consistently:
  • Closing a session now correctly removes references to the session object and prohibits users from using it to recreate new transactions.
  • Transactions are now reliably bounded to a thread.
  • Killing a session object will kill all of its transactions.
  • Deleting a keyspace that has opened sessions will kill the session.
  • As an alternative, JanusGraph cache is used by default
• Session RPC protocol introduces two new commands:
  • Session.Open: which takes in a Keyspace as request argument (Session.Open.Req), and returns a session ID as a response (Session.Open.Res).
  • Session.Close: which takes a session ID as request argument (Session.Close.Req).
• Transaction commits are now serialised as they are written to the underlying graph storage layer, which allows us to guarantee stronger concurrency behaviour during WRITE transactions.
• In-memory "graph" transaction has been removed. Given that the client drivers are now the default way of interacting with Grakn, connecting with Grakn through an in-memory graph which embeds Grakn into your runtime environment now becomes an anti-pattern that is no longer supported.
• Concepts are now properly bounded to transactions. I.e. concepts that are created/retrieved within a transaction, are no longer usable after closing the transaction.
• Schema concepts are now cached in the scope of a transaction.
• The Relationship and RelationshipType concept are now called Relation and RelationType, in line with the change in Graql terminology.
• Fixed the bug that prevents naming an attribute value or owner.
• Fixed concept deletion behaviour by skipping inferred concepts, as they don't exist in the database to begin with.

Graql Execution: Read, Write, Analytics and Reasoner

• The uniqueness of keys is now enforced properly. Key validation error messages are also more informative.
• Improved undefining of schema objects. The previously restrictive execution order of the undefine statements has been removed. Undefining attributes now also removes the implicit relation that relates it to the entity.
• Sorting attributes of datatype string are now non-case-sensitive.
• Compute Count now behaves analogously to Aggregate Count.
• Cleaner log output for compute queries.
• Introduced semantic query cache: when we perform a query that has been already cached, or the cache contains a query that is a generalisation of the input query, query answers can be reused. Currently, the lifetime of the query cache is bound to a disjunction - all conjunctions in a disjunction benefit from a common cache. The lifetime of the cache is about to be extended to the transaction in one of the following releases.
• Various improvements in the reasoner's performance and stability:
  • Stronger coupling between query equivalence and unification.
  • More robust (in)equality evaluation of attribute values.
  • More robust equality evaluation of atoms with user-defined variables.
  • More accurate comparison of attributes with multiple predicates.
  • More robust rule applicability evaluation.
  • Better pruning of rules during resolution when:
    • Rules mimick sub behaviour.
    • Mapping of variable pattern exists.
    • Parent rule has an ID mapping for its variable.
  • Fixed some bugs in ResolutionState handling.
  • More robust predicate compatibility checks.
  • Fixed issues with unnecessary propagation of value predicates to rule bodies.
  • more efficient RuleCache - information about fruitless rules is now based on type instance absence and propagated using the rule graph.
  • Improved scaling of reasoning with an increasing number of rules.
  • Fixed the issue where reasoner would only work in WRITE transactions. Now reasoner works as expected in READ transactions.
  • Improved error messages when validation of rule definition fails.
  • Fixed an issue where logging might cause a performance decrease at INFO log level.