Sign In Start for Free
Start for Free
Examples of Object Relational Mappers for Different Languages

What is an Object Relational Mapper? Object Relational Mapping (ORM) is a programming technique that bridges the gap between object-oriented programming languages and relational databases. By allowing developers to work with objects and classes instead of raw SQL queries, ORMs significantly simplify and accelerate the development process. In modern software development, ORMs are indispensable for enhancing productivity, reducing boilerplate code, and ensuring database independence. Given the diversity of programming languages, specific ORM tools are essential to cater to the unique needs of each language, making them a crucial component in the developer’s toolkit.

What is an Object Relational Mapper

Definition and Purpose

Object Relational Mapping (ORM) is a powerful programming technique that bridges the gap between object-oriented programming languages and relational databases. But what is an object relational mapper, exactly? At its core, an ORM is an application API layer that connects an object-oriented system to a relational database using SQL as its primary query language. This layer translates API calls in the programming language of your choice into SQL code, effectively converting procedural code (like Python or Java) into declarative code (SQL).

How ORMs Work

ORMs work by mapping the objects in your code to the tables in your database. This mapping allows developers to interact with the database using the same object-oriented principles they use in their code. For instance, instead of writing raw SQL queries to fetch data, you can use methods and properties of objects. This abstraction minimizes the need to deal directly with database-specific syntax and intricacies, making the development process more intuitive and less error-prone.

Database Expert: “In general, an ORM is an application API layer that connects an object-oriented system to a relational database that uses SQL as its primary query language.”

Benefits of Using ORMs

The benefits of using ORMs are numerous:

  • Simplified Development: By allowing developers to work with objects and classes instead of raw SQL queries, ORMs significantly simplify and accelerate the development process.
  • Database Independence: ORMs provide a layer of abstraction that makes it easier to switch between different database systems without changing the underlying code.
  • Reduced Boilerplate Code: With ORM, engineers omit writing boilerplate SQL commands and can reuse the code multiple times, which enhances productivity.
  • Enhanced Security: ORM tools often come with built-in security features to prevent SQL injection attacks, a common security vulnerability in database-driven applications.

Importance in Modern Software Development

In modern software development, ORMs have become indispensable tools for several reasons.

Enhancing Productivity

ORMs enhance productivity by allowing developers to focus more on business logic rather than on building queries. This is particularly beneficial at the start of a project when rapid development is crucial. As one Productivity Expert noted, “With ORM, engineers omit writing boilerplate SQL commands and can reuse the code multiple times. As a result, they become more productive.”

Reducing Boilerplate Code

Another significant advantage of ORMs is the reduction of boilerplate code. By abstracting the database interactions, ORMs eliminate the need for repetitive SQL code, allowing developers to write cleaner and more maintainable code. This not only speeds up the development process but also reduces the likelihood of errors.

Software Development Expert: “Developers use ORMs for several reasons. Firstly, it simplifies and accelerates the development process by allowing them to work with objects and classes in the programming language rather than writing SQL queries.”

Python ORMs

Python ORMs

Python, known for its simplicity and readability, boasts several powerful ORM frameworks. Among the most popular are SQLAlchemy and Django ORM. These tools provide robust solutions for database interactions, making them indispensable for Python developers.

SQLAlchemy

Overview and Features

SQLAlchemy is a versatile and powerful ORM framework for Python. It supports a wide variety of databases, including SQLite, PostgreSQL, MySQL & MariaDB, and Oracle. One of its standout features is its flexibility; it offers both an ORM and a SQL expression language, allowing developers to choose the level of abstraction they need.

  • Database Support: SQLite, PostgreSQL, MySQL & MariaDB, Oracle
  • Flexibility: Offers both ORM and SQL expression language
  • Installation: Easily installable via pip install SQLAlchemy==1.4.44

Database Expert: “SQLAlchemy provides a full suite of well-known enterprise-level persistence patterns, making it a go-to choice for complex database interactions.”

Advantages and Disadvantages

Advantages:

  • Flexibility: Allows for both high-level ORM operations and low-level SQL expressions.
  • Wide Database Support: Compatible with multiple database systems.
  • Powerful Query Construction: Provides a rich set of features for building complex queries.

Disadvantages:

  • Learning Curve: Can be complex for beginners due to its extensive feature set.
  • Verbose Syntax: Sometimes requires more code compared to other ORMs.

Practical Implementation Example

Here’s a simple example of how to use SQLAlchemy to interact with a database:

from sqlalchemy import create_engine, Column, Integer, String, Sequence
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# Define the database engine
engine = create_engine('mysql+pymysql://user:password@localhost/mydatabase')

# Define the base class for models
Base = declarative_base()

# Define a User model
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, Sequence('user_id_seq'), primary_key=True)
    name = Column(String(50))
    age = Column(Integer)

# Create the table
Base.metadata.create_all(engine)

# Create a new session
Session = sessionmaker(bind=engine)
session = Session()

# Add a new user
new_user = User(name='John Doe', age=30)
session.add(new_user)
session.commit()

Django ORM

Overview and Features

Django ORM is an integral part of the Django web framework. It provides a straightforward way to interact with a range of SQL databases using Python. One of its key features is its ability to automatically generate scripts for data migration, simplifying schema changes.

  • Integration: Embedded within the Django web framework
  • Automatic Migrations: Automatically writes scripts for data migration
  • Installation: Part of the Django package, installable via pip install django

Software Development Expert: “Django ORM pulls tables into object wrappers, making database interactions seamless and intuitive for developers.”

Advantages and Disadvantages

Advantages:

  • Ease of Use: Simplifies database interactions with a high-level API.
  • Automatic Migrations: Facilitates schema changes without manual intervention.
  • Strong Community Support: Extensive documentation and active community.

Disadvantages:

  • Less Flexibility: Compared to SQLAlchemy, it offers less control over SQL queries.
  • Tightly Coupled: Works best within the Django framework, limiting its use in non-Django projects.

Practical Implementation Example

Here’s a basic example of using Django ORM to manage database records:

# models.py
from django.db import models

class User(models.Model):
    name = models.CharField(max_length=50)
    age = models.IntegerField()

# In the Django shell or a view
from myapp.models import User

# Create a new user
new_user = User(name='Jane Doe', age=25)
new_user.save()

# Query users
users = User.objects.all()
for user in users:
    print(user.name, user.age)

Java ORMs

Java, a robust and versatile programming language, has several powerful ORM frameworks that simplify database interactions. Among the most prominent are Hibernate and EclipseLink. These tools provide extensive features and capabilities, making them indispensable for Java developers.

Hibernate

Overview and Features

Hibernate is one of the most mature and widely used ORM tools in the Java ecosystem. It supports almost all relational databases and is known for its stability, scalability, and extensive community support. Hibernate uses its own query language, Hibernate Query Language (HQL), which is similar to SQL but operates on the entity objects rather than the database tables.

  • Database Support: Compatible with almost all relational databases.
  • Query Language: Uses Hibernate Query Language (HQL).
  • Proprietary Features: Extended support for natural IDs, loading multiple entities by their primary key, management of creation and update timestamps, joining unassociated entities in queries, and multi-tenancy support.
  • Installation: Easily integrated into Java projects via Maven or Gradle dependencies.

Database Expert: “Hibernate provides a bunch of interesting, proprietary features like extended support for natural IDs and multi-tenancy, making it a go-to choice for complex database interactions.”

Advantages and Disadvantages

Advantages:

  • Mature and Stable: One of the most established ORM tools with a large user base.
  • Extensive Community Support: A vast forum for support and resources.
  • Powerful Features: Offers advanced features like multi-tenancy and complex relationship handling.

Disadvantages:

  • Performance Overhead: Can be slower compared to other ORMs due to its extensive feature set.
  • Complex Configuration: Requires more setup and configuration, which can be daunting for beginners.

Practical Implementation Example

Here’s a simple example of how to use Hibernate to interact with a database:

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private int age;

    // Getters and setters
}

public class HibernateExample {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration()
                                 .configure("hibernate.cfg.xml")
                                 .addAnnotatedClass(User.class)
                                 .buildSessionFactory();

        Session session = factory.getCurrentSession();
        try {
            User newUser = new User();
            newUser.setName("John Doe");
            newUser.setAge(30);

            session.beginTransaction();
            session.save(newUser);
            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

EclipseLink

Overview and Features

EclipseLink is another popular open-source ORM tool for Java. It is the reference implementation for JPA 2, making it highly standards-compliant. EclipseLink offers several interesting, proprietary features like handling database change events, composite persistence units, and multi-tenancy support. It also enables interaction with non-relational databases like Oracle NoSQL and MongoDB via the JPA connection.

  • Standards Compliance: Reference implementation for JPA 2.
  • Database Support: Supports both relational and non-relational databases.
  • Proprietary Features: Handling of database change events, composite persistence units, and multi-tenancy.
  • Query Language: Uses Jakarta Persistence Query Language (JPQL).
  • Installation: Easily integrated into Java projects via Maven or Gradle dependencies.

Software Development Expert: “EclipseLink offers several interesting, proprietary features like handling of database change events and support for multi-tenancy, making it a versatile choice for various database interactions.”

Advantages and Disadvantages

Advantages:

  • Standards Compliant: As the reference implementation for JPA 2, it ensures compatibility with JPA standards.
  • Versatile Database Support: Can interact with both relational and non-relational databases.
  • Advanced Features: Offers unique features like composite persistence units and database change event handling.

Disadvantages:

  • Performance: While powerful, it may not perform as well as Hibernate in some scenarios.
  • Complexity: The extensive feature set can make it more complex to configure and use.

Practical Implementation Example

Here’s a basic example of using EclipseLink to manage database records:

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private int age;

    // Getters and setters
}

public class EclipseLinkExample {
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("my-persistence-unit");
        EntityManager em = emf.createEntityManager();

        try {
            em.getTransaction().begin();
            User newUser = new User();
            newUser.setName("Jane Doe");
            newUser.setAge(25);

            em.persist(newUser);
            em.getTransaction().commit();
        } finally {
            em.close();
            emf.close();
        }
    }
}

C# ORMs

C# is a versatile and widely-used programming language, particularly in enterprise environments. It boasts several ORM frameworks that streamline database interactions, with Entity Framework and Dapper being among the most prominent. These tools offer unique features and benefits, making them essential for C# developers.

Entity Framework

Overview and Features

Entity Framework is a feature-rich ORM framework developed by Microsoft. It emphasizes productivity and abstraction, allowing developers to work with data using .NET objects, eliminating the need for most of the data-access code they would typically have to write. Entity Framework supports LINQ (Language Integrated Query), enabling developers to write queries using their preferred .NET language.

  • Database Support: Compatible with SQL Server, SQLite, PostgreSQL, MySQL, and more.
  • Productivity: High-level abstraction simplifies data manipulation.
  • LINQ Integration: Write queries using C# or other .NET languages.
  • Automatic Migrations: Simplifies schema changes and versioning.
  • Installation: Easily integrated into .NET projects via NuGet package manager.

Software Development Expert: “Entity Framework provides a high level of abstraction, making it easier for developers to interact with databases without writing extensive SQL queries.”

Advantages and Disadvantages

Advantages:

  • Ease of Use: Simplifies data access with high-level abstractions.
  • Productivity: Reduces boilerplate code, speeding up development.
  • Rich Feature Set: Supports complex queries, relationships, and lazy loading.
  • Community Support: Extensive documentation and active community.

Disadvantages:

  • Performance Overhead: Can be slower compared to more lightweight ORMs.
  • Learning Curve: May require time to master its extensive feature set.
  • Resource Intensive: Consumes more resources than micro-ORMs like Dapper.

Practical Implementation Example

Here’s a simple example of how to use Entity Framework to interact with a database:

using System;
using System.Linq;
using Microsoft.EntityFrameworkCore;

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

public class AppDbContext : DbContext
{
    public DbSet<User> Users { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("Server=your_server;Database=your_database;User Id=your_user;Password=your_password;");
    }
}

class Program
{
    static void Main()
    {
        using (var context = new AppDbContext())
        {
            // Add a new user
            var newUser = new User { Name = "John Doe", Age = 30 };
            context.Users.Add(newUser);
            context.SaveChanges();

            // Query users
            var users = context.Users.ToList();
            users.ForEach(user => Console.WriteLine($"{user.Name}, {user.Age}"));
        }
    }
}

Dapper

Overview and Features

Dapper is a micro-ORM developed by Stack Exchange. It is known for its speed and efficiency, providing significant performance gains over more feature-rich ORMs like Entity Framework. Dapper focuses on direct mapping and raw SQL queries, offering better performance in scenarios requiring high throughput or strict performance requirements.

  • Database Support: Compatible with SQL Server, SQLite, PostgreSQL, MySQL, and more.
  • Performance: One of the fastest micro-ORMs available for .NET.
  • Lightweight: Minimal overhead, making it less resource-intensive.
  • Direct SQL Queries: Allows developers to leverage their SQL skills.
  • Installation: Easily integrated into .NET projects via NuGet package manager.

Database Expert: “Dapper is closer to ‘the metal’ than standard ORMs, providing significant performance gains, especially when large amounts of data are queried.”

Advantages and Disadvantages

Advantages:

  • High Performance: Faster than Entity Framework due to its lightweight nature.
  • Flexibility: Directly uses raw SQL queries, giving developers full control.
  • Minimal Overhead: Less resource-intensive, ideal for performance-critical applications.
  • Ease of Use: Simple API for quick integration and usage.

Disadvantages:

  • Less Abstraction: Requires more manual handling of SQL queries.
  • Limited Features: Lacks some advanced features found in more comprehensive ORMs.
  • Manual Mapping: Developers need to handle object-to-table mappings manually.

Practical Implementation Example

Here’s a basic example of using Dapper to manage database records:

using System;
using System.Data.SqlClient;
using Dapper;

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

class Program
{
    static void Main()
    {
        using (var connection = new SqlConnection("Server=your_server;Database=your_database;User Id=your_user;Password=your_password;"))
        {
            connection.Open();

            // Add a new user
            var newUser = new User { Name = "Jane Doe", Age = 25 };
            var insertQuery = "INSERT INTO Users (Name, Age) VALUES (@Name, @Age)";
            connection.Execute(insertQuery, newUser);

            // Query users
            var users = connection.Query<User>("SELECT * FROM Users");
            foreach (var user in users)
            {
                Console.WriteLine($"{user.Name}, {user.Age}");
            }
        }
    }
}

Ruby ORMs

Ruby, known for its elegant syntax and developer-friendly environment, offers several ORM frameworks that simplify database interactions. Among the most popular are ActiveRecord and Sequel. These tools provide robust solutions for managing database operations, making them essential for Ruby developers.

ActiveRecord

Overview and Features

ActiveRecord is the default ORM framework integrated into the Ruby on Rails web framework. It provides a high level of abstraction, allowing developers to interact with databases using Ruby objects rather than writing raw SQL queries. This makes it incredibly beginner-friendly, as it hides complex SQL operations under the hood.

  • Integration: Embedded within the Ruby on Rails framework.
  • Automatic Migrations: Simplifies schema changes by automatically generating migration scripts.
  • Associations: Supports complex relationships between models (e.g., has_many, belongs_to).
  • Callbacks: Allows for hooks into the lifecycle of an object (e.g., before_save, after_create).

Database Expert: “ActiveRecord is very beginner-friendly, in that, it conveniently hides complex SQL queries under the hood.”

Advantages and Disadvantages

Advantages:

  • Ease of Use: Simplifies database interactions with a high-level API.
  • Rails Integration: Seamlessly integrates with Ruby on Rails, providing a cohesive development experience.
  • Community Support: Extensive documentation and a large, active community.

Disadvantages:

  • Less Flexibility: May be limiting for advanced users who prefer direct SQL control.
  • Performance Overhead: Can be slower compared to more lightweight ORMs.
  • Limited Features: Lacks some advanced features like query proxying without additional gems.

Practical Implementation Example

Here’s a basic example of using ActiveRecord to manage database records:

# Gemfile
gem 'activerecord', '~> 6.1'
gem 'sqlite3'

# Run bundle install to install the gems

# config/database.yml
default: &default
  adapter: sqlite3
  pool: 5
  timeout: 5000

development:
  <<: *default
  database: db/development.sqlite3

# app/models/user.rb
class User < ActiveRecord::Base
  validates :name, presence: true
end

# Creating a new user in the Rails console
user = User.new(name: 'John Doe', age: 30)
user.save

# Querying users
users = User.all
users.each do |user|
  puts "#{user.name}, #{user.age}"
end

Sequel

Overview and Features

Sequel is a powerful and flexible ORM library for Ruby. Unlike ActiveRecord, Sequel is not tied to any specific web framework, making it a versatile choice for various types of Ruby applications. It offers a rich set of features, including support for complex queries, dataset chaining, and advanced database operations.

  • Framework Agnostic: Can be used with any Ruby application, not just Rails.
  • Dataset Chaining: Allows for building complex queries through method chaining.
  • Advanced Features: Supports transactions, connection pooling, and custom SQL functions.
  • Installation: Easily installable via gem install sequel.

Software Development Expert: “Sequel is really a much better library than ActiveRecord objectively. I strongly believe ActiveRecord is popular because of Rails.”

Advantages and Disadvantages

Advantages:

  • Flexibility: Offers more control over SQL queries and database interactions.
  • Performance: Generally faster and more efficient than ActiveRecord.
  • Rich Feature Set: Includes advanced features like dataset chaining and custom SQL functions.

Disadvantages:

  • Learning Curve: Can be more complex for beginners due to its extensive feature set.
  • Less Integration: Does not integrate as seamlessly with Rails as ActiveRecord.

Practical Implementation Example

Here’s a basic example of using Sequel to manage database records:

# Gemfile
gem 'sequel'
gem 'sqlite3'

# Run bundle install to install the gems

# config/database.rb
require 'sequel'

DB = Sequel.sqlite('db/development.sqlite3')

# app/models/user.rb
DB.create_table :users do
  primary_key :id
  String :name
  Integer :age
end

class User < Sequel::Model
  plugin :validation_helpers

  def validate
    super
    validates_presence [:name]
  end
end

# Creating a new user
user = User.new(name: 'Jane Doe', age: 25)
user.save

# Querying users
users = User.all
users.each do |user|
  puts "#{user.name}, #{user.age}"
end

Both ActiveRecord and Sequel offer unique advantages and cater to different needs. While ActiveRecord is ideal for those seeking seamless integration with Ruby on Rails, Sequel provides greater flexibility and performance for more complex database interactions.

ORMs Supported by TiDB

TiDB, renowned for its MySQL compatibility and distributed SQL capabilities, supports a variety of ORM frameworks across different programming languages. This section delves into the specific ORM frameworks that seamlessly integrate with TiDB, enhancing database interactions and development efficiency.

Java ORM Frameworks

Hibernate

Hibernate is a robust and mature ORM framework widely used in the Java ecosystem. It simplifies database interactions by mapping Java objects to database tables, allowing developers to focus on business logic rather than SQL queries. Hibernate’s compatibility with TiDB ensures that you can leverage its powerful features while benefiting from TiDB’s distributed architecture.

  • Support Level: Full
  • Latest Tested Version: 6.1.0.Final
  • Key Features:
    • Supports complex relationships and inheritance hierarchies.
    • Provides a powerful query language (HQL) and criteria API.
    • Integrates seamlessly with the Spring Framework.
    • Offers caching mechanisms to enhance performance.

Technical Note: For optimal performance with TiDB, use Hibernate 6.0.0.Beta2 or above, and include the necessary dependencies in your Maven or Gradle build files.

MyBatis

MyBatis is another popular Java ORM framework that provides fine-grained control over SQL execution. Unlike Hibernate, MyBatis focuses on SQL mapping and execution, making it ideal for scenarios where you need precise control over your database queries.

  • Support Level: Full
  • Latest Tested Version: 3.5.10
  • Key Features:
    • Supports dynamic SQL generation.
    • Allows for flexible configuration of complex queries.
    • Reduces the risk of SQL injection through parameterized queries.
    • Integrates well with the Spring Framework.

Example Use Case: MyBatis is particularly useful in applications requiring complex query configurations and dynamic SQL generation, ensuring robust and secure database interactions.

Python ORM Frameworks

Django

Django ORM is an integral part of the Django web framework, providing a high-level abstraction for database operations. Its compatibility with TiDB allows developers to build scalable and efficient web applications with ease.

  • Support Level: Full
  • Latest Tested Version: 4.2
  • Key Features:
    • Built-in admin interface for managing application data.
    • Supports migrations for seamless schema changes.
    • Provides a high-level API for database operations.

Installation Tip: Use the django-tidb dialect for compatibility with TiDB. Install it via pip install django-tidb.

SQLAlchemy

SQLAlchemy is a versatile ORM framework for Python, offering both high-level ORM operations and low-level SQL expressions. Its flexibility makes it a preferred choice for developers working with TiDB.

  • Support Level: Full
  • Latest Tested Version: 1.4.37
  • Key Features:
    • Supports multiple database systems, including MySQL and PostgreSQL.
    • Provides a rich set of features for building complex queries.
    • Allows for both ORM and SQL expression language operations.

Implementation Example: To connect to TiDB using SQLAlchemy, install the package via pip install SQLAlchemy==1.4.44.

JavaScript/TypeScript ORM Frameworks

Sequelize

Sequelize is a promise-based ORM for Node.js, supporting various SQL databases, including MySQL. Its integration with TiDB allows JavaScript developers to build scalable applications with ease.

  • Support Level: Full
  • Latest Tested Version: 6.20.1
  • Key Features:
    • Supports multiple database systems.
    • Provides a rich set of features for model definition and query construction.
    • Offers migration and seeder support for database management.

Practical Tip: Sequelize integrates well with Express.js, making it a powerful tool for building RESTful APIs with TiDB.

TypeORM

TypeORM is a feature-rich ORM for TypeScript and JavaScript, supporting both Active Record and Data Mapper patterns. Its compatibility with TiDB ensures type-safe database operations and seamless integration with various Node.js frameworks.

  • Support Level: Full
  • Latest Tested Version: 0.3.17
  • Key Features:
    • Provides a powerful query builder.
    • Supports migrations and CLI tools.
    • Allows for type-safe database operations in TypeScript.

Example Use Case: TypeORM is ideal for developers seeking a type-safe ORM solution for Node.js applications, leveraging TiDB’s distributed capabilities for scalable and efficient database interactions.

By supporting these diverse ORM frameworks, TiDB empowers developers across various programming languages to build robust, scalable, and efficient applications. Whether you’re working with Java, Python, or JavaScript/TypeScript, TiDB’s compatibility ensures seamless integration and enhanced productivity.

Choosing the right ORM for your specific programming language is crucial for optimizing your development workflow. ORMs simplify database interactions and enhance code maintainability by allowing developers to work in a single language, thus saving valuable training time and providing a more straightforward code base and documentation. These tools also help separate database design from object-oriented design, making it easier to read and write data to the database.

ORMs significantly impact software development efficiency and maintainability. They come with extensive functionality that boosts productivity and embedded mechanisms to address performance issues. By simplifying the process of passing data between an application and its data store, ORMs make development more intuitive and less error-prone.

We encourage you to explore and experiment with different ORMs to find the best fit for your individual projects. Each ORM has its unique strengths and weaknesses, and understanding these will help you make informed decisions tailored to your application’s specific needs.

See Also

Resolving the Argument Between Relational and Non-Relational Databases

Navigating the Era of LLM: Storing Vectors Using MySQL SQL Syntax

Transforming MySQL Database Interactions Through Text-to-SQL and LLMs

Incorporating OpenAI with MySQL: Cutting-Edge Web App Functionalities

Unveiling Database Normalization Through Comprehensive Illustrations


Last updated July 18, 2024