Cycle ORM

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

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

Provides a robust tool for constructing complex database queries.

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).

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).

Standard relational capabilities for defining relationships between entities.

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.

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

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

Provides various methods for retrieving data from the database.

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.

Straightforward mapping of database table columns to object properties.

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

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

Can manage and persist data structures that have directional relationships.

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

Compatible with MySQL databases.

Compatible with MariaDB databases.

Compatible with PostgreSQL databases.

Compatible with Microsoft SQL Server databases.

Compatible with SQLite databases.

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

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

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

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

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

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

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

Defines reusable query constraints.

Supports using Universally Unique Identifiers as primary keys.

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

Automatically manages created_at and updated_at fields.

Allows defining custom data types for database columns.

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

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

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

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

Uses proxy objects to enable efficient lazy loading of relationships.

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

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

Distinct components for managing transaction state and persisting entities.

Ensures compatibility with modern PHP versions.