doctrine/orm

Features

• Object Oriented Querying - Implements a high-level object-oriented query language (DQL) to retrieve data based on entities instead of tables.
• Object Persistence - Allows saving and retrieving data without writing manual SQL by mapping objects to storage.
• Object-Relational Mappers - Provides a full object-relational mapping implementation to decouple application objects from relational database schemas.
• Object-Relational Mapping - Provides a comprehensive object-relational mapping system for PHP application objects and relational databases.
• Association Lazy Loading - Defers the retrieval of related objects until they are accessed, significantly reducing initial database load.
• Repository Patterns - Implements the repository pattern to encapsulate query logic and decouple the domain layer from data access.
• Database Atomic Batches - Groups multiple database mutations into a single atomic operation to ensure consistency.
• Column Mappings - Provides configurations for linking class properties to specific database columns with defined types and constraints.
• Data Query Builders - Provides a programmatic query builder and custom language to decouple data retrieval from database schemas.
• Persistence State Tracking - Tracks object changes via snapshots to ensure only modified fields are updated in the database.
• Database Abstraction Layers - A consistent interface for interacting with various database engines to decouple logic from SQL dialects.
• Database Schema Migrations - Automates versioned structural updates to the database to maintain compatibility with application code.
• Database Schema Managers - Includes tools to automatically generate and update relational database structures based on object metadata.
• Database Transaction Management - Provides programmatic control over transaction boundaries to group multiple operations into atomic units.
• Primary Keys - Ships a system to designate object properties as unique identifiers and configure generation strategies like auto-increment.
• Primary Key Retrievals - Provides a primary mechanism to fetch a single persistent entity from the database using its unique identifier.
• Identity Maps - Ensures a single instance of an object is maintained for every database record within a request.
• Fluent Query Construction - Provides a fluent, object-oriented interface for programmatically constructing database queries without writing raw SQL.
• Entity Second-Level Caching - Implements a second-level cache to store frequently accessed entities and collections across sessions.
• Persistence Scheduling - Marks objects for synchronization and delays execution until a global flush operation.
• State Change Tracking - Monitors modifications to object attributes to ensure correct synchronization with the database.
• Object State Diffing - Compares object states against snapshots to generate minimal update statements for modified fields.
• PHP Data Hydration - Provides a system to populate PHP objects and arrays from raw database result sets.
• Type Mappings - Implements conversions between database-specific column types and native programming language objects based on type and nullability.
• Object-Oriented - Provides a dedicated object-oriented query language (DQL) and programmatic builder for retrieving entity-based data.
• Eager Loading - Reduces N+1 query problems by automatically loading related entities in a single database request.
• Object-Oriented Query Compilation - Implements a custom query language that is compiled into optimized vendor-specific SQL.
• Entity Mappings - Provides a comprehensive system for defining how PHP objects map to database tables via attributes, XML, or code.
• Entity Mapping Metadata - Supports flexible mapping definitions through PHP attributes, XML, and programmatic configuration.
• Parameterized Query Bindings - Implements parameterized query bindings to separate SQL logic from user input, preventing SQL injection attacks.
• Custom Repository Implementations - Enables the creation of custom repository classes to centralize specialized data retrieval logic.
• Data Mappers - Implements the data mapper pattern to decouple the in-memory object model from the database schema.
• Identity Map Patterns - Ensures a single instance of an object is returned for every request of a specific key.
• Persistence State Management - Tracks whether an object is new, managed, detached, or removed for synchronization.
• Unit of Work Patterns - Implements the Unit of Work pattern to coordinate atomic database transactions for all tracked object changes.
• Concurrent Read-Write Transactions - Coordinates simultaneous database updates using a combination of optimistic and pessimistic locking strategies.
• Batch Processing - Implements batch processing to handle large volumes of data updates efficiently by flushing in sets.
• Bulk Data Operations - Provides capabilities for mass inserts, updates, and deletes to minimize memory usage during large operations.
• Custom Data Types - Provides a system for defining and using custom data types to map non-standard database columns to objects.
• Deferred Executions - Delays SQL execution until transaction commit to minimize database write locks.
• Query Result Caching - Stores the outcome of a query and its parsed SQL in a cache driver to improve retrieval speed.
• Partial Association Querying - Allows executing targeted queries for counts or slices of an association without loading the entire collection into memory.
• Schema Versioning - Tracks incremental schema versions to keep the database structure in sync with the application code.
• DTO Mappings - Enables instantiating plain Data Transfer Objects (DTOs) directly from query results via constructor mapping.
• Field Value Converters - Ships custom mapping types to transform data between object properties and database columns.
• Data Type Mappings - Implements the translation of application-level data types into native database-specific column formats.
• Database Change Tracking - Implements a system for recording attribute changes to optimize database synchronization.
• Bulk Entity Deletions - Allows for the efficient removal of multiple objects in a single operation to avoid memory exhaustion.
• Database Performance Optimizers - Enhances query efficiency using techniques like lazy loading and second-level caching.
• Scalar Result Retrieval - Enables the retrieval of non-object scalar values, such as aggregate counts, directly from the database.
• Database Result Caching - Implements a secondary cache to store retrieved database data and reduce redundant query load.
• Embeddable Objects - Implements embeddables to persist related value objects within a single database table.
• Inheritance Mappings - Provides various strategies for mapping class inheritance hierarchies to relational database tables.
• Mapped Superclasses - Allows the definition of shared persistent fields in a base class inherited by multiple entities.
• Composite - Supports the definition of primary keys composed of multiple columns or related entity associations.
• Entity Relationship Definitions - Provides configurations for establishing associations between objects, including fetch strategies and cascade options.
• Metadata Caches - Caches parsed class mapping information in memory to avoid repeated configuration parsing overhead.
• Cardinality Mapping - Defines relationships between objects as one-to-one, one-to-many, many-to-one, or many-to-many.
• Batch Processing - Optimizes the persistence of large volumes of objects to improve speed and reduce memory usage.
• Graph Persistence - Saves a root object and all nested related objects in a single operation.
• Partial Property Persistence - Synchronizes only modified properties with the database during a flush operation.
• Self-Referencing Relationships - Implements support for modeling recursive hierarchies through self-referencing object associations.
• Association-Based Filters - Allows filtering of associated collections using criteria that execute at the SQL or memory level.
• Bidirectional Association Mapping - Defines relationship sides to determine which object reference triggers database updates in bidirectional associations.
• Optimistic Locking - Prevents concurrent update conflicts by tracking version counts on entity instances.
• Orphan Removal - Automatically deletes associated objects when they are removed from a parent collection.
• Partial Entity Loading - Provides the ability to retrieve only specific fields of an object to reduce memory consumption.
• Query Aggregates - Supports computing aggregate values like sums, counts, and minimums directly through query logic.
• Query Plan Caching - Caches the translation of high-level DQL into vendor-specific SQL to avoid repeated parsing.
• Query Expression Builders - Provides a set of expression helpers to build dynamic conditional logic for query filters.
• Query Language Extensions - Allows adding custom functions and walkers to the query language to support complex business logic.
• Array Result Fetches - Supports retrieving query results as associative arrays for improved performance and simplified access.
• Pagination - Supports retrieving data subsets from large result sets using offset and limit parameters.
• Result Streaming - Implements incremental result streaming via cursors to process massive datasets without exhausting memory.
• Query Filters - Provides mechanisms to apply conditional logic and range-based constraints to filter database query results.
• Inheritance-Based Filtering - Provides a specialized query construct to retrieve specific subclasses from an entity inheritance hierarchy.
• Entity Associations - Defines unidirectional and bidirectional relationships between data entities that synchronize with the database.
• Database Constraints - Allows the definition of uniqueness and non-nullability constraints enforced at the database level.
• Schema Generators - Analyzes entity models and metadata to generate the corresponding relational database schema.
• SQL Execution Logging - Ships a mechanism to record all executed SQL statements for debugging purposes via a custom logger.
• SQL Query Execution - Allows execution of native SQL statements and maps the resulting row sets back into objects.
• Many-to-Many Join Tables - Handles intermediary tables that connect multiple records from two different objects.
• Object Mappings - Allows specifying database mapping metadata programmatically using code and attributes within object classes.
• Bulk Update Utilities - Provides utilities for performing batch modifications on database records to improve performance.
• Value Object Embedding - Inlines value object properties as columns within a single object table.
• Entity Detachment - Removes objects from management so changes are no longer synchronized to the database.
• Second-Level Caches - Implements a second-level cache to store frequently accessed entities and reduce database load.
• Entity Proxy - Uses proxy objects to implement lazy loading of associations, reducing initial database load.
• Optimistic Locking - Implements optimistic locking using version columns to prevent concurrent update conflicts.
• SQL Injection Prevention - Uses prepared statement parameters to protect database queries from SQL injection attacks.
• Database Schema Migrations - Ships a system for tracking and applying versioned schema migrations to maintain environment consistency.
• Lifecycle Callbacks - Allows executing custom methods on objects automatically during persistence events like pre-persist or post-load.
• Persistence Cascades - Implements a mechanism to propagate persistence operations from parent objects to their associated children.
• Persistence Lifecycle Events - Triggers custom logic automatically during the creation, update, or deletion of managed entities.

Star history