Cycle ORM

Additional features

PHP DataMapper ORM & Data Modelling Engine

The core identity of the product, emphasizing its data mapping and modeling capabilities in PHP.

Flexible Configuration Options

Allows for highly adaptable setup to model datasets according to specific requirements.

Powerful Query Builder

Provides a robust tool for constructing complex database queries.

Dynamic Mapping Schemas

Supports the ability to define and adjust how objects map to database tables at runtime, useful for applications requiring dynamic data structures (e.g., ERP/CRM/CMS).

Polymorphic Relations

Supports advanced relationship types where an entity can be related to multiple other entity types (e.g., a "Comment" entity related to either a "Post" or a " "Video" entity).

Has-One, Has-Many, Many-Through-Many Relations

Standard relational capabilities for defining relationships between entities.

Multiple Object Types Support

Can work with Plain Old PHP Objects (POPOs), Active Record (AR) patterns, custom objects, or even the same entity type for multiple repositories, offering flexibility in object design.

Eager Loading

Allows loading related data along with the primary entity in a single query, reducing the N+1 query problem.

Lazy Loading

Defers loading of related data until it is actually accessed, optimizing initial load times.

Multiple Fetch Strategies

Provides various methods for retrieving data from the database.

Runtime Configuration (with/without code-generation)

Enables configuring the ORM at runtime, offering flexibility and potentially avoiding the need for static code generation, which is beneficial for long-running applications like those powered by RoadRunner.

Column-to-Field Mapping

Straightforward mapping of database table columns to object properties.

Single Table Inheritance

A mapping strategy where an entire class hierarchy is stored in a single database table.

Value Objects Support

Allows embedding value objects (objects without a unique identity that represent a value, like an "Address" object) within entities.

Works with Directed Graphs

Can manage and persist data structures that have directional relationships.

Works with Cyclic Graphs using Command Chains

Specifically designed to handle complex data structures with circular dependencies through its command chain mechanism for persistence.

MySQL Support

Compatible with MySQL databases.

MariaDB Support

Compatible with MariaDB databases.

PostgreSQL Support

Compatible with PostgreSQL databases.

SQL Server Support

Compatible with Microsoft SQL Server databases.

SQLite Support

Compatible with SQLite databases.

Included DBAL Component

The cycle/database component (Database Abstraction Layer) is included by default in Web and GRPC builds, focusing on unifying database access across different DBMS.

Compatible with Doctrine Collections

Can work seamlessly with doctrine/collections for handling entity collections.

Compatible with Laravel Collections

Can work seamlessly with illuminate/collections (Laravel's collection class) for handling entity collections.

Compatible with Doctrine Annotations

Supports defining entity mappings using Doctrine annotations (and PHP 8 attributes).

Designed for Long-Running Applications

Built to work safely and efficiently in daemonized PHP environments like RoadRunner, minimizing memory leaks.

Hackable Architecture

Allows for customization of persist strategies, mappers, relations, and transactions.

Schema Scaffolding, Introspection, Migrations

Tools for generating database schemas, inspecting existing ones, and managing database changes through migrations.

Supports Global Query Scopes

Defines reusable query constraints.

UUIDs as Primary Keys

Supports using Universally Unique Identifiers as primary keys.

Soft Deletes

Provides a mechanism for marking records as "deleted" without actually removing them from the database.

Auto Timestamps

Automatically manages created_at and updated_at fields.

Custom Column Types

Allows defining custom data types for database columns.

Foreign Keys to Non-Primary Columns

Supports defining foreign key relationships to columns that are not primary keys.

Composite Keys Support

Allows entities and relations to use multiple columns as a primary or foreign key.

Joined Table Inheritance (JTI)

A mapping strategy where each entity in a class hierarchy maps to its own separate table, joined by a common identifier.

Significantly Redesigned Mappers

Improved internal mapper architecture for easier work with lazy links, typed class properties, and private class properties.

Proxy Entities for Lazy Loading

Uses proxy objects to enable efficient lazy loading of relationships.

Faster Entities Hydrator

A rewritten hydrator for improved performance when populating entities from database results.

Customizable Typecasting

Flexible rules and handlers for converting entity property values to common data types.

Separated Entity Manager and Unit Of Work

Distinct components for managing transaction state and persisting entities.

PHP 8.0+ Support

Ensures compatibility with modern PHP versions.