Simplify and improve data access code using ActiveRecord design pattern | Video tutorial collection

The Active Record design pattern is a popular architectural pattern used to manage and interact with data stored in a database. This pattern provides a straightforward way to encapsulate database records as objects, allowing developers to work with data using object-oriented principles.

Active Record: Introduction and first adopters

Active Record was introduced by Martin Fowler in his 2003 book “Patterns of Enterprise Application Architecture.” This pattern falls under the broader Model-View-Controller (MVC) architectural design. Active Record’s essence lies in representing a database table as a class, linking instances of that class to rows in the table, and enabling easy interaction between objects and relational databases.

The primary goal of Active Record is to simplify database operations by providing an intuitive object-oriented interface. It abstracts away the need to write raw SQL queries for CRUD (Create, Read, Update, Delete) operations, making code more readable and maintainable.

Ruby on Rails, a popular web framework, adopted and popularized the Active Record pattern. The framework was released in 2004 and gained widespread recognition for its implementation of Active Record, offering developers an efficient way to work with databases. DHH (David Heinemeier Hansson), the creator of Ruby on Rails, played a significant role in implementing and advocating Active Record’s usage.

Thus, Active Record emerged in the early 2000s as a groundbreaking concept, revolutionizing how developers interact with databases in a more streamlined and object-oriented manner.

Can a Delphi developer benefits from Active Record? Let’s analyze the key features and judge for yourself.

Key Features of Active Record

The key features of the Active Record pattern include:

✅ Single Responsibility: Each active record object represents a single database table row. This means that the object is responsible for both data representation and data manipulation related to that row.

✅ Encapsulation: The active record object hides the complexity of database operations behind its methods and properties. This encapsulation makes it easier to work with the data without directly dealing with SQL queries or database connections.

✅ Data Mapping: Active record objects usually include methods for CRUD (Create, Read, Update, Delete) operations. These methods handle the translation between object-oriented operations and database operations.

✅ Validation: Active record objects often include validation rules to ensure that only valid data is saved to the database. This helps maintain data integrity and consistency.

✅ Relationships: Active record objects can also handle relationships between different tables. For instance, if you have a Customers table and an Orders table, the Customers active record object might have methods to retrieve related orders.

✅ Persistence: Active record objects manage their own persistence, meaning they know how to load and save themselves to the database.

⚠️ ActiveRecord is (obviously) not DataMapper.

💬 The biggest difference between the data mapper pattern and the active record pattern is that the data mapper is meant to be a layer between the actual business domain of your application and the database that persists its data. Where active record seeks to invisibly bridge the gaps between the two as seamlessly as possible, the role of the data mapper is to allow you to consider the two more independently.

I strongly believe that both the Active Record and the Data Mapper patterns have a place within our developer tool belts. I think it is wrong to categorically say that one pattern is better than the other. As always “it depends”.

Photo by mcmurryjulie from Pixabay

How a Delphi developer can get strategic benefits using Active Record

For a Delphi developer, the Active Record design pattern can be particularly useful for several reasons:

✅ Simplicity: The pattern provides a simple and intuitive way to work with database records as objects, aligning with the object-oriented nature of Delphi programming.

✅ Reduced Code: By encapsulating database operations within the active record objects, developers can write less code for database interaction, making the codebase cleaner and more maintainable.

✅ Consistency: Active record objects provide a consistent interface for working with different database tables, making it easier to learn and work with the application’s data layer.

✅ Productivity: The pattern can lead to increased productivity since developers spend less time writing repetitive database code and more time focusing on business logic.

✅ Testing: Active record objects can be unit tested more easily, as they encapsulate database interactions. This makes it simpler to write functional integration tests for data-related functionality. Moreover, it’s possibile to use a smaller/lighter database engine than the one used in production.

✅ Flexibility: While Delphi also offers other database-related patterns like Data Mapper, Active Record is well-suited for CRUD oriented applications or situations where simplicity and speed of development is a priority.

In conclusion, the Active Record design pattern is a valuable tool in the Delphi developer’s toolkit, providing an intuitive and efficient way to interact with databases using object-oriented principles, reducing code complexity, and enhancing overall productivity.

ActiveRecord in DMVCFramework a.k.a. MVCActiveRecord

DMVCFramework natively supports active record pattern with its MVCActiveRecord micro-framework. Accessing data using the objecty oriented approach encouraged by MVCActiveRecord really improves and speeds up application development. If you want to get the benefits MVCActiveRecord can provides here’s some valuable resources:

✅ Active Record Showcase: In the official dmvcframework repository there is a complete sample for all MVCActiveRecord funcionality. Altough this is not a dmvcframework project (that’s it, it doesn’t expose an API) this example is really all what you need to see how MVCActiveRecord works and also make it clear that MVCACtiveRecord can be used in any Delphi project, also not a “classic” dmvcframework project. The Delphi project is called activerecord_showcase and is available here.

✅ Simple API using MVCActiveRecord: In the official dmvcframework repository there is a simple example about a Web API which uses MVCActiveRecord to interact with database. The Delphi project is called simple_api_using_mvcactiverecord and is available here

✅ DMVCFramework - The Official Guide: This is the book about dmvcframework. Chapters 7,8,9 and 10 explain MVCActiveRecord in good detail level. The book is aligned to dmvcframework-3.2.1-carbon. Since then many things have been added to dmvcframework and MVCActiveRecord but the concepts exposed in the book are still valid. You can read a free sample and then, if you like it, buy the full book. The book is avialable also in other languages.

✅ The Upcoming Serie on Patreon for dmvcframework supporters Are you a dmvcframework users? Becoming a Patreon supporter would be great for your skill and business. Keep reading the next section.

The Web Series for Patreon Supporters

In the next weeks I’m going to publish a video series about MVCActiveRecord. Videos will be available only for Patreon supporters.

As a Patreon supporter, you’ll get exclusive access to a range of benefits that will supercharge your development experience with DMVCFramework. You’ll get early access to updates, sneak peeks at new features, and the opportunity to influence the direction of the framework’s development.

But that’s not all! You’ll also have access to in-depth tutorials, workshops, and webinars led by the creators and experts behind dmvcframework. These resources will empower you to master the framework inside out, allowing you to fastly create dynamic and high-performance Web APIs that stand out in today’s competitive landscape.

To have an idea about what you can find today as supporter, check the already published articles.

MVCActiveRecord Mapping Example

Just to show an example, here’s an excerpt of the mapping code from the active_record_showcase sample (which I strongly suggest to get in confidence with the technology).

Full code available here: https://github.com/danieleteti/delphimvcframework/blob/master/samples/activerecord_showcase/EntitiesU.pas

Some mapping examples for the most common cases

Simple R/W table mapping

Mapping queries using NamedSQLQuery and NamedRQLQuery

Default Filtering

Partitioned Mapping

Handling relations

Aggregate Entity

Entity with business logic

Using native complex types (e.g. In PostgreSQL you can use json, jsonb and xml)

Read-Only Entity

OOP Mapping using inheritance: the (in)famous “person, employee, manager” example

Web Serie Contents

If you are interested to know how to use MVCActiveRecord to improve and simplify your data access layer (making it more robust and manageable), the video tutorials in the serie will explain these features (among others):

• Mapping a simple entity to a database table
• Defining connections
• Using auto-generated primary keys
• How to Create, Retrieve, Update and Delete an entity
• Using client-side-generated primary keys
• Using entities in desktop, console and Web API project
• How to handle nullable types
• How to handle relations
• How to map aggregate entities to use in joins
• How to map stored procedures
• What’s RQL and why it make sense
• Using RQL to provide to users filtering over an entity
• Using NamedSQLQuery and NamedRQLQuery
• Default filtering and partitioning

Become a supporter and access to current and future privileged contents!