How to Implement a One-to-One Relationship in SQLAlchemy and Execute a Query

What will you learn?

In this tutorial, you will master the art of establishing a one-to-one relationship between two tables using SQLAlchemy. You will also gain expertise in executing queries on these interlinked tables with precision.

Introduction to the Problem and Solution

When working with databases in SQLAlchemy, defining relationships between tables is paramount for effectively retrieving related data. A one-to-one (1..1) relationship signifies that each entry in one table corresponds to precisely one record in another table. This type of relationship proves beneficial when specific data pieces are closely related but stored separately for organizational purposes.

To create a one-to-one relationship in SQLAlchemy, it is crucial to define the necessary foreign key constraints between the involved tables. By appropriately configuring these relationships, you can seamlessly write queries that retrieve associated data from both tables.


# Define the two tables with a one-to-one relationship

from sqlalchemy import Column, Integer, String, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    name = Column(String)

    address = relationship("Address", uselist=False)

class Address(Base):
    __tablename__ = 'addresses'

    id = Column(Integer, primary_key=True)
    email_address = Column(String)

    user_id = Column(Integer, ForeignKey(''))

# Executing a query on the one-to-one related tables

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine('sqlite:///:memory:')

Session = sessionmaker(bind=engine)
session = Session()

user1 = User(name='Alice', address=Address(email_address=''))

# - Providing assistance with Python programming questions

# Copyright PHD


  • Defining Tables: Utilize SQLAlchemy’s declarative_base function to define the User and Address classes representing database tables.

  • Relationship Configuration: Use the relationship function within the User class to specify its association with the Address class. Setting uselist=False denotes a one-to-one relationship.

  • Foreign Key Constraint: The ForeignKey function establishes a linkage between the user_id column in Address and the id column in User.

  • Executing Queries: After setting up our tables and inserting sample data into them, we can seamlessly query records across both tables using sessions provided by SQLAlchemy.

    How do I define a one-to-one relationship in SQLAlchemy?

    To establish a 1..1 relationship between two entities in SQLAlchemy, you need to utilize the relationship function along with proper foreign key definitions.

    Can there be multiple records linked together in a 1..1 relationship?

    No, by definition of a 1..1 (one-to-one) mapping each record from one entity should correspond to exactly one record from another entity.

    What does “uselist=False” signify when defining an SQLAchemy relation?

    Setting uselist=False indicates that this relation represents at most one item or no items rather than returning results as lists or collections.

    How do I create instances of associated objects while adding new records?

    Creating new instances of parent objects like User which have associations like Address specified via relationships already defined within their respective classes allows us to effortlessly link them during object creation itself.

    Is it possible for either side of this relation (User or Address)to not have corresponding entries?

    Yes, depending on your application logic structure it’s possible for either side of this relation not have their counterpart entry due various reasons including optional nature or deletion scenarios etc.

    What happens if I try insert conflicting records violating this unique constraint setup?

    If you attempt inserting duplicate or conflicting entries which violate uniqueness constraints enforced due presence of such 11 relations setups an error would be raised preventing such additions.

    Can I change an existing record’s association after its been created initially?

    Yes , changing an existing record’s association after initial creation is possible depending upon framework specifics however its recommended such changes are done cautiously keeping referential integrity needs intact.

    Are circular dependencies allowed when setting up these relations?

    Circular dependencies might introduce complexities hence its advised against introducing these as they could impact cascading operations among other things negatively.


    In conclusion, mastering how to set up and query data from database tables having a one-to-one (1..1) mapping using SQLAlchemy is essential. Understanding how relationships operate within ORM frameworks like SQLAlchemy is critical for efficiently retrieving and managing interconnected data structures.

    Leave a Comment