# doctrine/orm

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/doctrine-orm).**

10,172 stars · 2,535 forks · PHP · MIT

## Links

- GitHub: https://github.com/doctrine/orm
- Homepage: https://www.doctrine-project.org/projects/orm.html
- awesome-repositories: https://awesome-repositories.com/repository/doctrine-orm.md

## Topics

`hacktoberfest`

## Description

Doctrine ORM is a PHP object-relational mapper that connects application objects to relational database tables. It uses the data mapper and identity map patterns to decouple the in-memory object model from the database schema, allowing developers to manage data persistence without writing manual SQL.

The project features a dedicated object-oriented query language and programmatic builder for retrieving data based on entities rather than tables. It implements a unit-of-work system to track object changes during a request and synchronize them via atomic transactions.

The capability surface includes comprehensive schema management with versioned migrations, a multi-layer caching system for metadata and query results, and advanced mapping options for inheritance and complex associations. It also provides tools for state tracking, result hydration into different data structures, and concurrency control through optimistic locking.

A command-line interface is provided for managing database schemas, executing queries, and handling cache automation.

## Tags

### Data & Databases

- [Object Oriented Querying](https://awesome-repositories.com/f/data-databases/object-oriented-querying.md) — Implements a high-level object-oriented query language (DQL) to retrieve data based on entities instead of tables. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/index.html))
- [Object Persistence](https://awesome-repositories.com/f/data-databases/object-persistence.md) — Allows saving and retrieving data without writing manual SQL by mapping objects to storage. ([source](https://cdn.jsdelivr.net/gh/doctrine/orm@3.6.x/README.md))
- [Object-Relational Mappers](https://awesome-repositories.com/f/data-databases/object-relational-mappers.md) — Provides a full object-relational mapping implementation to decouple application objects from relational database schemas.
- [Object-Relational Mapping](https://awesome-repositories.com/f/data-databases/object-relational-mapping.md) — Provides a comprehensive object-relational mapping system for PHP application objects and relational databases.
- [Association Lazy Loading](https://awesome-repositories.com/f/data-databases/association-lazy-loading.md) — Defers the retrieval of related objects until they are accessed, significantly reducing initial database load. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/working-with-objects.html))
- [Repository Patterns](https://awesome-repositories.com/f/data-databases/backend-data-access-layers/repository-patterns.md) — Implements the repository pattern to encapsulate query logic and decouple the domain layer from data access. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/tutorials/getting-started.html))
- [Database Atomic Batches](https://awesome-repositories.com/f/data-databases/bulk-data-operations/atomic-batch-operations/database-atomic-batches.md) — Groups multiple database mutations into a single atomic operation to ensure consistency.
- [Column Mappings](https://awesome-repositories.com/f/data-databases/column-mappings.md) — Provides configurations for linking class properties to specific database columns with defined types and constraints. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/basic-mapping.html))
- [Data Query Builders](https://awesome-repositories.com/f/data-databases/data-query-builders.md) — Provides a programmatic query builder and custom language to decouple data retrieval from database schemas. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/2.16/index.html))
- [Persistence State Tracking](https://awesome-repositories.com/f/data-databases/data-snapshotting/state-snapshots/persistence-state-tracking.md) — Tracks object changes via snapshots to ensure only modified fields are updated in the database.
- [Database Abstraction Layers](https://awesome-repositories.com/f/data-databases/database-abstraction-layers.md) — A consistent interface for interacting with various database engines to decouple logic from SQL dialects. ([source](http://www.doctrine-project.org/))
- [Database Schema Migrations](https://awesome-repositories.com/f/data-databases/database-management-systems/database-systems-management/database-management/database-schema-migrations.md) — Automates versioned structural updates to the database to maintain compatibility with application code.
- [Database Schema Managers](https://awesome-repositories.com/f/data-databases/database-schema-managers.md) — Includes tools to automatically generate and update relational database structures based on object metadata. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/tools.html))
- [Database Transaction Management](https://awesome-repositories.com/f/data-databases/database-transaction-management.md) — Provides programmatic control over transaction boundaries to group multiple operations into atomic units. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/best-practices.html))
- [Primary Keys](https://awesome-repositories.com/f/data-databases/entity-modeling/primary-keys.md) — Ships a system to designate object properties as unique identifiers and configure generation strategies like auto-increment. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/attributes-reference.html))
- [Primary Key Retrievals](https://awesome-repositories.com/f/data-databases/entity-modeling/primary-keys/primary-key-retrievals.md) — Provides a primary mechanism to fetch a single persistent entity from the database using its unique identifier. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/tutorials/getting-started.html))
- [Identity Maps](https://awesome-repositories.com/f/data-databases/entity-relationships/identity-maps.md) — Ensures a single instance of an object is maintained for every database record within a request.
- [Fluent Query Construction](https://awesome-repositories.com/f/data-databases/expression-based-data-querying/fluent-query-apis/sql-syntax-tree-construction/fluent-query-construction.md) — Provides a fluent, object-oriented interface for programmatically constructing database queries without writing raw SQL. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/query-builder.html))
- [Entity Second-Level Caching](https://awesome-repositories.com/f/data-databases/multi-level-caching/entity-second-level-caching.md) — Implements a second-level cache to store frequently accessed entities and collections across sessions. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/2.21/index.html))
- [Persistence Scheduling](https://awesome-repositories.com/f/data-databases/object-persistence/persistence-scheduling.md) — Marks objects for synchronization and delays execution until a global flush operation. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/working-with-objects.html))
- [State Change Tracking](https://awesome-repositories.com/f/data-databases/object-relational-mapping/state-change-tracking.md) — Monitors modifications to object attributes to ensure correct synchronization with the database. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/change-tracking-policies.html))
- [Object State Diffing](https://awesome-repositories.com/f/data-databases/object-relational-mapping/state-change-tracking/object-state-diffing.md) — Compares object states against snapshots to generate minimal update statements for modified fields. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/unitofwork.html))
- [PHP Data Hydration](https://awesome-repositories.com/f/data-databases/php-data-hydration.md) — Provides a system to populate PHP objects and arrays from raw database result sets. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/unitofwork.html))
- [Type Mappings](https://awesome-repositories.com/f/data-databases/postgresql-integrations/type-mappings.md) — Implements conversions between database-specific column types and native programming language objects based on type and nullability. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/typedfieldmapper.html))
- [Object-Oriented](https://awesome-repositories.com/f/data-databases/query-languages/object-oriented.md) — Provides a dedicated object-oriented query language (DQL) and programmatic builder for retrieving entity-based data.
- [Eager Loading](https://awesome-repositories.com/f/data-databases/query-performance-tuning/eager-loading.md) — Reduces N+1 query problems by automatically loading related entities in a single database request. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/working-with-objects.html))
- [Object-Oriented Query Compilation](https://awesome-repositories.com/f/data-databases/sql-generators/deferred-query-compilation/sql-string-compilations/object-oriented-query-compilation.md) — Implements a custom query language that is compiled into optimized vendor-specific SQL.
- [Entity Mappings](https://awesome-repositories.com/f/data-databases/type-mapping-frameworks/script-to-native-type-mappings/entity-mappings.md) — Provides a comprehensive system for defining how PHP objects map to database tables via attributes, XML, or code. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/metadata-drivers.html))
- [Entity Mapping Metadata](https://awesome-repositories.com/f/data-databases/xml-query-mappings/xml-configuration-mappings/entity-mapping-metadata.md) — Supports flexible mapping definitions through PHP attributes, XML, and programmatic configuration.
- [Concurrent Read-Write Transactions](https://awesome-repositories.com/f/data-databases/acid-transactional-cores/concurrent-read-write-transactions.md) — Coordinates simultaneous database updates using a combination of optimistic and pessimistic locking strategies. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/2.21/index.html))
- [Batch Processing](https://awesome-repositories.com/f/data-databases/batch-processing.md) — Implements batch processing to handle large volumes of data updates efficiently by flushing in sets. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/3.6/index.html))
- [Bulk Data Operations](https://awesome-repositories.com/f/data-databases/bulk-data-operations.md) — Provides capabilities for mass inserts, updates, and deletes to minimize memory usage during large operations. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/batch-processing.html))
- [Custom Data Types](https://awesome-repositories.com/f/data-databases/custom-data-types.md) — Provides a system for defining and using custom data types to map non-standard database columns to objects. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/2.21/index.html))
- [Deferred Executions](https://awesome-repositories.com/f/data-databases/custom-sql-execution/deferred-executions.md) — Delays SQL execution until transaction commit to minimize database write locks. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/architecture.html))
- [Query Result Caching](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/caching-performance/caching-strategies/query-result-caching.md) — Stores the outcome of a query and its parsed SQL in a cache driver to improve retrieval speed. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/caching.html))
- [Partial Association Querying](https://awesome-repositories.com/f/data-databases/data-querying/partial-association-querying.md) — Allows executing targeted queries for counts or slices of an association without loading the entire collection into memory. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/tutorials/extra-lazy-associations.html))
- [Schema Versioning](https://awesome-repositories.com/f/data-databases/data-schema-management/schema-versioning.md) — Tracks incremental schema versions to keep the database structure in sync with the application code. ([source](http://www.doctrine-project.org/))
- [DTO Mappings](https://awesome-repositories.com/f/data-databases/data-serialization-formats/structured-data-exporters/analysis-result-exporters/query-result-exporters/dto-mappings.md) — Enables instantiating plain Data Transfer Objects (DTOs) directly from query results via constructor mapping. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/dql-doctrine-query-language.html))
- [Field Value Converters](https://awesome-repositories.com/f/data-databases/data-source-definitions/field-definitions/custom-field-type-definitions/field-value-converters.md) — Ships custom mapping types to transform data between object properties and database columns. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/cookbook/advanced-field-value-conversion-using-custom-mapping-types.html))
- [Data Type Mappings](https://awesome-repositories.com/f/data-databases/data-type-mappings.md) — Implements the translation of application-level data types into native database-specific column formats. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/index.html))
- [Database Change Tracking](https://awesome-repositories.com/f/data-databases/database-change-tracking.md) — Implements a system for recording attribute changes to optimize database synchronization. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/attributes-reference.html))
- [Bulk Entity Deletions](https://awesome-repositories.com/f/data-databases/database-deletion-utilities/bulk-force-deletion/filtered-bulk-deletions/bulk-entity-deletions.md) — Allows for the efficient removal of multiple objects in a single operation to avoid memory exhaustion. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/dql-doctrine-query-language.html))
- [Database Performance Optimizers](https://awesome-repositories.com/f/data-databases/database-performance-optimizers.md) — Enhances query efficiency using techniques like lazy loading and second-level caching.
- [Scalar Result Retrieval](https://awesome-repositories.com/f/data-databases/database-query-execution/scalar-result-retrieval.md) — Enables the retrieval of non-object scalar values, such as aggregate counts, directly from the database. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/tutorials/getting-started.html))
- [Database Result Caching](https://awesome-repositories.com/f/data-databases/database-result-caching.md) — Implements a secondary cache to store retrieved database data and reduce redundant query load. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/index.html))
- [Embeddable Objects](https://awesome-repositories.com/f/data-databases/embeddable-objects.md) — Implements embeddables to persist related value objects within a single database table. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/2.15/index.html))
- [Inheritance Mappings](https://awesome-repositories.com/f/data-databases/entity-inheritance/inheritance-mappings.md) — Provides various strategies for mapping class inheritance hierarchies to relational database tables. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/2.19/index.html))
- [Mapped Superclasses](https://awesome-repositories.com/f/data-databases/entity-inheritance/inheritance-mappings/mapped-superclasses.md) — Allows the definition of shared persistent fields in a base class inherited by multiple entities. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/inheritance-mapping.html))
- [Composite](https://awesome-repositories.com/f/data-databases/entity-modeling/primary-keys/composite.md) — Supports the definition of primary keys composed of multiple columns or related entity associations. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/tutorials/composite-primary-keys.html))
- [Entity Relationship Definitions](https://awesome-repositories.com/f/data-databases/entity-relationship-definitions.md) — Provides configurations for establishing associations between objects, including fetch strategies and cascade options. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/attributes-reference.html))
- [Metadata Caches](https://awesome-repositories.com/f/data-databases/in-memory-caches/metadata-caches.md) — Caches parsed class mapping information in memory to avoid repeated configuration parsing overhead. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/caching.html))
- [Cardinality Mapping](https://awesome-repositories.com/f/data-databases/many-to-many-associations/cardinality-mapping.md) — Defines relationships between objects as one-to-one, one-to-many, many-to-one, or many-to-many. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/xml-mapping.html))
- [Batch Processing](https://awesome-repositories.com/f/data-databases/object-persistence/batch-processing.md) — Optimizes the persistence of large volumes of objects to improve speed and reduce memory usage. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/2.14/index.html))
- [Graph Persistence](https://awesome-repositories.com/f/data-databases/object-persistence/graph-persistence.md) — Saves a root object and all nested related objects in a single operation. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/cookbook/aggregate-fields.html))
- [Partial Property Persistence](https://awesome-repositories.com/f/data-databases/object-persistence/partial-property-persistence.md) — Synchronizes only modified properties with the database during a flush operation. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/tutorials/getting-started.html))
- [Self-Referencing Relationships](https://awesome-repositories.com/f/data-databases/object-relational-mappers/data-modeling/entity-relationship-models/association-models/self-referencing-relationships.md) — Implements support for modeling recursive hierarchies through self-referencing object associations. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/association-mapping.html))
- [Association-Based Filters](https://awesome-repositories.com/f/data-databases/object-relational-mapping-associations/association-based-filters.md) — Allows filtering of associated collections using criteria that execute at the SQL or memory level. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/working-with-associations.html))
- [Bidirectional Association Mapping](https://awesome-repositories.com/f/data-databases/object-relational-mapping-associations/bidirectional-association-mapping.md) — Defines relationship sides to determine which object reference triggers database updates in bidirectional associations. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/unitofwork-associations.html))
- [Optimistic Locking](https://awesome-repositories.com/f/data-databases/optimistic-locking.md) — Prevents concurrent update conflicts by tracking version counts on entity instances. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/attributes-reference.html))
- [Orphan Removal](https://awesome-repositories.com/f/data-databases/orphan-removal.md) — Automatically deletes associated objects when they are removed from a parent collection. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/working-with-associations.html))
- [Partial Entity Loading](https://awesome-repositories.com/f/data-databases/partial-document-retrieval/partial-entity-loading.md) — Provides the ability to retrieve only specific fields of an object to reduce memory consumption. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/partial-objects.html))
- [Query Aggregates](https://awesome-repositories.com/f/data-databases/query-aggregates.md) — Supports computing aggregate values like sums, counts, and minimums directly through query logic. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/cookbook/aggregate-fields.html))
- [Query Plan Caching](https://awesome-repositories.com/f/data-databases/query-caching-strategies/query-plan-caching.md) — Caches the translation of high-level DQL into vendor-specific SQL to avoid repeated parsing. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/caching.html))
- [Query Expression Builders](https://awesome-repositories.com/f/data-databases/query-expression-builders.md) — Provides a set of expression helpers to build dynamic conditional logic for query filters. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/query-builder.html))
- [Query Language Extensions](https://awesome-repositories.com/f/data-databases/query-language-extensions.md) — Allows adding custom functions and walkers to the query language to support complex business logic. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/index.html))
- [Array Result Fetches](https://awesome-repositories.com/f/data-databases/query-result-fetching/array-result-fetches.md) — Supports retrieving query results as associative arrays for improved performance and simplified access. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/tutorials/getting-started.html))
- [Pagination](https://awesome-repositories.com/f/data-databases/query-result-fetching/pagination.md) — Supports retrieving data subsets from large result sets using offset and limit parameters. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/tutorials/pagination.html))
- [Result Streaming](https://awesome-repositories.com/f/data-databases/query-result-fetching/result-streaming.md) — Implements incremental result streaming via cursors to process massive datasets without exhausting memory. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/batch-processing.html))
- [Query Filters](https://awesome-repositories.com/f/data-databases/query-sorting/query-filters.md) — Provides mechanisms to apply conditional logic and range-based constraints to filter database query results. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/query-builder.html))
- [Inheritance-Based Filtering](https://awesome-repositories.com/f/data-databases/query-sorting/query-filters/inheritance-based-filtering.md) — Provides a specialized query construct to retrieve specific subclasses from an entity inheritance hierarchy. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/inheritance-mapping.html))
- [Entity Associations](https://awesome-repositories.com/f/data-databases/relational-data-modeling/entity-associations.md) — Defines unidirectional and bidirectional relationships between data entities that synchronize with the database. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/working-with-associations.html))
- [Database Constraints](https://awesome-repositories.com/f/data-databases/schema-enforcement-tools/validation-constraints/database-constraints.md) — Allows the definition of uniqueness and non-nullability constraints enforced at the database level. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/xml-mapping.html))
- [Schema Generators](https://awesome-repositories.com/f/data-databases/schema-generators.md) — Analyzes entity models and metadata to generate the corresponding relational database schema. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/tutorials/getting-started.html))
- [SQL Execution Logging](https://awesome-repositories.com/f/data-databases/sql-execution-logging.md) — Ships a mechanism to record all executed SQL statements for debugging purposes via a custom logger. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/advanced-configuration.html))
- [SQL Query Execution](https://awesome-repositories.com/f/data-databases/sql-query-execution.md) — Allows execution of native SQL statements and maps the resulting row sets back into objects. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/working-with-objects.html))
- [Many-to-Many Join Tables](https://awesome-repositories.com/f/data-databases/storage-configuration/table-level-storage-formats/table-storage-option-modifications/table-creations/join/many-to-many-join-tables.md) — Handles intermediary tables that connect multiple records from two different objects. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/association-mapping.html))
- [Object Mappings](https://awesome-repositories.com/f/data-databases/table-definitions/object-mappings.md) — Allows specifying database mapping metadata programmatically using code and attributes within object classes. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/php-mapping.html))
- [Bulk Update Utilities](https://awesome-repositories.com/f/data-databases/update-operations/bulk-update-utilities.md) — Provides utilities for performing batch modifications on database records to improve performance. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/dql-doctrine-query-language.html))
- [Value Object Embedding](https://awesome-repositories.com/f/data-databases/value-object-embedding.md) — Inlines value object properties as columns within a single object table. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/attributes-reference.html))

### Security & Cryptography

- [Parameterized Query Bindings](https://awesome-repositories.com/f/security-cryptography/sql-injection-prevention/parameterized-query-bindings.md) — Implements parameterized query bindings to separate SQL logic from user input, preventing SQL injection attacks. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/query-builder.html))
- [Optimistic Locking](https://awesome-repositories.com/f/security-cryptography/row-level-security/concurrency-locking/optimistic-locking.md) — Implements optimistic locking using version columns to prevent concurrent update conflicts. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/cookbook/aggregate-fields.html))
- [SQL Injection Prevention](https://awesome-repositories.com/f/security-cryptography/sql-injection-prevention.md) — Uses prepared statement parameters to protect database queries from SQL injection attacks. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/security.html))

### Software Engineering & Architecture

- [Custom Repository Implementations](https://awesome-repositories.com/f/software-engineering-architecture/custom-repository-implementations.md) — Enables the creation of custom repository classes to centralize specialized data retrieval logic. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/working-with-objects.html))
- [Data Mappers](https://awesome-repositories.com/f/software-engineering-architecture/data-mappers.md) — Implements the data mapper pattern to decouple the in-memory object model from the database schema.
- [Identity Map Patterns](https://awesome-repositories.com/f/software-engineering-architecture/identity-map-patterns.md) — Ensures a single instance of an object is returned for every request of a specific key. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/unitofwork.html))
- [Persistence State Management](https://awesome-repositories.com/f/software-engineering-architecture/persistence-state-management.md) — Tracks whether an object is new, managed, detached, or removed for synchronization. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/architecture.html))
- [Unit of Work Patterns](https://awesome-repositories.com/f/software-engineering-architecture/unit-of-work-patterns.md) — Implements the Unit of Work pattern to coordinate atomic database transactions for all tracked object changes.
- [Database Schema Migrations](https://awesome-repositories.com/f/software-engineering-architecture/data-migrators/database-schema-migrations.md) — Ships a system for tracking and applying versioned schema migrations to maintain environment consistency. ([source](http://www.doctrine-project.org/))
- [Lifecycle Callbacks](https://awesome-repositories.com/f/software-engineering-architecture/lifecycle-callbacks.md) — Allows executing custom methods on objects automatically during persistence events like pre-persist or post-load. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/xml-mapping.html))
- [Persistence Cascades](https://awesome-repositories.com/f/software-engineering-architecture/persistence-cascades.md) — Implements a mechanism to propagate persistence operations from parent objects to their associated children. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/xml-mapping.html))

### Development Tools & Productivity

- [Entity Detachment](https://awesome-repositories.com/f/development-tools-productivity/change-tracking/entity-tracking/entity-detachment.md) — Removes objects from management so changes are no longer synchronized to the database. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/working-with-objects.html))

### DevOps & Infrastructure

- [Second-Level Caches](https://awesome-repositories.com/f/devops-infrastructure/caching-layers/second-level-caches.md) — Implements a second-level cache to store frequently accessed entities and reduce database load.

### Programming Languages & Runtimes

- [Entity Proxy](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-class-creation/class-loading-mechanisms/lazy-loading/entity-proxy.md) — Uses proxy objects to implement lazy loading of associations, reducing initial database load.

### Web Development

- [Persistence Lifecycle Events](https://awesome-repositories.com/f/web-development/persistence-lifecycle-events.md) — Triggers custom logic automatically during the creation, update, or deletion of managed entities. ([source](https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/best-practices.html))