diff --git a/src/main/resources/schema.sql b/src/main/resources/schema.sql
index 5e5dd43..3c9ff93 100644
--- a/src/main/resources/schema.sql
+++ b/src/main/resources/schema.sql
@@ -84,4 +84,16 @@
     is_read BOOLEAN DEFAULT false,
     FOREIGN KEY (sender_id) REFERENCES users(user_id),
     FOREIGN KEY (receiver_id) REFERENCES users(user_id)
-);
\ No newline at end of file
+);
+
+CREATE TABLE IF NOT EXISTS `comments` (
+    comment_id INT AUTO_INCREMENT PRIMARY KEY,      -- 评论ID
+    post_id INT NOT NULL,                            -- 所属帖子ID
+    user_id INT NOT NULL,                            -- 评论用户ID
+    parent_comment_id INT DEFAULT NULL,             -- 父评论ID, 如果是顶级评论则为NULL
+    content TEXT NOT NULL,                          -- 评论内容
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- 评论时间
+    FOREIGN KEY (post_id) REFERENCES posts(post_id), -- 关联帖子
+    FOREIGN KEY (user_id) REFERENCES users(user_id), -- 关联用户
+    FOREIGN KEY (parent_comment_id) REFERENCES comments(comment_id) -- 关联父评论
+);
