typedb/typedb 2.0.0-alpha-2

Grakn Core 2.0.0-alpha-2

on GitHub

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

• Fix console warnings caused by out of date dependency
  Fix WARNING: An illegal reflective access operation has occurred warning caused by an out of date version of protobuf.

• Fix traversal performance caused by not hitting traversal cache
  We fixed a match query performance problem, which was caused by match queries with same structure don't hit traversal cache properly.

• Add RPC method to retrieve all rules
  We added an RPC method to retrieve all rules, allowing clients to list all rules in a database.

• Fix undefiner bugs from BDD
  Repairing the undefine behavioural tests revealed a number of flaws in the undefine process for the core server, which we proceeded to fix. Among these are changes to the behaviour of attempting to unset plays or owns on types that do not play or own anything, which previously was a no-op but now throws, as well as fixes to permit the undefinition of relationships that have roles set on them, and steps for testing rules.

• Keep the protocol version in sync with Grakn Cluster
  The protocol version included in Grakn Core has been kept in sync with what's needed by Grakn Cluster.

• Rewritten Producers to be thread-safe with a clean algorithm
  The first draft of the Async Producer, that came out with 2.0.0-alpha release, was not yet fully thread-safe, which cause plenty of bugs that were all caused by various race conditions. It also caused "thread leaks" that overburdened the CPU to the point of unusable over time. We have now fixed this problem by rewriting the Async Producer to be thread-safe from the start, with an algorithm that is much easier to follow, which allows us to easily improve it in the future.

• Permit override of played roles in Plays constraints
  Specifying the scope of an overridden role is not allowed syntactically when specifying a Plays constraint in graql, and previously, it was not possible to infer a label appropriately for overridden roles. We added, in combination with some changes in graql, the ability to correctly infer the scope of the overridden type, allowing overridden types in definitions.

• Fixed typos, missing articles + added Oxford commas

• Type resolver will not run on schema queries
  When running resolve(), it will not run if the Conjunction is already entirely TypeVariables.
  This fixes a bug where schema look-ups were failing instead of returning empty,

• Fix a bug causing ConcurrentModificationException
  We have fixed a bug which causes ConcurrentModificationException while executing queries with multithreading.

• Ignore failing Graql Define BDD test
  One of our Graql Define BDD scenarios was failing. We temporarily ignored it to allow CI to pass.

• Enable Graql Define tests in CI
  Our Graql Define tests were not being run in CI because some of them were failing. Given it was a relatively small number (8), we decided to ignore the failing tests for now, allowing us to add the passing ones to CI. This helps to guard against regressions.

• In BDD, split Match step into Aggregate, Group etc
  The get answers of graql query step was problematic for Clients Python and NodeJS, because they don't have Graql parsing libraries - meaning they can't reliably figure out which query type the raw String corresponds to (from the feature file) To mitigate the issue, we split the step up into multiple steps: get answers of graql match aggregate, get answers of graql match group... and so on, and implemented the new steps in Grakn Core.

• Do not start new async producer job when not necessary
  We appended a new async producer job even when the iterator has already exhausted, which caused a long tail of producer jobs that does nothing. We fixed this by not shutting down the current producer job whenever we know we need to produce more answers from the current iterator.

• Fixed Referable Class Typo

  • Change name of class from "Referrable" to "Referable"

• Fix stalling when closing transactions in parallel
  Intermittently, clients would stall when attempting to close many transactions in parallel. Transactions were stored in a non-threadsafe collection (a HashSet) on the server, which was being modified concurrently by multiple threads. Sometimes, this caused iteration over the collection to not return all the elements, which meant the missed Transactions would remain open indefinitely, causing the client to stall.
  We changed the server implementation to use a ConcurrentHashMap to remedy the issue.

• Write schema transactions are exclusive
  In order to prevent any read or write operations happening during a schema write transactions, where rule validity and rule indexing may be out of date, we make all data transactions contend with schema sessions, via an established read-write lock. We also add a new read-write lock to only allow 1 schema write transaction at a time, which prevents other schema write or read transactions from opening.

• Fix async producer
  Fix a bug in the async producer, which caused the graph producer to return incorrect number of answers.

• Always use scoped labels in role overrides in BDD
  There was an inconsistency in our Behaviour tests: some referred to overridden role types by their label, others used the scoped label. We unified them to always use the scoped label.

• Migrate Actor library from @graknlabs_common
  We have added //common/concurrent/actor package from graknlabs/common

• Bump year in license headers to 2021
  License headers are currently out of date (2020) for a while. This PR replaces 2020 with 2021 across all the files.

• Fix concurrency bugs in async producer
  The async producers had concurrency bugs which caused multiple match and match-get tests to fail. This PR strengthens the concurrency control by introducing higher level concurrency mechanism, which fixes a few race conditions.

• Bump @graknlabs_console artifact version
  In order to produce correct APT package for grakn-core-all, we should depend on Console artifact that's available in release repo.

• Rule materialisation
  Rule conclusions can be materialised, using the TraversalEngine to perform lookups if a satisfactory conclusion already exists in the DB, otherwise we use a ConceptManager to insert the relevant fact.

• Type resolver implemented directly with traversals
  TypeResolver now creates a Traversal directly. This has reduced the complexity of planning the Traversal execution, allowing us to no longer need a separate "simple type resolver" because the "exhaustive" type resolver is fast enough, even for query lookups. Therefore there is now only resolveLabels() and resolve() that the user of the class can use.

Please refer to full release notes of 2.0.0-alpha to see the changes in 2.0.0.