ERDiagram: Relational Schemas & Crow's Foot Notations

ERDiagram visualizes relational database architectures adhering strictly to Information Engineering (IE) / Crow's Foot notation—the industry standard for physical database schema modeling.

from drawlib.canvas import save, setup
from drawlib.diagrams.er import ERDiagram, Entity
from drawlib.styles import Styles

setup(width=98, height=24)

er = ERDiagram(
    node_style=Styles.Neutral,
    edge_style=Styles.DarkBold,
    edge_text_style=Styles.Dark.patch(text_size=10.5),
)

users = er.add(Entity(name="users", width=32.0), xy=(19.0, 12.0))
users.add_column("id", type="INT", pk=True)
users.add_column("email", type="VARCHAR(255)", nullable=False)
users.add_column("name", type="VARCHAR(100)")

orders = er.add(Entity(name="orders", width=32.0, style=Styles.PrimaryNeutral), xy=(79.0, 12.0))
orders.add_column("id", type="INT", pk=True)
orders.add_column("user_id", type="INT", fk=True)
orders.add_column("total", type="DECIMAL(10,2)", nullable=False)

users.connect(
    orders,
    cardinality="1:*",
    start_side="right",
    end_side="left",
    start_column="id",
    end_column="user_id",
    label="places",
)

er.draw(xy=(0.0, 0.0))
save()

1. Core Concepts & Basic Usage

ERDiagram places relational Entity tables by their Center (cx, cy) via er.add(entity, xy=(cx, cy)), rendering typed schema rows with automatic PK and FK key badges as effective_height expands to fit every column. Relationships draw industry-standard Information Engineering (IE) Crow's Foot cardinality markers, snap directly to primary and foreign key rows via start_column and end_column, and support custom header_style bands, show=False hiding, and align="center" placement:

• Center-Anchored Entity Cards & Key Badges (xy, pk, fk, nullable): er.add(entity, xy=(cx, cy)) places each table by its center while .add_column(...) adds amber PK and blue FK tags and expands effective_height automatically.
• IE Crow's Foot Cardinalities (cardinality): entity.connect(...) and er.connect(...) draw Information Engineering vector markers across all 7 multiplicities ("1:*", "1:1", "1:1..*", "1:0..1", "0..1:1", "0..1:*", "*:*").
• Row-Level Column Anchoring (start_column, end_column): Pin relationship wires directly to specific primary and foreign key rows on "left" / "right" sides instead of generic card midpoints.
• Header Styling, Visibility & Centering (header_style, show=False, align="center"): Accentuate focal tables with header_style, hide entities and incident Crow's Foot wires in place via show=False, or center the schema on xy via align="center".

2. Constructor & Entity Definition

from drawlib.canvas import save, setup
from drawlib.diagrams.er import ERDiagram, Entity
from drawlib.styles import Styles

setup(width=52, height=26)

er = ERDiagram(
    node_style=Styles.Neutral,
    edge_style=Styles.DarkBold,
    edge_text_style=Styles.Dark.patch(text_size=10.5),
    title="User Schema",
    title_style=Styles.BlackBold.patch(text_size=13.5),
    width=52.0,
    height=20.0,
)

# Create entity table
users = er.add(Entity(name="users", width=42.0), xy=(26.0, 10.0))
users.add_column("id", type="INT", pk=True)
users.add_column("email", type="VARCHAR(255)", nullable=False)
users.add_column("created_at", type="TIMESTAMP")

er.draw(xy=(0.0, 0.0))
save()

Parameter Reference Tables

ERDiagram Class

Entity Class

Column Declaration (add_column, add_columns & ColumnInfo)

from drawlib.diagrams.er import ColumnInfo

# Single column & batch column registration
entity.add_column(name: str, type: str = "", pk: bool = False, fk: bool = False, nullable: bool = True) -> Entity
entity.add_columns(
    columns: Sequence[Sequence[Any] | ColumnInfo],
    # Each item is a ColumnInfo or tuple (name, [type, pk, fk, nullable])
) -> Entity

Relationship (entity.connect & er.connect)

Registration, Sizing & Rendering Methods

• er.add(entity, xy=(cx, cy), show: bool | None = None) -> Entity: Places an entity table centered at (cx, cy) and returns the mutable Entity.
• entity.connect(target, cardinality="1:*", ..., show=True) -> Relationship or er.connect(start, end, cardinality="1:*", ..., show=True) -> Relationship (and er.add_relationship(rel) -> Relationship): Connects two entities with Crow's Foot notation and returns a mutable Relationship (rel.show, rel.style, rel.text_style).
• er.get_size() -> tuple[float, float]: Returns the overall (width, height) of the diagram.
• er.draw(xy=(0.0, 0.0), *, scale: float = 1.0) -> None: Renders the ER diagram anchored at bottom-left xy, proportionally scaling table geometry, Crow's Foot markers, and font sizes by scale.

3. Supported Cardinality Notations

from drawlib.canvas import save, setup
from drawlib.diagrams.er import ERDiagram, Entity
from drawlib.styles import Colors, Styles
from drawlib.text import text

setup(width=128, height=96)

er = ERDiagram(
    node_style=Styles.Neutral,
    edge_style=Styles.DarkBold,
    edge_text_style=Styles.Dark.patch(text_size=10.5),
)

# 7 supported Crow's Foot cardinality strings arranged in a clean 2-column catalog
specs = [
    # Left column (x_src=14, x_dst=49)
    ('"1:*"  (One-to-Many)', "1:*", 14.0, 49.0, 80.0, "Parent", "Child"),
    ('"1:1"  (One-to-One)', "1:1", 14.0, 49.0, 57.0, "Parent", "Child"),
    ('"1:1..*"  (Mandatory Child)', "1:1..*", 14.0, 49.0, 34.0, "Parent", "Child"),
    ('"1:0..1"  (Optional Child)', "1:0..1", 14.0, 49.0, 11.0, "Parent", "Child"),
    # Right column (x_src=79, x_dst=114)
    ('"0..1:1"  (Optional Parent 1:1)', "0..1:1", 79.0, 114.0, 80.0, "Parent", "Child"),
    ('"0..1:*"  (Optional Parent 1:N)', "0..1:*", 79.0, 114.0, 57.0, "Parent", "Child"),
    ('"*:*"  (Many-to-Many)', "*:*", 79.0, 114.0, 34.0, "Left", "Right"),
]

lbl_style = Styles.DarkBold.patch(text_size=10.5, text_color=Colors.Primary5)

for _title_str, card, x1, x2, y, src_name, dst_name in specs:
    e_src = er.add(Entity(name=src_name, width=16.0, style=Styles.PrimaryNeutral), xy=(x1, y))
    e_dst = er.add(Entity(name=dst_name, width=16.0, style=Styles.Neutral), xy=(x2, y))
    e_src.connect(e_dst, cardinality=card, start_side="right", end_side="left")

er.draw(xy=(0.0, 0.0))

for title_str, _card, x1, x2, y, _src_name, _dst_name in specs:
    text(((x1 + x2) / 2.0, y + 6.5), title_str, style=lbl_style)

save()

4. E-Commerce Relational Schema with Column Anchors

The following four-table schema (users, orders, order_items, and products) anchors every relationship directly to its primary and foreign key rows:

from drawlib.canvas import save, setup
from drawlib.diagrams.er import ERDiagram, Entity
from drawlib.styles import Styles

setup(width=114, height=82)

er = ERDiagram(
    node_style=Styles.Neutral,
    edge_style=Styles.DarkBold,
    edge_text_style=Styles.Dark.patch(text_size=10.5),
    title="E-Commerce Relational Database Schema",
    title_style=Styles.BlackBold.patch(text_size=13.5),
)

# Top row: users (left) -> orders (right)
users = er.add(Entity(name="users", width=34.0), xy=(21.0, 54.0))
users.add_column("id", type="INT", pk=True)
users.add_column("email", type="VARCHAR(255)", nullable=False)
users.add_column("name", type="VARCHAR(100)")
users.add_column("created_at", type="TIMESTAMP")

orders = er.add(Entity(name="orders", width=34.0, style=Styles.PrimaryNeutral), xy=(93.0, 54.0))
orders.add_column("id", type="INT", pk=True)
orders.add_column("user_id", type="INT", fk=True)
orders.add_column("total_cents", type="INT", nullable=False)
orders.add_column("status", type="VARCHAR(32)")

# Bottom row: products (left) -> order_items (right)
products = er.add(Entity(name="products", width=34.0), xy=(21.0, 14.0))
products.add_column("id", type="INT", pk=True)
products.add_column("sku", type="VARCHAR(64)", nullable=False)
products.add_column("title", type="VARCHAR(200)")
products.add_column("price_cents", type="INT", nullable=False)

order_items = er.add(Entity(name="order_items", width=34.0, style=Styles.SecondaryNeutral), xy=(93.0, 14.0))
order_items.add_column("id", type="INT", pk=True)
order_items.add_column("order_id", type="INT", fk=True)
order_items.add_column("product_id", type="INT", fk=True)
order_items.add_column("quantity", type="INT", nullable=False)

# Row-anchored relationships
users.connect(
    orders,
    cardinality="1:*",
    start_side="right",
    end_side="left",
    start_column="id",
    end_column="user_id",
    label="places",
)
orders.connect(
    order_items,
    cardinality="1:1..*",
    start_side="bottom",
    end_side="top",
    label="contains",
)
products.connect(
    order_items,
    cardinality="1:*",
    start_side="right",
    end_side="left",
    start_column="id",
    end_column="product_id",
    label="referenced by",
)

er.draw(xy=(0.0, 0.0))
save()

5. Best Practices & Guidelines

1. Always Use Column Anchoring: Supplying start_column and end_column visually connects the specific foreign key attribute to its referenced primary key, making schemas intuitive and professional.
2. Width Budgeting: Tables with long data types (e.g., VARCHAR(255)) look best with a width of 28.0 to 34.0 canvas units.
3. Cardinality Strings: Always use explicit cardinality strings ("1:*", "1:1", etc.) rather than manual arrow heads.