DDL to ORM Models

-- target: prisma
CREATE TABLE customers (
  id serial PRIMARY KEY,
  email varchar(255) NOT NULL UNIQUE
);

CREATE TABLE orders (
  id serial PRIMARY KEY,
  customer_id integer NOT NULL REFERENCES customers(id),
  total numeric(10,2) NOT NULL,
  placed_at timestamptz NOT NULL DEFAULT now()
);

// generated from DDL — review relations and defaults

model customers {
  id    Int    @id @default(autoincrement())
  email String @unique

  orders orders[]
}

model orders {
  id          Int      @id @default(autoincrement())
  customer_id Int
  total       Decimal
  placed_at   DateTime @default(now())

  customers customers @relation(fields: [customer_id], references: [id])
}

The serial primary key arrives as @id @default(autoincrement()), the REFERENCES clause becomes a @relation field on orders AND a list field on customers, and numeric(10, 2) lands as Decimal — with a lossy row in the drawer because the Prisma scalar does not carry precision.

-- target: sqlalchemy
CREATE TABLE customers (
  id serial PRIMARY KEY,
  email varchar(255) NOT NULL UNIQUE
);

CREATE TABLE orders (
  id serial PRIMARY KEY,
  customer_id integer NOT NULL REFERENCES customers(id),
  total numeric(10,2) NOT NULL,
  placed_at timestamptz NOT NULL DEFAULT now()
);

# generated from DDL — review relations and defaults

from datetime import datetime
from decimal import Decimal

from sqlalchemy import DateTime, ForeignKey, Integer, Numeric, String, text
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship


class Base(DeclarativeBase):
    pass


class Customers(Base):
    __tablename__ = "customers"

    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    email: Mapped[str] = mapped_column(String(255), unique=True)

    orders: Mapped[list["Orders"]] = relationship(back_populates="customers")


class Orders(Base):
    __tablename__ = "orders"

    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    customer_id: Mapped[int] = mapped_column(Integer, ForeignKey("customers.id"))
    total: Mapped[Decimal] = mapped_column(Numeric(10, 2))
    placed_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=text("now()"))

    customers: Mapped["Customers"] = relationship(back_populates="orders")

The same DDL in 2.0 style: Mapped[] annotations drive nullability, the foreign key becomes ForeignKey("customers.id") plus a relationship() pair wired with back_populates, Numeric(10, 2) keeps its precision, and DEFAULT now() rides as server_default=text("now()").

-- target: typeorm
CREATE TABLE customers (
  id serial PRIMARY KEY,
  email varchar(255) NOT NULL UNIQUE
);

CREATE TABLE orders (
  id serial PRIMARY KEY,
  customer_id integer NOT NULL REFERENCES customers(id),
  total numeric(10,2) NOT NULL,
  placed_at timestamptz NOT NULL DEFAULT now()
);

// generated from DDL — review relations and defaults
import { Column, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn } from "typeorm";
import { Customers } from "./customers.entity";

@Entity("orders")
export class Orders {
  @PrimaryGeneratedColumn()
  id!: number;

  @Column("int")
  customer_id!: number;

  @Column("numeric", { precision: 10, scale: 2 })
  total!: string;

  @Column("timestamptz", { default: () => "now()" })
  placed_at!: Date;

  @ManyToOne(() => Customers, (customers) => customers.orders)
  @JoinColumn({ name: "customer_id", referencedColumnName: "id" })
  customers!: Customers;
}

TypeORM emits one file per table — this is orders.entity.ts, which imports the Customers class from its sibling. Note total!: string: TypeORM returns numeric columns as strings, so the property type says so instead of pretending it is a number.

CREATE TABLE hits (id bigint PRIMARY KEY, views int unsigned NOT NULL, day date NOT NULL);

// generated from DDL — review relations and defaults

model hits {
  id    BigInt   @id
  views Int
  day   DateTime
}

MySQL edge case: int unsigned still generates Int and date still generates DateTime, but neither silently — the drawer marks both rows lossy, one because Int is signed, one because a date-only value gains an invented midnight.