from sqlalchemy.orm import Session, joinedload

# N+1이 발생하는 코드
posts = session.query(Post).limit(10).all()
for post in posts:
    print(post.comments)

# Eager Loading으로 해결 — JOIN으로 한 번에 로드
posts = (
    session.query(Post)
    .options(joinedload(Post.comments))
    .limit(10)
    .all()
)

SELECT u.id, u.name, o.id AS order_id, o.total_amount
FROM users u
INNER JOIN orders o ON o.user_id = u.id
WHERE u.email = 'alice@example.com'
ORDER BY o.created_at DESC
LIMIT 10;

실행 완료 또는 조회 결과가 표시됩니다.

from sqlalchemy.orm import Session

with Session(engine) as session:
    results = (
        session.query(User, Order)
        .join(Order, Order.user_id == User.id)
        .filter(User.email == 'alice@example.com')
        .order_by(Order.created_at.desc())
        .limit(10)
        .all()
    )

import { Entity, PrimaryGeneratedColumn, Column, BaseEntity } from "typeorm";

@Entity()
export class User extends BaseEntity {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column({ unique: true })
  email: string;
}

const user = new User();
user.name = "Alice";
user.email = "alice@example.com";
await user.save();

const found = await User.findOne({ where: { email: "alice@example.com" } });
await found.remove();

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

    @Column(nullable = false)
    private String name;

    @Column(unique = true, nullable = false)
    private String email;
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
    List<User> findByNameContaining(String keyword);
}

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User createUser(String name, String email) {
        User user = new User();
        user.setName(name);
        user.setEmail(email);
        return userRepository.save(user);
    }
}

[앱 코드]  user = repo.findById(1)  →  user.setName("Alice")
   │
   ① 로드·영속화          (SELECT 또는 persist → 1차 캐시(영속성 컨텍스트)에 올리고 로드 값 스냅샷 보관)
   │
   ② 객체 조작            (user.setName(...) — 순수 메모리 변경, 아직 DB 미접촉·SQL 없음)
   │
   ③ 변경 감지(dirty checking)  (flush 시 현재 값 ↔ ①의 스냅샷 비교 → 바뀐 엔터티·컬럼 탐지)
   │
   ④ SQL 생성·플러시(flush)     (변경분에 INSERT/UPDATE/DELETE 생성 → DB로 전송, 아직 커밋 아님)
   │    ↑ 트리거: 커밋 직전 · JPQL/쿼리 실행 직전 · 수동 flush() 호출
   │
   ⑤ 커밋(commit)         (트랜잭션 확정 → 반영. 영속성 컨텍스트(1차 캐시) 종료)
   ▼
[DB]  UPDATE users SET name='Alice' WHERE id=1

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String
  posts     Post[]
  createdAt DateTime @default(now())
}

model Post {
  id        Int    @id @default(autoincrement())
  title     String
  content   String?
  author    User   @relation(fields: [authorId], references: [id])
  authorId  Int
}

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

const user = await prisma.user.create({
  data: { email: 'alice@example.com', name: 'Alice' }
});

const usersWithPosts = await prisma.user.findMany({
  include: { posts: true }
});

await prisma.user.update({
  where: { id: user.id },
  data: { name: 'Alice Updated' }
});

await prisma.user.delete({ where: { id: user.id } });

from sqlalchemy import create_engine, Column, Integer, String, ForeignKey, select
from sqlalchemy.orm import DeclarativeBase, relationship, Session

class Base(DeclarativeBase):
    pass

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True, autoincrement=True)
    email = Column(String(255), unique=True, nullable=False)
    name = Column(String(100), nullable=False)
    posts = relationship("Post", back_populates="author", lazy="select")

class Post(Base):
    __tablename__ = "posts"
    id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(255), nullable=False)
    author_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    author = relationship("User", back_populates="posts")

engine = create_engine("postgresql+psycopg2://user:pass@localhost/db")

with Session(engine) as session:
    user = User(email="bob@example.com", name="Bob")
    session.add(user)
    session.commit()

    stmt = select(User).where(User.email == "bob@example.com")
    result = session.execute(stmt).scalar_one()

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

    @Column(unique = true, nullable = false)
    private String email;

    @OneToMany(mappedBy = "author", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    private List<Post> posts = new ArrayList<>();
}

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);

    @Query("SELECT u FROM User u JOIN FETCH u.posts WHERE u.id = :id")
    Optional<User> findByIdWithPosts(@Param("id") Long id);
}

import { Entity, PrimaryGeneratedColumn, Column,
         OneToMany, Repository } from 'typeorm';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ unique: true })
  email: string;

  @OneToMany(() => Post, (post) => post.author, { lazy: true })
  posts: Promise<Post[]>;
}

const userRepo: Repository<User> = dataSource.getRepository(User);

const user = userRepo.create({ email: 'carol@example.com' });
await userRepo.save(user);

const found = await userRepo.findOne({
  where: { email: 'carol@example.com' },
  relations: { posts: true }
});