opencypher/morpheus

Morpheus is a property graph query engine built on Apache Spark that executes Cypher queries against various data sources. It provides a comprehensive pipeline for parsing, logical planning, and relational optimization, supporting graph schemas defined via Graph DDL and data stored in formats like CSV, Parquet, or Neo4j. The system exposes a Scala API for session management, graph cataloging, and result visualization, enabling users to perform complex graph analytics and data integration within a distributed computing environment.

74 changes.

The project was rebranded as Morpheus and migrated from Maven to a multi-module Gradle build system. This period focused on a comprehensive refactoring of the Okapi API, introducing a new type system, schema model, and intermediate representation to support advanced graph operations. It also established the foundational logical and relational query planning layers alongside initial Neo4j I/O capabilities.

17 changes.

This period focused on establishing the Morpheus Spark-based graph processing module, including its core session implementation, data sources, and comprehensive test infrastructure. Concurrently, the Okapi API underwent significant refactoring to standardize terminology from 'Entity' to 'Element' and expand support for temporal data types and duration operations.

The Okapi API now includes built-in support for Apache Zeppelin, allowing users to visualize query results directly in Zeppelin notebooks. Tabular results are rendered using Zeppelin's \%table\ format, while results containing nodes and relationships are visualized as interactive network graphs using the \%network\ format. This enables seamless integration of openCypher queries into Zeppelin-based data analysis workflows.

okapi-api/src/main/scala/org/opencypher/okapi/api/util · high confidence

The okapi-api module now includes a new configuration option, morpheus.printTimings, which allows users to enable the printing of execution times for query processing phases. This feature provides visibility into performance metrics during query execution, aiding in debugging and optimization efforts.

okapi-api/src/main/scala/org/opencypher/okapi/api/configuration · high confidence

A new configuration flag, \ir.explainIr\, has been added to the Okapi IR API. This allows users to enable the printing of the Intermediate Representation (IR) for debugging or inspection purposes.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/api/configuration · high confidence

The Okapi API now includes a custom \Duration\ class and associated helper utilities to support duration-based temporal operations. This change introduces the ability to parse, construct, and compare durations using components such as years, months, weeks, days, hours, minutes, seconds, and nanoseconds. It also provides constants and formatters for handling various date and time string formats, enabling more granular temporal data handling within the openCypher implementation.

okapi-api/src/main/scala/org/opencypher/okapi/impl/temporal · high confidence

The IR parser now recognizes and supports the timestamp, localdatetime, date, and duration functions. These functions are mapped to their respective internal representations, allowing users to utilize these temporal operations in their queries.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/impl/parse/functions · high confidence

The morpheus-jmh module now includes new JMH benchmarks to measure the performance of specific data processing operations. The new ConcatColumnBenchmark compares the speed of Spark's built-in concat\_ws function against the custom MorpheusFunctions.serialize method when combining integer, string, and encoded ID columns. Additionally, the JoinBenchmark evaluates the performance of joining DataFrames using various ID representations, including Long, Array\[Long\], naive String, byte arrays, and efficient byte-array-backed strings, allowing users to identify performance characteristics for different join strategies.

morpheus-jmh · high confidence

A new utility object, VarConverters, has been added to the IR implementation utilities. This provides implicit conversions that allow IRField and PatternElement instances to be seamlessly converted to Var, NodeVar, or RelationshipVar types, as well as converting Scala Symbols to IRField or Var. This simplifies code that needs to bridge between the internal IR representation and variable-based expressions.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/impl/util · high confidence

The \RelationalConverters\ object introduces implicit extension methods (\asRelational\) for \PropertyGraph\ and \CypherRecords\, enabling safe casting to their relational counterparts (\RelationalCypherGraph\ and \RelationalCypherRecords\) using \TypeTag\. This allows users to seamlessly convert standard API graph and record types into the relational implementation types required for further processing within the relational engine.

okapi-relational/src/main/scala/org/opencypher/okapi/relational/impl · high confidence

Introduces the \okapi-neo4j-io\ module, providing the core infrastructure to read from and write to Neo4j databases. This includes \ElementReader\ and \ElementWriter\ for generating Cypher queries to import and export nodes and relationships, \SchemaFromProcedure\ to derive the property graph schema using Neo4j's built-in schema procedures, and \Neo4jConfig\ to manage connection settings and batch sizes for merge and create operations.

okapi-neo4j-io · high confidence

This change introduces the core \morpheus-spark-cypher\ module, providing the \MorpheusSession\ entry point for executing Cypher queries on Spark DataFrames and a suite of \GraphSources\ for reading and writing property graphs. It adds support for file-system-based storage (CSV, Parquet, ORC) with optional Hive integration, Neo4j bulk CSV export, and edge-list imports, while configuring Spark defaults such as enabling cross joins for OPTIONAL MATCH support.

morpheus-spark-cypher · high confidence

The \RecordHeader\ class has been added to the \okapi-relational\ module to centralize the management of column names and their associated Cypher expressions. This component provides methods for looking up columns by expression, identifying variables, and extracting metadata such as labels, relationship types, and properties. It replaces previous ad-hoc header handling, ensuring consistent column name resolution and type alignment across relational operations like joins and unions.

okapi-relational/src/main/scala/org/opencypher/okapi/relational/impl/table · high confidence

The Graph DDL module in the \org.opencypher.graphddl\ package has been introduced, providing a new parser and intermediate representation for defining graph schemas. This change adds support for creating element types, graph types, and graph definitions using a declarative syntax that includes inheritance (EXTENDS or \<:), property mappings, and node/relationship type definitions. The parser validates for duplicate definitions and resolves type hierarchies, enabling users to define complex graph structures with explicit type constraints and mappings to underlying data views.

graph-ddl/src/main · high confidence

The \okapi-ir\ module now includes new utility classes to support internal query processing. \CompilationStage\ and \DirectCompilationStage\ traits define a standardized pipeline for transforming intermediate representations, allowing users to benefit from more structured and reusable compilation logic. Additionally, \FreshVariableNamer\ provides a mechanism for generating unique variable names during query analysis, ensuring that generated identifiers do not conflict with existing ones.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/api/util · high confidence

The IR API in \okapi-ir\ now includes new case classes to represent graph creation and view management operations. \CypherStatement\ defines \CreateGraphStatement\ and \DeleteGraphStatement\ for manipulating graphs, as well as \CreateViewStatement\ and \DeleteViewStatement\ for managing named views. \IRElement\ introduces \IRPatternGraph\ to support pattern-based graph construction with set items and clones, and \IRCatalogGraph\ for cataloged graphs. \QueryModel\ now wraps result blocks with parameters, and \Token\ provides value types for labels, property keys, and relationship types.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/api · high confidence

A new \@experimental\ annotation has been added to the Okapi API, allowing developers to mark methods and classes as experimental. This signals to users that these elements are not subject to semantic versioning and may be changed or removed at any time, helping to distinguish stable public APIs from those still in development.

okapi-api/src/main/scala/org/opencypher/okapi/impl/annotations · high confidence

The \okapi-api\ module introduces a new \CypherValue\ abstraction for representing Cypher data types, including support for \BigDecimal\ and temporal types like \Duration\. This change adds a \toJson\ method to serialize Cypher values (including Nodes, Relationships, and Maps) into JSON structures using the \ujson\ library, and allows users to inject custom conversion rules via the \CypherValueConverter\ trait when creating Cypher values from Scala/Java objects.

okapi-api/src/main/scala/org/opencypher/okapi/api/value · high confidence

The relational module now exposes four new configuration flags in CoraConfiguration to control diagnostic output. Users can enable 'cora.explainRelational' to print the initial relational plan, 'cora.explainOptimizedRelational' to print the optimized physical plan, 'cora.debugPhysical' to print scan operators for debugging, and 'cora.stages' to print query execution stages. All flags are disabled by default.

okapi-relational/src/main/scala/org/opencypher/okapi/relational/api/configuration · high confidence

The examples module now includes comprehensive seed data and schema definitions for three new graph scenarios: a Census dataset (with CSVs for licensed dogs, residents, visitors, and towns, plus DDL and SQL views), a Customer Interactions dataset (with CSVs for interactions and DDL defining policy, customer, and rep relationships), and a Product graph (with CSVs for customers and products, a BOUGHT relationship, and a JSON schema). These resources provide the underlying data structures and graph models required to run the corresponding example applications.

morpheus-examples/src/main · high confidence

Added ExprSyntax to provide implicit extension methods for IR expressions. Users can now check if an expression can be evaluated given a specific set of available variables via the canEvaluate method, or retrieve the set of variables the expression depends on using the dependencies method.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/impl/syntax · high confidence

The \okapi-logical\ module introduces a new logical query planner and optimizer for Cypher queries. This includes a new logical operator tree (with operators like \PatternScan\, \Expand\, \ValueJoin\, and \GraphUnionAll\), a \LogicalPlanner\ that translates IR into this tree, and a \LogicalOptimizer\ that applies rules such as replacing Cartesian products with ValueJoins and optimizing pattern scans. It also adds support for graph unions (\TabularUnionAll\, \GraphUnionAll\) and a configuration flag \morpheus.explain\ to print the logical plan.

okapi-logical · high confidence

This change introduces the core relational graph abstractions for the OKAPI pipeline. It adds the \RelationalCypherGraph\ trait, which defines how relational graphs expose nodes and relationships via scan operators and supports union operations, along with the \RelationalCypherGraphFactory\ for constructing these graphs from element tables. It also introduces \RelationalCypherSession\, a base class that lifts session-level capabilities (parsing, planning, and query execution) into the relational module, and \RelationalPropertyGraphSchema\ to provide schema-aware header generation for nodes and relationships. For users, this establishes the foundational API layer that relational back-ends use to execute Cypher queries and manage graph data within the relational planner.

okapi-relational/src/main/scala/org/opencypher/okapi/relational/api/graph · high confidence

This location introduces a suite of new utility objects to support internal implementation details. JsonUtils provides a custom upickle writer/reader to flatten Option types in JSON output. ParserUtils adds fastparse-based helpers for parsing Cypher identifiers and comments. TablePrinter replaces previous printing mechanisms with a new component that renders data as ASCII-art tables with dynamic column widths and box-drawing characters. StringEncodingUtilities adds methods to encode and decode special characters in property and relationship type names for SQL compatibility. Additional utilities include Measurement for timing code execution, PrintOptions for configurable output streams, ScalaUtils for fold operations, and Version for parsing and comparing semantic version strings.

okapi-api/src/main/scala/org/opencypher/okapi/impl/util · high confidence

The IR now supports SET operations within CONSTRUCT clauses, allowing users to modify node labels and properties during graph construction. This is implemented via new SetItem types (SetLabelItem and SetPropertyItem) that define how variables are updated with specific labels or property values.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/api/set · high confidence

The CypherCatalog now supports storing parameterized views, allowing users to define reusable graph queries with parameters. These views can be listed, dropped, and invoked, with the catalog handling parameter substitution and recursive view evaluation in simple cases. This change introduces a new QGNGenerator trait to support unique graph name generation during view resolution.

okapi-api/src/main/scala/org/opencypher/okapi/impl/graph · high confidence

The relational query planning logic has been reorganized into a new \planning\ package, introducing dedicated components such as \ConstructGraphPlanner\ for handling CONSTRUCT operations, \RelationalOptimizer\ for inserting caching operators to avoid redundant computation, and \VarLengthExpandPlanner\ for managing variable-length pattern expansions. This restructuring consolidates the planning implementation, separating concerns for graph construction, optimization, and complex pattern matching within the relational backend.

okapi-relational/src/main/scala/org/opencypher/okapi/relational/impl/planning · high confidence

The \okapi-api\ module now defines core Cypher type unions (such as \CTNumber\, \CTBoolean\, and \CTElement\) within the \org.opencypher.okapi.api.types\ package object. This change consolidates type definitions that were previously scattered, providing a single, accessible location for these fundamental type constants used across the API.

okapi-api/src/main/scala/org/opencypher/okapi/api · high confidence

The configuration system now supports caching for config options via the new ConfigCaching trait. When a config option mixes in this trait, its value is evaluated lazily and cached upon first access; subsequent attempts to modify the value after it has been read will throw an UnsupportedOperationException, ensuring configuration immutability once accessed.

okapi-api/src/main/scala/org/opencypher/okapi/impl/configuration · high confidence

The Neo4j integration testing setup in the \okapi-neo4j-io-testing\ module now uses Testcontainers to manage the Neo4j server lifecycle instead of the previous Gradle spawn plugin. Tests now spin up a Neo4j 3.4.10 Enterprise container with a fixed admin password, and the test utilities automatically clear all data, constraints, and indexes before each run to ensure isolation. This change also introduces a standard Log4j2 configuration for test logging.

okapi-neo4j-io-testing/src/main · high confidence

The Okapi IR module now includes a dedicated AST rewriting pipeline (OkapiPreparatoryRewriting and OkapiLateRewriting) that transforms parsed Cypher queries into a normalized shape suitable for semantic analysis. This pipeline normalizes RETURN and WITH clauses by ensuring all items are aliased and moving ORDER BY clauses to preceding WITH statements, normalizes CASE expressions into generic forms, pushes label filters into scan patterns to optimize execution, and extracts subqueries from pattern expressions (including EXISTS patterns) into explicit subquery structures.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/impl/parse/rewriter · high confidence

The parsing module in okapi-ir now includes a new CypherParser and BlankBaseContext that integrate with the openCypher v9.0 frontend. This change introduces support for driving table input via the \drivingTableFields\ parameter in the parser's process method, allowing frontend-driven table inputs to be processed during query parsing. The parser pipeline has been restructured to include Okapi-specific pre- and late rewriting phases (OkapiPreparatoryRewriting and OkapiLateRewriting) alongside standard openCypher phases like SemanticAnalysis, AstRewriting, and CNFNormalizer. The default context filters out 'already declared' semantic errors to support CLONE clause functionality.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/impl/parse · high confidence

The system now uses a new parser built with the fastparse library to interpret Cypher type strings, supporting a comprehensive set of types including DATE, LOCALDATETIME, and parameterized BIGDECIMAL. Additionally, utility methods have been added to safely convert Cypher types into specific node or relationship types, failing explicitly if the conversion is not possible.

okapi-api/src/main/scala/org/opencypher/okapi/impl/types · high confidence

The \okapi-api\ module introduces a new \InternalException\ base class and a set of specific exception types (such as \SchemaException\, \GraphNotFoundException\, \InvalidGraphException\, and \ViewAlreadyExistsException\) to handle internal errors, graph state issues, and view conflicts. These exceptions support an optional cause parameter, allowing callers to preserve the original throwable for better debugging and error context when these specific internal conditions are triggered.

okapi-api/src/main/scala/org/opencypher/okapi/impl/exception · high confidence

The internal intermediate representation for graph patterns has been restructured to use a new, type-safe model for connections and endpoints. This change introduces distinct types for directed, undirected, and cyclic relationships, explicitly tracking semantic direction (e.g., outgoing/incoming) and preserving insertion order in pattern topologies. For users, this ensures that pattern matching and query planning respect the directionality of relationships more accurately, preventing ambiguities in directed graph traversals and supporting more complex pattern constructions like cyclic relationships.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/api/pattern · high confidence

The typer module now includes new internal components to manage type conversions and tracking: TypeConverter and toFrontendType handle mapping between internal and frontend Cypher types, TypeRecorder and TypeTracker manage expression type information during analysis, TyperError defines specific error cases for typing failures, and TyperResult packages the outcome of type checking. These changes provide the foundation for more robust type handling within the IR layer.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/impl/typer · high confidence

The \okapi-relational\ planning package now exposes three new core classes: \QueryPlans\ to hold and display logical and relational query plans, \RelationalCypherResult\ to manage query outcomes (including extracting graphs from \ReturnGraph\ and \GraphUnionAll\ operators and aligning result columns), and \RelationalRuntimeContext\ to track session state, input records, parameters, and graph resolution during query execution.

okapi-relational/src/main/scala/org/opencypher/okapi/relational/api/planning · high confidence

The project has been renamed from 'Cypher for Apache Spark' to 'Morpheus' and restructured as a Gradle-based build. This change introduces the core project scaffolding, including the Gradle wrapper scripts (gradlew, gradlew.bat), a .gitignore file, and a .git-blame-ignore-revs file to handle formatting history. It also adds essential documentation and legal files: a README.md detailing the new name, version 0.4.2, and usage examples; a CONTRIBUTING.adoc file outlining the openCypher Contributor Agreement (oCCA) requirements; and LICENSE.txt and NOTICE files establishing the Apache 2.0 license and an unofficial project disclaimer.

(repo-wide) · high confidence

The PropertyGraphDataSource interface now includes a reset() method, allowing implementations to clear internal state and schema caches. This enables users to effectively reset a data source to its initial state, which is particularly useful for testing or when reusing a data source instance across different graph operations.

okapi-api/src/main/scala/org/opencypher/okapi/api/io · high confidence

The Cypher table API in the \okapi-api\ module has been restructured to improve usability and safety. A new \CypherPrintable\ trait was introduced to standardize how table results are displayed to users, while \CypherRecords\ now explicitly extends this trait to handle record iteration and collection. The core \CypherTable\ interface was updated to distinguish between physical and logical column names, aiding in correct row display. Additionally, a \RichCypherTable\ implicit class was added to provide a \verifyColumnType\ method, which now throws an \IllegalArgumentException\ if a column is missing or has an incompatible type, ensuring stricter type safety during query execution.

okapi-api/src/main/scala/org/opencypher/okapi/api/table · high confidence

The core Cypher type definitions in the API have been restructured to support more precise type checking and serialization. The \CypherType\ trait now implements explicit \meet\ (intersection) and \join\ (union) operations, enabling better handling of type hierarchies for nodes, relationships, maps, and lists. A new \CTBigDecimal\ type has been introduced with specific subtyping rules based on precision and scale, and union types are now used to manage nullable states and type intersections. Additionally, the type system now supports serialization via uPickle, allowing types to be easily converted to and from string representations.

okapi-api/src/main/scala/org/opencypher/okapi/api/types · high confidence

The IO conversion API in the Okapi API module has been refactored to rename the core mapping concept from 'Entity' to 'Element'. This change introduces a new \ElementMapping\ class and a suite of builder classes (\NodeMappingBuilder\, \RelationshipMappingBuilder\, and \SingleElementMappingBuilder\) to construct mappings from external data sources to property graph patterns. Users interacting with this API will now use these builders to define how node and relationship identifiers, labels, types, and properties map to source data keys, replacing the previous entity-based mapping approach.

okapi-api/src/main/scala/org/opencypher/okapi/api/io/conversion · high confidence

The IR builder implementation in okapi-ir has been restructured to replace the previous expression conversion logic with AST rewriting. This change introduces new components including BlockRegistry for managing query blocks, IRBuilderContext for tracking the working graph and schema, and PatternConverter for handling graph patterns, fundamentally altering how Cypher queries are transformed into the intermediate representation.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/impl · high confidence

The relational graph layer has been refactored to improve how graph scans are generated and combined. New or updated graph types—EmptyGraph, PrefixedGraph, ScanGraph, and UnionGraph—now implement a consistent scanOperator interface that aligns element tables and handles unions via TabularUnionAll. This change enables the planner to construct ScanGraphs from element tables, supports unions with multiple unaligned elements, and fixes previous issues with optional label matching and empty input handling in union operations.

okapi-relational/src/main/scala/org/opencypher/okapi/relational/impl/graph · high confidence

The relational query planning layer has been restructured to improve code organization and correctness. The core \RelationalOperator\ abstract class and its associated traits (such as \EmptyTable\ and \UnitTable\) have been consolidated into a single file, establishing a unified base for relational operations. Additionally, a new \RelationalException\ hierarchy has been introduced, including \RecordHeaderException\ and \DuplicateSourceColumnException\, to provide more specific error reporting during query execution. These changes support broader refactoring efforts in the planner, such as aligning column names before union operations and optimizing construct graph planning, by providing a cleaner operator foundation and better error handling.

okapi-relational/src/main/scala/org/opencypher/okapi/relational/impl/operators · high confidence

The relational table API has been refactored to introduce a canonical physical record representation for Cypher results, replacing the previous CAPSRecords wrapper with a simpler structure based on a RecordHeader and the underlying table. This change includes the introduction of RelationalCypherRecords and RelationalElementTableFactory traits to manage result sets and element tables more explicitly. Additionally, the Table abstraction now supports column selection with aliasing, allowing users to rename columns during projection operations, and generalizes EntityMapping and Tables to better accommodate arbitrary query patterns.

okapi-relational/src/main/scala/org/opencypher/okapi/relational/api/table · high confidence

The IR expression system now enforces stricter type validation and more precise null handling. A new \TypeValidatedExpr\ trait automatically computes the \CypherType\ based on input signatures, ensuring that expressions fail early if no suitable type signature exists. Additionally, the introduction of \PropagationType\ (with modes like \NullOrAnyNullable\, \AnyNullable\, and \AllNullable\) allows expressions to explicitly define how null values from child nodes should influence the parent's type, replacing the previous default behavior and improving type safety for complex expressions.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/api/expr · high confidence

The ElementTable trait in the relational IO API has been renamed from EntityTable to align with the broader shift from 'Entity' to 'Element' terminology. This change updates the core abstraction used to map input data frames to Property Graph elements (nodes and relationships), ensuring consistent naming across the schema and mapping components.

okapi-relational/src/main/scala/org/opencypher/okapi/relational/api/io · high confidence

The table output logic in the Okapi API has been refactored to use the TablePrinter utility instead of the previous RecordsPrinter implementation. This change ensures that Cypher records are formatted into a table structure using dynamic column width computation and logical column names, resulting in more accurate and readable row displays for users viewing query results.

okapi-api/src/main/scala/org/opencypher/okapi/impl/table · high confidence

The intermediate representation (IR) block definitions in the \okapi-ir\ module have been refactored to support a tree-based structure. This change introduces a new \Block\ abstract class extending \AbstractTreeNode\, along with a \BasicBlock\ base class for specific operations. New or updated block types include \AggregationBlock\, \MatchBlock\, \OrderAndSliceBlock\, \ProjectBlock\, \ResultBlock\ (with \TableResultBlock\ and \GraphResultBlock\), \SourceBlock\, and \UnwindBlock\. The refactoring also adds supporting types like \BlockSig\, \Fields\, \OrderedFields\, and \SortItem\ to better model query execution steps and their data flow.

okapi-ir/src/main/scala/org/opencypher/okapi/ir/api/block · high confidence

The \okapi-api\ graph module has been refactored to introduce a new \CypherResult\ type that explicitly distinguishes between query results returning records versus those returning graphs, and a new \CypherSession\ trait that manages graph lifecycles and exposes a \PropertyGraphCatalog\. The catalog now supports storing and dropping views in addition to graphs, and graph operations like store, graph, and delete are restricted to qualified graph names. Additionally, a new \Pattern\ interface and \GraphElementType\ definitions have been added to support pattern-based graph scanning and element identification.

okapi-api/src/main/scala/org/opencypher/okapi/api/graph · high confidence

The schema API in the \okapi-api\ module has been restructured to better model property graph schemas. The previous \Schema\ type has been renamed to \PropertyGraphSchema\, and the internal storage for node and relationship properties has been replaced with new \LabelPropertyMap\ and \RelTypePropertyMap\ types. These changes allow the schema to explicitly track property keys for specific combinations of node labels (rather than just single labels) and relationship types. Additionally, a new \SchemaPattern\ class has been introduced to define and store explicit constraints on graph patterns (source node labels, relationship type, and target node labels), enabling more precise schema validation and query planning based on defined structural patterns.

okapi-api/src/main/scala/org/opencypher/okapi/api/schema · high confidence

The schema implementation in the API module has been refactored to rename the core schema class to PropertyGraphSchemaImpl and introduce new helper types for managing label relationships. Specifically, the new ImpliedLabels class provides logic for computing transitive label implications, while LabelCombinations handles sets of co-existing labels. The PropertyGraphSchemaImpl now integrates these components to derive schema patterns and implied labels, and includes updated serialization logic for JSON read/write operations.

okapi-api/src/main/scala/org/opencypher/okapi/impl/schema · high confidence

The in-memory session data source now prevents overwriting existing graphs by throwing a GraphAlreadyExistsException when attempting to store a graph with a name that is already in use. Additionally, it provides a specific GraphNotFoundException when retrieving a non-existent graph, replacing previous generic error handling with clearer, distinct exception types for these common session management scenarios.

okapi-api/src/main/scala/org/opencypher/okapi/impl/io · high confidence

The tree library now provides stack-safe implementations for bottom-up and top-down rewrites, as well as general transformations, ensuring that operations on very deep trees no longer risk StackOverflowErrors. This is achieved by introducing a new \TreeTransformer\ abstraction and corresponding stack-safe variants (\BottomUpStackSafe\, \TopDownStackSafe\, \TransformStackSafe\) that use an explicit stack instead of recursion. The core \TreeNode\ class has been updated to automatically fall back to these stack-safe versions if a standard recursive transformation exceeds the stack limit. Additionally, a new \BottomUpWithContext\ rewriter allows transformations to pass context between siblings, and \AbstractTreeNode\ now supports \NonEmptyList\ in addition to \List\ and \Option\ for automatic child inference.

okapi-trees/src/main · high confidence

The project now uses Scalafmt version 3.8.1 with Scala 2.12 dialect to enforce consistent code style (100-column limit, 2-space indentation, specific docstring rules). Additionally, the \etc/licenses\ directory has been updated to include full text for Apache-2.0, BSD-2-Clause, BSD-3-Clause, and MIT licenses, along with updated NOTICE and header files to reflect current copyright years and attribution requirements.

etc · high confidence

Added Morpheus test generator for Cypher TCK scenarios; Added ScalaTest-based test infrastructure and utilities for Okapi; Added base test class for Okapi API tests; Added comprehensive tests for tree node operations and rewrites; Added in-memory test graph utilities for property graph testing; Added logging configuration for the neo4j-io-testing module; Added property-based tests for Cypher value serialization; Added test suite for IR implementation components; Added test support for tree node verification; Added test support utilities for Neo4j AST parsing and query rewriting; Added tests for Bag equality semantics; Added tests for Cypher type system laws and pattern element mapping; Added tests for CypherCatalog error handling and namespace management; Added tests for Graph DDL parser and IR conversion; Added tests for IR expression typing and equality; Added tests for IR rewriters; Added tests for IRField equality and hashing; Added tests for Morpheus example applications; Added tests for Neo4j I/O helpers and element readers/writers; Added tests for RelationalPropertyGraphSchema header generation; Added tests for TablePrinter and Version utilities; Added tests for TypedMatchBlock type inference; Added tests for configuration caching behavior; Added tests for property graph CreateQueryFactory; Added unit tests for CypherSession and QualifiedGraphName; Added unit tests for IR type conversion and tracking components; Added unit tests for RecordHeader and FreshVariableNamer; Added unit tests for SessionGraphDataSource; Added unit tests for pattern connection equality and pattern construction; Added unit tests for schema components; New TCK test generation and fixture infrastructure; New testing infrastructure for Morpheus; Updated test blacklists for known failing scenarios.

The project has replaced its Maven build configuration (pom.xml) with a multi-module Gradle build structure. This migration introduces a Gradle version catalog (gradle/libs.versions.toml) to centrally manage dependency versions, including Spark 3.5.7, Scala 2.12.20, and the openCypher frontend 9.0. The build now enforces Java 21 toolchains, utilizes the Shadow plugin for creating fat JARs in the relational and Spark modules, and integrates license validation and reporting tasks. Additionally, the test suite has been standardized to use JUnit Platform with ScalaTest, replacing the previous JUnit 4 and older ScalaTest configurations.

(dependencies) · high confidence

The local dependency repository now includes version 0.16.3-63da64d of the \license-gradle-plugin\ (group \com.hierynomus.gradle.plugins\). This update adds the plugin's metadata and artifacts, which target JVM 21 and include runtime dependencies on \plexus-utils\ 4.0.2, \xmltool\ 3.3, and \license-maven-plugin\ 3.0. This change supports the broader Gradle upgrade to version 9.2.1.

dependencies/plugins/repository, dependencies/plugins/repository/com/hierynomus/gradle/plugins/license-gradle-plugin · medium confidence

The Gradle wrapper configuration has been updated to use Gradle 9.2.1. This change ensures that the project builds using the specified distribution URL, aligning the local build environment with the new wrapper version defined in the properties file.

gradle · high confidence

Added three new files to the developer documentation: a scratchpad outlining the physical and logical query execution model (including named graphs and result interfaces), a planner structure document detailing operator variations and graph registry concepts, and an LDBC Social Network example demonstrating specific Cypher queries against a sample graph dataset.

doc · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 58.

• Code Health 86
• Architecture 81
• Maturity 60
• Readiness 50
• Security 59

• 300 commits — 257 feature/other, 43 fixes

• okapi-ir/src — 72 commits
• (repo) — 36 commits
• (root) — 36 commits
• spark-cypher-examples/src — 27 commits
• morpheus-spark-cypher/src — 17 commits
• morpheus-testing/src — 14 commits
• morpheus-examples/src — 13 commits
• okapi-api/src — 13 commits
• spark-cypher-testing/src — 13 commits
• okapi-tck/src — 10 commits
• spark-cypher/src — 9 commits
• okapi-shade/build.gradle — 6 commits
• documentation/asciidoc — 5 commits
• okapi-logical/src — 5 commits
• okapi-relational/src — 5 commits
• okapi-api/build.gradle — 4 commits
• morpheus-spark-cypher/build.gradle — 3 commits
• spark-cypher-tck/src — 3 commits
• dependencies/plugins — 2 commits
• morpheus-tck/src — 2 commits

• fix: Fix Ands/Ors conversion and test expectations
• fix: Fix Explode-Bug
• fix: Fix PGDS id generation
• fix: Fix README and UpdateExample tests
• fix: Fix README test
• fix: Fix RecordHeader tests
• fix: Fix SQL expression mapper type-check for list concatenation
• fix: Fix Spark type conversion for numeric lists
• fix: Fix blacklisted test by removing special case handling for IN
• fix: Fix bug and add test for map type intersections
• fix: Fix bugs in Spark type conversion and SparkSQL expression mapper
• fix: Fix closed stream issue
• fix: Fix compilation errors
• fix: Fix connection-scope after WITH
• fix: Fix including CTRelationship and CTNode signatures
• fix: Fix module name in MetaTest
• fix: Fix optimized imports
• fix: Fix recommendation query
• fix: Fix result type testing of expression converter
• fix: Fix scala-style
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

opencypher/morpheus was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.