In this talk, we will present and discuss the motivation behind the provision of the openCypher artefacts, all of which are publicly available for consumption. We will describe the components of the grammar specification and our Technology Compatibility Kit (TCK).
In this presentation we will describe SAP HANA Graph, a core component of the SAP HANA database. Specifically, we discuss the major design decisions that drove the integration of native graph processing capabilities and describe how we integrated a language subset of openCypher into SAP HANA. We conclude with a list of observations that we made during the development process when integrating openCypher into an existing database management system.
In this talk we will take a look on "Graph Database support" plugin for JetBrains IDEs, in particular Cypher support that this plugin offers. We will explore what functionality it provides and how it can be used by developers to make them more efficient when dealing with Cypher.
How can we evaluate a global query on huge graphs in 0.1 seconds? Given our current technology, that would be magic. The lack of wizarding skills did not stop us, however, from tackling the problem by using smart caching structures, which are witchcrafts on their own.
Why is this challenge important? Several applications evaluate global queries on continuously changing graphs: fraud detection in financial transactions, analysis of source code repositories and validating engineering models. Current approaches employ domain-specific optimizations, which are difficult and error-prone to implement. Meanwhile, the requirements of these (and similar) use cases could be uniformly addressed by incremental graph query evaluation. With this technique, the first execution of the queries takes some time, but once the result are calculated, they can be efficiently maintained for each change in the graph.
To allow incremental queries on property graphs, we implemented the ingraph engine, based on the openCypher language specification. We aim to support the standard subset of openCypher, as most standard constructs can be calculated incrementally. We already mapped some of the standard constructs to relational algebra, defined incremental relational algebraic operators and implemented them in an incremental relational engine using Akka actors.
We start the talk by presenting use cases that evaluate complex global queries on continuously changing graphs and discuss the idea of incremental graph queries. We show the mapping of basic openCypher constructs (e.g. MATCH, WHERE, WITH, RETURN) to relational operators, such as joins, selections and projections. Finally, we show our approach for optimizing incremental graph queries and outline related challenges.
The first and most widely-used version of Cypher is the version that is currently implemented in Neo4j. After a brief history of Cypher, we will present our current implementation of Cypher as it appears in Neo4j. We will discuss the full life cycle of a Cypher query, from the initial parsing of the query string through to the execution of the physical query plan. We define relevant concepts, such as iterative dynamic programming, and describe how we use these techniques within our implementation. The talk concludes with an outlook on next steps for further improving the implementation of Cypher in Neo4j.
Redis-Graph is a graph database built on top of Redis. In this talk we will review from top to bottom an implementation of a graph database, dig a bit inside its internals and touch on key decisions made as the project developed.
QUIL is an ongoing effort for creating a platform-agnostic intermediary representation for Cypher. The goal of QUIL is to provide a compact representation for a Cypher query for analysis and executing by different vendors. We would like to discuss the motivation for QUIL, our current approach, open questions, and gather general feedback around the idea.
Dgraph is an open source, scalable, distributed, highly available and fast graph database, designed from ground up to be run in production. In this talk we present our goals, main design concepts, current status of the project and benchmark results. We also discuss implementation decisions and introduce the GraphQL+- query language.
A number of companies and groups have considered how to integrate SQL and Cypher. The simple composition model used by Bitnine in their Agens Graph product is of interest. GraphQL is a widely-used tool for expressing queries and for defining returned data documents, but it is not a fully-featured graph querying language: it will be interesting to see how GraphQL can be integrated with Cypher. Jason Crawford at IBM's System G project has recently raised the idea of implementing Cypher over Tinkerpop, an idea which has also been floated by the Apache Tinkerpop project. This session is an opportunity to talk about these kinds of language integrations in a round table discussion.
Accessing multiple property graphs within the same query provides many promising new approaches for graph data management, graph analytics, and graph modelling.
Graph pattern matching is one of the most interesting and challenging operations in graph analytics. However, it is primarily supported by graph database systems such as Neo4j but, besides research prototypes, not generally available for distributed (not-only graph) processing frameworks like Apache Flink or Apache Spark.
In our talk, we want to give an overview of our current implementation of Cypher on Apache Flink. Cypher is the Neo4j graph query language and enables the intuitive definition of graph patterns including structural and semantic predicates. As the Neo4j graph data model is not supported out-of-the box by Apache Flink, we leverage Gradoop, a Flink-based graph analytics framework based on Apache Flink that already provides an abstraction of schema-free property graphs.
We will give a brief overview about the technologies used to implement Cypher, explain our query engine and give a demonstration of the available language features. Finally, we will discuss open challenges and missing features hopefully motivating people to contribute.
The project is a cooperation between the University of Leipzig and Neo Technology.
In this talk we present an outlook on a future world of multiple graph processing and show how applications may benefit from the techniques enabled by accessing multiple, globally-addressable property graphs, including parameterized views, logical graphs, and data graphs. The talk discusses these topics in the context of how the Cypher graph query language may be evolved over time to support querying multiple property graphs end-to-end in OLTP as well as in OLAP scenarios.
In this talk, we we discuss ongoing work on Graph Views in Cypher.
Schemas and constraints are an integral part of any database management system. In this talk, we will present our view on this topic, and provide details on current and future work in this area.
Subqueries are a well-known and useful adjunct in querying, and in this talk we will discuss how we envisage incorporating existential, nested, and scalar subqueries into Cypher, along with projections and comprehensions.
Cypher's pattern matching semantics is based on relationship-isomorphic matching. While this has proven to be a good, pragmatic choice for real-world applications, it also limits language expressivity for no strong reason. This short talk presents a recent proposal for lifting this restriction by introducing a new set of uniqueness modes to pattern matching as well as accompanying path predicate functions.
Conjuctive Regular Path Queries (CRPQs) lie at the heart of complex graph pattern matching, and research into this area has been ongoing for decades. In this talk, we present our ideas for their incorporation into Cypher.
The SQL standard has been around for more than three decades, but we still do not fully understand what to expect when executing an SQL query on a relational DBMS. This is mostly due to vagueness of the standard and the ambiguity of the natural language it is expressed in. In this talk, I will discuss recent efforts in providing a formal semantics for a core fragment of the SQL language that captures the behavior of real DBMSs, and the lessons we learned from this exercise. I will also introduce the newly started, ongoing collaboration between Neo Technologies and the University of Edinburgh in providing a similar formal semantics for Cypher, the challenges it poses and expected outcomes.
In this talk, we will provide working details on the Technology Compatability Kit (TCK), an artefact that we provide as part of openCypher. We will discuss the purpose, benefits, and limitations of the TCK, and walk through an example.
In SQL's long history, there have been a number of undesirable outcomes, such as different meanings for the same query, alternative ways of implementing the same construct, and difficulty in evolving the language whilst remaining backwards-compatible. *These are situations we seek to* avoid in Cypher, and in this talk, we discuss various ways of extending Cypher along with a motivating example, as well as language profiles and ideas around versioning the language.
The evolution of Cypher is driven by the production and acceptance of Cypher Improvement Proposals (CIPs), which are documents outlining the syntax and semantics of proposed new Cypher features. In this talk, we will provide details of how we envisage the Cypher Improvement Proposal (CIP) process to work going forwards.