1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# Django ORM 예제: User 모델 정의 및 CRUD
from django.db import models

class User(models.Model):
    username = models.CharField(max_length=50)
    email = models.EmailField()

# 객체 생성 및 저장
u = User(username="tester", email="test@test.com")
u.save()  # ORM이 INSERT SQL 자동 실행

# 객체 조회
user = User.objects.filter(username="tester").first()  # ORM이 SELECT SQL 자동 실행

# 객체 수정
user.email = "update@test.com"
user.save()  # ORM이 UPDATE SQL 자동 실행

# 객체 삭제
user.delete()  # ORM이 DELETE SQL 자동 실행

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

from django.db import models

class User(models.Model):  # 엔티티 정의, User와 테이블 매핑
    username = models.CharField(max_length=50)
    email = models.EmailField()

class Post(models.Model):  # 게시물 엔티티 정의
    title = models.CharField(max_length=100)
    content = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE)  # 관계 매핑: User와 연결

# 사용자 생성/저장
user = User(username="tester", email="test@test.com")
user.save()  # INSERT 자동 처리

# 게시물 생성/저장
post = Post(title="ORM 실습", content="ORM 기본 원리", author=user)
post.save()  # INSERT 자동 처리

# 게시물 조회
posts = Post.objects.filter(author__username="tester")  # 복잡한 쿼리도 ORM이 SQL로 변환

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// TypeORM 연결 예시 (ServiceA)
import { DataSource } from 'typeorm'
import { User } from './entity/User'

export const AppDataSource = new DataSource({
    type: 'mysql',
    host: 'localhost',
    port: 3306,
    username: 'root',
    password: 'pass',
    database: 'users',
    entities: [User],
    synchronize: true,
})

// User 엔티티
@Entity()
export class User {
    @PrimaryGeneratedColumn()
    id: number

    @Column()
    username: string

    @Column()
    email: string
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# Django ORM - Active Record 패턴
class User(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()
    created_at = models.DateTimeField(auto_now_add=True)
    
    # 인스턴스 메서드 - 개별 레코드 조작
    def save(self):
        # Active Record 패턴: 객체 자체가 저장 로직 포함
        super().save()  # 이 부분이 ORM의 핵심 - 객체를 DB에 저장
    
    def activate(self):
        # 비즈니스 로직과 데이터 조작이 한 클래스에
        self.is_active = True
        self.save()  # ORM을 통한 자동 UPDATE 쿼리 생성
    
    # 클래스 메서드 - 쿼리 작업
    @classmethod
    def find_by_email(cls, email):
        # ORM이 자동으로 SELECT 쿼리 생성 및 객체 매핑
        return cls.objects.filter(email=email).first()

# 사용 예시
user = User(name="홍길동", email="hong@example.com")
user.save()  # ORM이 INSERT INTO users... 쿼리 자동 생성

found_user = User.find_by_email("hong@example.com")  # SELECT 쿼리 자동 생성
found_user.activate()  # UPDATE 쿼리 자동 생성

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

// JPA - Data Mapper 패턴

// 1. 순수 도메인 엔티티 (데이터베이스 의존성 최소화)
@Entity
@Table(name = "users")
public class User {
    @Id  // ORM 매핑 애노테이션 - ID 필드 지정
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)  // ORM 매핑 - 컬럼 제약조건
    private String name;
    
    @Column(unique = true)  // ORM 매핑 - 유니크 제약
    private String email;
    
    // 순수 비즈니스 로직 (데이터베이스 작업 없음)
    public void activate() {
        this.isActive = true;
        // 저장은 별도 서비스가 담당
    }
    
    // getters, setters...
}

// 2. 리포지토리 인터페이스 (데이터 접근 추상화)
public interface UserRepository extends JpaRepository<User, Long> {
    // ORM이 메서드 이름을 분석해서 쿼리 자동 생성
    Optional<User> findByEmail(String email);  // SELECT * FROM users WHERE email = ?
    List<User> findByNameContaining(String name);  // SELECT * FROM users WHERE name LIKE %?%
    
    // 복잡한 쿼리는 직접 정의
    @Query("SELECT u FROM User u WHERE u.createdAt > :date")
    List<User> findRecentUsers(@Param("date") LocalDateTime date);
}

// 3. 서비스 계층 (비즈니스 로직과 데이터 접근 분리)
@Service
@Transactional
public class UserService {
    
    @Autowired
    private UserRepository userRepository;  // ORM 리포지토리 주입
    
    public void activateUser(String email) {
        User user = userRepository.findByEmail(email)
            .orElseThrow(() -> new UserNotFoundException());
        
        user.activate();  // 순수 비즈니스 로직
        userRepository.save(user);  // ORM을 통한 데이터베이스 저장
        // ORM이 더티 체킹으로 변경사항 감지 후 UPDATE 쿼리 자동 생성
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

// Knex.js - Query Builder 패턴
const knex = require('knex')({
  client: 'postgresql',
  connection: {
    database: 'myapp',
    user: 'username',
    password: 'password'
  }
});

// Query Builder를 통한 동적 쿼리 생성
class UserRepository {
  
  // 기본 CRUD - ORM이 SQL 자동 생성
  async createUser(userData) {
    // ORM이 INSERT INTO users (...) VALUES (...) 쿼리 생성
    const [user] = await knex('users')
      .insert(userData)
      .returning('*');
    return user;
  }
  
  // 복잡한 조건부 쿼리 - Query Builder의 강점
  async searchUsers(filters) {
    let query = knex('users').select('*');  // ORM 쿼리 빌더 시작
    
    // 동적 조건 추가 - ORM이 각 조건을 WHERE 절로 변환
    if (filters.name) {
      query = query.where('name', 'like', `%${filters.name}%`);
    }
    
    if (filters.ageMin) {
      query = query.where('age', '>=', filters.ageMin);
    }
    
    if (filters.department) {
      // ORM이 JOIN 쿼리 자동 생성
      query = query
        .join('departments', 'users.department_id', 'departments.id')
        .where('departments.name', filters.department);
    }
    
    if (filters.sortBy) {
      query = query.orderBy(filters.sortBy, filters.sortOrder || 'asc');
    }
    
    // 페이징 처리 - ORM이 LIMIT/OFFSET 자동 추가
    if (filters.page && filters.pageSize) {
      const offset = (filters.page - 1) * filters.pageSize;
      query = query.limit(filters.pageSize).offset(offset);
    }
    
    return await query;  // 최종 SQL 실행 및 객체 매핑
  }
  
  // 집계 쿼리 - ORM의 집계 함수 활용
  async getUserStats() {
    return await knex('users')
      .select(
        knex.raw('COUNT(*) as total_users'),  // ORM 집계 함수
        knex.raw('AVG(age) as average_age'),
        'department_id'
      )
      .groupBy('department_id')  // ORM GROUP BY
      .having(knex.raw('COUNT(*) > ?'), [5]);  // ORM HAVING 절
  }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208

// 1. User 엔티티 - ORM 매핑의 기본
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true)
    private String username;
    
    @Column(nullable = false)
    private String email;
    
    // ORM 관계 매핑 - 일대다 관계
    @OneToMany(mappedBy = "author", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Post> posts = new ArrayList<>();
    
    // ORM을 통한 연관관계 편의 메서드
    public void addPost(Post post) {
        posts.add(post);
        post.setAuthor(this);  // 양방향 관계 설정
    }
    
    // getters, setters, constructors...
}

// 2. Post 엔티티 - 복합 관계 매핑
@Entity
@Table(name = "posts")
public class Post {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String title;
    
    @Column(columnDefinition = "TEXT")
    private String content;
    
    // ORM 관계 매핑 - 다대일 관계 (지연 로딩)
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "author_id")
    private User author;
    
    // ORM 관계 매핑 - 일대다 관계
    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Comment> comments = new ArrayList<>();
    
    @CreationTimestamp
    private LocalDateTime createdAt;
    
    @UpdateTimestamp
    private LocalDateTime updatedAt;
    
    // 연관관계 편의 메서드
    public void addComment(Comment comment) {
        comments.add(comment);
        comment.setPost(this);
    }
}

// 3. Comment 엔티티
@Entity
@Table(name = "comments")
public class Comment {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String content;
    
    // ORM 다대일 관계 - 게시글과 연관
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "post_id")
    private Post post;
    
    // ORM 다대일 관계 - 작성자와 연관
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "author_id")
    private User author;
    
    @CreationTimestamp
    private LocalDateTime createdAt;
}

// 4. Repository 인터페이스 - ORM 데이터 접근 추상화
public interface PostRepository extends JpaRepository<Post, Long> {
    
    // ORM이 메서드 이름을 분석해서 쿼리 자동 생성
    List<Post> findByAuthorUsernameOrderByCreatedAtDesc(String username);
    
    // ORM이 제목에서 키워드 검색 쿼리 생성
    List<Post> findByTitleContainingIgnoreCase(String keyword);
    
    // 복잡한 쿼리는 JPQL로 직접 정의
    @Query("SELECT p FROM Post p LEFT JOIN FETCH p.comments WHERE p.id = :postId")
    Optional<Post> findByIdWithComments(@Param("postId") Long postId);
    
    // 네이티브 쿼리도 지원 (ORM의 유연성)
    @Query(value = "SELECT * FROM posts WHERE created_at >= :date", nativeQuery = true)
    List<Post> findRecentPosts(@Param("date") LocalDateTime date);
}

// 5. 서비스 클래스 - 비즈니스 로직과 ORM 트랜잭션 관리
@Service
@Transactional
public class PostService {
    
    @Autowired
    private PostRepository postRepository;
    
    @Autowired
    private UserRepository userRepository;
    
    // ORM을 활용한 게시글 생성
    public Post createPost(String username, String title, String content) {
        // ORM 쿼리 메서드 활용
        User author = userRepository.findByUsername(username)
            .orElseThrow(() -> new UserNotFoundException("사용자를 찾을 수 없습니다: " + username));
        
        Post post = new Post();
        post.setTitle(title);
        post.setContent(content);
        post.setAuthor(author);  // ORM 관계 설정
        
        // ORM이 INSERT 쿼리 자동 생성 및 실행
        return postRepository.save(post);
    }
    
    // ORM 지연 로딩 활용한 댓글 포함 조회
    @Transactional(readOnly = true)
    public Post getPostWithComments(Long postId) {
        // ORM 페치 조인으로 N+1 문제 해결
        return postRepository.findByIdWithComments(postId)
            .orElseThrow(() -> new PostNotFoundException("게시글을 찾을 수 없습니다: " + postId));
    }
    
    // ORM 트랜잭션과 더티 체킹 활용
    public Post updatePost(Long postId, String newTitle, String newContent) {
        Post post = postRepository.findById(postId)
            .orElseThrow(() -> new PostNotFoundException("게시글을 찾을 수 없습니다: " + postId));
        
        // ORM의 더티 체킹 - 객체 수정만으로 자동 UPDATE
        post.setTitle(newTitle);
        post.setContent(newContent);
        
        // 명시적 save() 호출 없이도 트랜잭션 커밋 시 자동 UPDATE
        return post;
    }
    
    // ORM 관계 매핑을 활용한 댓글 추가
    public Comment addComment(Long postId, String username, String content) {
        Post post = postRepository.findById(postId)
            .orElseThrow(() -> new PostNotFoundException("게시글을 찾을 수 없습니다: " + postId));
        
        User author = userRepository.findByUsername(username)
            .orElseThrow(() -> new UserNotFoundException("사용자를 찾을 수 없습니다: " + username));
        
        Comment comment = new Comment();
        comment.setContent(content);
        comment.setAuthor(author);
        
        // ORM 연관관계 편의 메서드 활용
        post.addComment(comment);  // 양방향 관계 자동 설정
        
        // ORM이 Comment INSERT와 Post UPDATE를 자동 처리
        return commentRepository.save(comment);
    }
}

// 6. REST Controller - ORM 서비스 활용
@RestController
@RequestMapping("/api/posts")
public class PostController {
    
    @Autowired
    private PostService postService;
    
    // 게시글 생성
    @PostMapping
    public ResponseEntity<Post> createPost(@RequestBody CreatePostRequest request) {
        Post post = postService.createPost(
            request.getUsername(), 
            request.getTitle(), 
            request.getContent()
        );
        return ResponseEntity.ok(post);
    }
    
    // 게시글 상세 조회 (댓글 포함)
    @GetMapping("/{postId}")
    public ResponseEntity<Post> getPost(@PathVariable Long postId) {
        // ORM의 지연 로딩과 페치 조인 활용
        Post post = postService.getPostWithComments(postId);
        return ResponseEntity.ok(post);
    }
    
    // 사용자별 게시글 목록
    @GetMapping("/user/{username}")
    public ResponseEntity<List<Post>> getUserPosts(@PathVariable String username) {
        // ORM 쿼리 메서드 활용
        List<Post> posts = postService.getPostsByUsername(username);
        return ResponseEntity.ok(posts);
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296

# models.py - Django ORM 모델 정의
from django.db import models
from django.contrib.auth.models import AbstractUser
from django.core.validators import FileExtensionValidator
import uuid

class User(AbstractUser):
    """Instagram 스타일 사용자 모델"""
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    bio = models.TextField(max_length=500, blank=True)
    profile_image = models.ImageField(
        upload_to='profiles/', 
        blank=True, 
        null=True
    )
    followers_count = models.PositiveIntegerField(default=0)
    following_count = models.PositiveIntegerField(default=0)
    posts_count = models.PositiveIntegerField(default=0)
    
    # ORM을 통한 역방향 관계 접근 최적화
    class Meta:
        indexes = [
            models.Index(fields=['username']),
            models.Index(fields=['email']),
        ]

class Post(models.Model):
    """게시물 모델 - ORM 관계 매핑의 핵심"""
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    
    # ORM 외래키 관계 - 게시물 작성자
    author = models.ForeignKey(
        User, 
        on_delete=models.CASCADE, 
        related_name='posts'  # ORM 역방향 관계명 지정
    )
    
    image = models.ImageField(
        upload_to='posts/',
        validators=[FileExtensionValidator(['jpg', 'jpeg', 'png'])]
    )
    caption = models.TextField(max_length=2000, blank=True)
    likes_count = models.PositiveIntegerField(default=0)
    comments_count = models.PositiveIntegerField(default=0)
    
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    # ORM 쿼리 최적화를 위한 인덱스
    class Meta:
        indexes = [
            models.Index(fields=['-created_at']),  # 최신 게시물 조회 최적화
            models.Index(fields=['author', '-created_at']),  # 사용자별 게시물 조회
        ]
        ordering = ['-created_at']

class Follow(models.Model):
    """팔로우 관계 모델 - 다대다 관계의 중간 테이블"""
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    
    # ORM 외래키 관계 - 팔로워
    follower = models.ForeignKey(
        User, 
        on_delete=models.CASCADE, 
        related_name='following'
    )
    
    # ORM 외래키 관계 - 팔로우 대상
    following = models.ForeignKey(
        User, 
        on_delete=models.CASCADE, 
        related_name='followers'
    )
    
    created_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        # ORM 제약조건 - 중복 팔로우 방지
        unique_together = ('follower', 'following')
        indexes = [
            models.Index(fields=['follower']),
            models.Index(fields=['following']),
        ]

class Like(models.Model):
    """좋아요 모델"""
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name='likes')
    created_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        unique_together = ('user', 'post')  # ORM 제약조건
        indexes = [
            models.Index(fields=['post', '-created_at']),
        ]

# services.py - 비즈니스 로직과 ORM 활용
from django.db import transaction
from django.core.cache import cache
from django.db.models import Prefetch, Count, Q
import json

class PostService:
    """게시물 관련 비즈니스 로직"""
    
    @staticmethod
    @transaction.atomic  # ORM 트랜잭션 관리
    def create_post(user, image, caption):
        """게시물 생성 - ORM을 활용한 관련 데이터 업데이트"""
        # ORM을 통한 게시물 생성
        post = Post.objects.create(
            author=user,
            image=image,
            caption=caption
        )
        
        # ORM F() 표현식을 사용한 원자적 카운터 업데이트
        User.objects.filter(id=user.id).update(
            posts_count=models.F('posts_count') + 1
        )
        
        # 비동기 피드 업데이트 (Redis 캐시 활용)
        PostService._update_followers_feed.delay(user.id, post.id)
        
        return post
    
    @staticmethod
    def get_user_feed(user_id, page=1, per_page=20):
        """사용자 피드 조회 - ORM 쿼리 최적화"""
        cache_key = f"user_feed:{user_id}:page:{page}"
        
        # Redis 캐시 확인
        cached_feed = cache.get(cache_key)
        if cached_feed:
            return json.loads(cached_feed)
        
        # ORM을 활용한 복잡한 피드 쿼리
        # select_related: 외래키 관계 즉시 로딩
        # prefetch_related: 역방향 관계 최적화 로딩
        posts = Post.objects.select_related('author') \
                          .prefetch_related(
                              Prefetch('likes', queryset=Like.objects.select_related('user')),
                              'author__followers'
                          ) \
                          .filter(
                              # ORM Q 객체를 사용한 복잡한 조건
                              Q(author__followers__follower=user_id) | 
                              Q(author_id=user_id)
                          ) \
                          .distinct() \
                          .order_by('-created_at')[(page-1)*per_page:page*per_page]
        
        # 결과 직렬화 및 캐시 저장
        feed_data = PostService._serialize_posts(posts, user_id)
        cache.set(cache_key, json.dumps(feed_data), timeout=300)  # 5분 캐시
        
        return feed_data
    
    @staticmethod
    def like_post(user_id, post_id):
        """게시물 좋아요 - ORM get_or_create 활용"""
        try:
            with transaction.atomic():
                # ORM get_or_create로 중복 방지
                like, created = Like.objects.get_or_create(
                    user_id=user_id,
                    post_id=post_id
                )
                
                if created:
                    # ORM F() 표현식으로 원자적 카운터 증가
                    Post.objects.filter(id=post_id).update(
                        likes_count=models.F('likes_count') + 1
                    )
                    
                    # 캐시 무효화
                    PostService._invalidate_post_cache(post_id)
                    
                return created
                
        except IntegrityError:
            # 동시성 제어 - 중복 좋아요 방지
            return False

class UserService:
    """사용자 관련 비즈니스 로직"""
    
    @staticmethod
    @transaction.atomic
    def follow_user(follower_id, following_id):
        """사용자 팔로우 - ORM 관계 관리"""
        if follower_id == following_id:
            raise ValueError("자기 자신을 팔로우할 수 없습니다")
        
        # ORM get_or_create로 중복 팔로우 방지
        follow, created = Follow.objects.get_or_create(
            follower_id=follower_id,
            following_id=following_id
        )
        
        if created:
            # ORM bulk_update로 카운터 업데이트 최적화
            User.objects.filter(id=follower_id).update(
                following_count=models.F('following_count') + 1
            )
            User.objects.filter(id=following_id).update(
                followers_count=models.F('followers_count') + 1
            )
            
            # 피드 캐시 무효화
            cache.delete_pattern(f"user_feed:{follower_id}:*")
        
        return created
    
    @staticmethod
    def get_user_stats(user_id):
        """사용자 통계 - ORM 집계 쿼리"""
        # ORM annotate를 사용한 복잡한 집계
        stats = User.objects.filter(id=user_id).annotate(
            recent_posts_count=Count(
                'posts',
                filter=Q(posts__created_at__gte=timezone.now() - timedelta(days=30))
            ),
            total_likes_received=Count('posts__likes'),
            avg_likes_per_post=Avg('posts__likes_count')
        ).values(
            'posts_count',
            'followers_count', 
            'following_count',
            'recent_posts_count',
            'total_likes_received',
            'avg_likes_per_post'
        ).first()
        
        return stats

# views.py - Django REST Framework와 ORM 통합
from rest_framework import viewsets, status
from rest_framework.decorators import action
from rest_framework.response import Response
from django.utils.decorators import method_decorator
from django.views.decorators.cache import cache_page

class PostViewSet(viewsets.ModelViewSet):
    """게시물 API - ORM 쿼리셋 최적화"""
    
    def get_queryset(self):
        """ORM 쿼리셋 최적화 - N+1 문제 해결"""
        return Post.objects.select_related('author') \
                          .prefetch_related('likes__user') \
                          .annotate(
                              is_liked=Count(
                                  'likes',
                                  filter=Q(likes__user=self.request.user)
                              )
                          )
    
    @action(detail=False, methods=['get'])
    @method_decorator(cache_page(60))  # 1분 캐시
    def feed(self, request):
        """개인화된 피드 조회"""
        page = int(request.query_params.get('page', 1))
        feed_data = PostService.get_user_feed(request.user.id, page)
        return Response(feed_data)
    
    @action(detail=True, methods=['post'])
    def like(self, request, pk=None):
        """게시물 좋아요"""
        created = PostService.like_post(request.user.id, pk)
        return Response(
            {'liked': created}, 
            status=status.HTTP_201_CREATED if created else status.HTTP_200_OK
        )

# 성능 모니터링을 위한 커스텀 미들웨어
class ORMQueryMonitoringMiddleware:
    """ORM 쿼리 성능 모니터링"""
    
    def __init__(self, get_response):
        self.get_response = get_response
    
    def __call__(self, request):
        from django.db import connection
        
        initial_queries = len(connection.queries)
        
        response = self.get_response(request)
        
        # ORM 쿼리 개수 및 성능 로깅
        queries_count = len(connection.queries) - initial_queries
        if queries_count > 10:  # 쿼리가 많은 경우 경고
            logger.warning(f"High query count detected: {queries_count} queries for {request.path}")
        
        return response