Update app.py

app.py

@@ -1,10 +1,96 @@
 import gradio as gr
 from googleapiclient.discovery import build
 import os
+import sqlite3
+from datetime import datetime, timedelta
+import json
 
 API_KEY = os.getenv("YOUTUBE_API_KEY")
 youtube = build("youtube", "v3", developerKey=API_KEY)
 
+# DB 초기화
+def init_db():
+    conn = sqlite3.connect("youtube_data.db")
+    c = conn.cursor()
+    
+    # 영상 데이터 테이블
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS videos (
+            video_id TEXT PRIMARY KEY,
+            title TEXT,
+            channel_id TEXT,
+            channel_name TEXT,
+            thumbnail TEXT,
+            published_at TEXT,
+            first_seen TEXT
+        )
+    ''')
+    
+    # 영상 통계 히스토리 (시간별 추적)
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS video_stats (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            video_id TEXT,
+            views INTEGER,
+            likes INTEGER,
+            comments INTEGER,
+            recorded_at TEXT,
+            FOREIGN KEY (video_id) REFERENCES videos(video_id)
+        )
+    ''')
+    
+    # 채널 데이터 테이블
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS channels (
+            channel_id TEXT PRIMARY KEY,
+            channel_name TEXT,
+            first_seen TEXT
+        )
+    ''')
+    
+    # 채널 통계 히스토리
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS channel_stats (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            channel_id TEXT,
+            subscribers INTEGER,
+            recorded_at TEXT,
+            FOREIGN KEY (channel_id) REFERENCES channels(channel_id)
+        )
+    ''')
+    
+    # 검색 기록 테이블
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS search_history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            keyword TEXT,
+            country TEXT,
+            language TEXT,
+            sort_by TEXT,
+            results_count INTEGER,
+            searched_at TEXT
+        )
+    ''')
+    
+    # 급상승 알림 테이블
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS trending_alerts (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            video_id TEXT,
+            alert_type TEXT,
+            old_value INTEGER,
+            new_value INTEGER,
+            change_percent REAL,
+            detected_at TEXT,
+            FOREIGN KEY (video_id) REFERENCES videos(video_id)
+        )
+    ''')
+    
+    conn.commit()
+    conn.close()
+
+init_db()
+
 # 국가 코드 - 인구 순 상위 40개
 COUNTRIES = {
     "전세계": "",
@@ -95,7 +181,6 @@ LANGUAGES = {
     "노르웨이어": "no",
 }
 
-# 정렬 기준
 SORT_OPTIONS = {
     "조회수 순": "viewCount",
     "최신순": "date",
@@ -103,7 +188,6 @@ SORT_OPTIONS = {
     "평점 순": "rating",
 }
 
-# 기간 필터
 DATE_OPTIONS = {
     "전체 기간": "",
     "오늘": "today",
@@ -112,8 +196,180 @@ DATE_OPTIONS = {
     "올해": "thisYear",
 }
 
+def format_count(count):
+    if count >= 1000000000:
+        return f"{count/1000000000:.1f}B"
+    elif count >= 1000000:
+        return f"{count/1000000:.1f}M"
+    elif count >= 1000:
+        return f"{count/1000:.1f}K"
+    return str(count)
+
+def save_to_db(videos_data, channels_data, keyword, country, language, sort_by):
+    """검색 결과를 DB에 저장"""
+    conn = sqlite3.connect("youtube_data.db")
+    c = conn.cursor()
+    now = datetime.now().isoformat()
+    
+    # 검색 기록 저장
+    c.execute('''
+        INSERT INTO search_history (keyword, country, language, sort_by, results_count, searched_at)
+        VALUES (?, ?, ?, ?, ?, ?)
+    ''', (keyword, country, language, sort_by, len(videos_data), now))
+    
+    for video in videos_data:
+        # 영상 기본 정보 저장/업데이트
+        c.execute('''
+            INSERT OR IGNORE INTO videos (video_id, title, channel_id, channel_name, thumbnail, published_at, first_seen)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        ''', (video['video_id'], video['title'], video['channel_id'], video['channel_name'], 
+              video['thumbnail'], video['published_at'], now))
+        
+        # 이전 통계 가져오기 (급상승 감지용)
+        c.execute('''
+            SELECT views FROM video_stats 
+            WHERE video_id = ? 
+            ORDER BY recorded_at DESC LIMIT 1
+        ''', (video['video_id'],))
+        prev_stats = c.fetchone()
+        
+        # 영상 통계 저장
+        c.execute('''
+            INSERT INTO video_stats (video_id, views, likes, comments, recorded_at)
+            VALUES (?, ?, ?, ?, ?)
+        ''', (video['video_id'], video['views'], video['likes'], video['comments'], now))
+        
+        # 급상승 감지 (조회수 20% 이상 증가)
+        if prev_stats and prev_stats[0] > 0:
+            change_percent = ((video['views'] - prev_stats[0]) / prev_stats[0]) * 100
+            if change_percent >= 20:
+                c.execute('''
+                    INSERT INTO trending_alerts (video_id, alert_type, old_value, new_value, change_percent, detected_at)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                ''', (video['video_id'], 'views_surge', prev_stats[0], video['views'], change_percent, now))
+    
+    for channel_id, subs in channels_data.items():
+        # 채널 정보 저장
+        c.execute('''
+            INSERT OR IGNORE INTO channels (channel_id, channel_name, first_seen)
+            VALUES (?, ?, ?)
+        ''', (channel_id, '', now))
+        
+        # 채널 통계 저장
+        if isinstance(subs, int):
+            c.execute('''
+                INSERT INTO channel_stats (channel_id, subscribers, recorded_at)
+                VALUES (?, ?, ?)
+            ''', (channel_id, subs, now))
+    
+    conn.commit()
+    conn.close()
+
+def get_trending_alerts():
+    """최근 급상승 알림 가져오기"""
+    conn = sqlite3.connect("youtube_data.db")
+    c = conn.cursor()
+    
+    c.execute('''
+        SELECT ta.video_id, v.title, v.channel_name, ta.alert_type, 
+               ta.old_value, ta.new_value, ta.change_percent, ta.detected_at
+        FROM trending_alerts ta
+        JOIN videos v ON ta.video_id = v.video_id
+        ORDER BY ta.detected_at DESC
+        LIMIT 20
+    ''')
+    
+    alerts = c.fetchall()
+    conn.close()
+    return alerts
+
+def get_search_history():
+    """검색 기록 가져오기"""
+    conn = sqlite3.connect("youtube_data.db")
+    c = conn.cursor()
+    
+    c.execute('''
+        SELECT keyword, country, language, sort_by, results_count, searched_at
+        FROM search_history
+        ORDER BY searched_at DESC
+        LIMIT 50
+    ''')
+    
+    history = c.fetchall()
+    conn.close()
+    return history
+
+def get_video_history(video_id):
+    """특정 영상의 통계 히스토리"""
+    conn = sqlite3.connect("youtube_data.db")
+    c = conn.cursor()
+    
+    c.execute('''
+        SELECT views, likes, comments, recorded_at
+        FROM video_stats
+        WHERE video_id = ?
+        ORDER BY recorded_at ASC
+    ''', (video_id,))
+    
+    history = c.fetchall()
+    conn.close()
+    return history
+
+def get_top_growing_videos(hours=24):
+    """급성장 영상 TOP 10"""
+    conn = sqlite3.connect("youtube_data.db")
+    c = conn.cursor()
+    
+    cutoff = (datetime.now() - timedelta(hours=hours)).isoformat()
+    
+    c.execute('''
+        SELECT v.video_id, v.title, v.channel_name, v.thumbnail,
+               MIN(vs.views) as min_views, MAX(vs.views) as max_views,
+               ((MAX(vs.views) - MIN(vs.views)) * 100.0 / MIN(vs.views)) as growth_rate
+        FROM videos v
+        JOIN video_stats vs ON v.video_id = vs.video_id
+        WHERE vs.recorded_at > ?
+        GROUP BY v.video_id
+        HAVING min_views > 0 AND max_views > min_views
+        ORDER BY growth_rate DESC
+        LIMIT 10
+    ''', (cutoff,))
+    
+    results = c.fetchall()
+    conn.close()
+    return results
+
+def get_db_stats():
+    """DB 통계"""
+    conn = sqlite3.connect("youtube_data.db")
+    c = conn.cursor()
+    
+    c.execute("SELECT COUNT(*) FROM videos")
+    video_count = c.fetchone()[0]
+    
+    c.execute("SELECT COUNT(*) FROM video_stats")
+    stats_count = c.fetchone()[0]
+    
+    c.execute("SELECT COUNT(*) FROM channels")
+    channel_count = c.fetchone()[0]
+    
+    c.execute("SELECT COUNT(*) FROM search_history")
+    search_count = c.fetchone()[0]
+    
+    c.execute("SELECT COUNT(*) FROM trending_alerts")
+    alert_count = c.fetchone()[0]
+    
+    conn.close()
+    
+    return {
+        "videos": video_count,
+        "stats_records": stats_count,
+        "channels": channel_count,
+        "searches": search_count,
+        "alerts": alert_count
+    }
+
 def get_trending_keywords(region_code="KR"):
-    """YouTube 인기 동영상에서 트렌드 키워드 추출"""
     try:
         response = youtube.videos().list(
             part="snippet",
@@ -125,9 +381,8 @@ def get_trending_keywords(region_code="KR"):
         keywords = []
         seen = set()
         for item in response.get("items", []):
-            title = item["snippet"]["title"]
             channel = item["snippet"]["channelTitle"]
-            keyword = channel.split()[0] if len(channel.split()) > 0 else title.split()[0]
+            keyword = channel.split()[0] if len(channel.split()) > 0 else item["snippet"]["title"].split()[0]
             if keyword not in seen and len(keyword) > 1:
                 keywords.append(keyword)
                 seen.add(keyword)
@@ -139,35 +394,23 @@ def get_trending_keywords(region_code="KR"):
         return get_default_trending()
 
 def get_default_trending():
-    """기본 인기 검색어"""
     return [
         "AI", "ChatGPT", "뉴진스", "BTS", "Netflix", 
         "게임", "먹방", "브이로그", "shorts", "음악",
         "축구", "NBA", "애니메이션", "영화 리뷰", "코딩"
     ]
 
-def format_count(count):
-    if count >= 1000000000:
-        return f"{count/1000000000:.1f}B"
-    elif count >= 1000000:
-        return f"{count/1000000:.1f}M"
-    elif count >= 1000:
-        return f"{count/1000:.1f}K"
-    return str(count)
-
 def update_trending(country):
-    """국가 변경시 트렌딩 키워드 업데이트"""
     region = COUNTRIES.get(country, "")
     keywords = get_trending_keywords(region if region else "US")
     return gr.update(choices=keywords, value=None)
 
 def use_trending_keyword(trending_keyword):
-    """트렌딩 키워드 선택시 검색창에 입력"""
     return trending_keyword if trending_keyword else ""
 
-def search_videos(keyword, country, language, sort_by, date_filter, max_results):
+def search_videos(keyword, country, language, sort_by, date_filter, max_results, save_db=True):
     if not keyword or not keyword.strip():
-        return "검색어를 입력하세요."
+        return "검색어를 입력하세요.", ""
     
     max_results = int(max_results)
     all_items = []
@@ -186,7 +429,6 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results)
         search_params["relevanceLanguage"] = LANGUAGES[language]
     
     if date_filter != "전체 기간":
-        from datetime import datetime, timedelta
         now = datetime.utcnow()
         if date_filter == "오늘":
             after = now - timedelta(days=1)
@@ -216,7 +458,7 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results)
             break
     
     if not all_items:
-        return "검색 결과가 없습니다."
+        return "검색 결과가 없습니다.", ""
     
     video_ids = [item["id"]["videoId"] for item in all_items]
     channel_ids = list(set([item["snippet"]["channelId"] for item in all_items]))
@@ -234,11 +476,14 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results)
             video_stats[v["id"]] = {
                 "views": int(stats.get("viewCount", 0)),
                 "views_fmt": format_count(int(stats.get("viewCount", 0))),
-                "likes": format_count(int(stats.get("likeCount", 0))),
-                "comments": format_count(int(stats.get("commentCount", 0))),
+                "likes": int(stats.get("likeCount", 0)),
+                "likes_fmt": format_count(int(stats.get("likeCount", 0))),
+                "comments": int(stats.get("commentCount", 0)),
+                "comments_fmt": format_count(int(stats.get("commentCount", 0))),
             }
     
     channel_subs = {}
+    channel_subs_raw = {}
     for i in range(0, len(channel_ids), 50):
         batch_ids = channel_ids[i:i+50]
         channel_details = youtube.channels().list(
@@ -247,11 +492,37 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results)
         ).execute()
         
         for ch in channel_details.get("items", []):
-            sub_count = ch["statistics"].get("subscriberCount", "비공개")
-            if sub_count != "비공개":
-                sub_count = format_count(int(sub_count))
-            channel_subs[ch["id"]] = sub_count
+            sub_count = ch["statistics"].get("subscriberCount", "0")
+            if sub_count:
+                channel_subs_raw[ch["id"]] = int(sub_count)
+                channel_subs[ch["id"]] = format_count(int(sub_count))
+            else:
+                channel_subs[ch["id"]] = "비공개"
+    
+    # DB 저장용 데이터 준비
+    videos_data = []
+    for item in all_items:
+        video_id = item["id"]["videoId"]
+        snippet = item["snippet"]
+        stats = video_stats.get(video_id, {})
+        
+        videos_data.append({
+            "video_id": video_id,
+            "title": snippet["title"],
+            "channel_id": snippet["channelId"],
+            "channel_name": snippet["channelTitle"],
+            "thumbnail": snippet["thumbnails"]["default"]["url"],
+            "published_at": snippet["publishedAt"],
+            "views": stats.get("views", 0),
+            "likes": stats.get("likes", 0),
+            "comments": stats.get("comments", 0),
+        })
+    
+    # DB에 저장
+    if save_db:
+        save_to_db(videos_data, channel_subs_raw, keyword, country, language, sort_by)
     
+    # HTML 테이블 생성
     html = f'''
     <style>
         .yt-table {{ width: 100%; border-collapse: collapse; font-size: 14px; }}
@@ -265,8 +536,9 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results)
         .yt-views {{ font-weight: bold; color: #065fd4; }}
         .yt-subs {{ color: #606060; }}
         .yt-date {{ color: #888; font-size: 12px; }}
+        .surge {{ background: #fff3cd !important; }}
     </style>
-    <p><b>총 {len(all_items)}개 결과</b> | 검색어: "{keyword}" | 정렬: {sort_by}</p>
+    <p><b>총 {len(all_items)}개 결과</b> | 검색어: "{keyword}" | 정렬: {sort_by} | 💾 DB 저장 완료</p>
     <div style="max-height: 800px; overflow-y: auto;">
     <table class="yt-table">
         <thead>
@@ -303,8 +575,8 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results)
         
         stats = video_stats.get(video_id, {})
         views = stats.get("views_fmt", "N/A")
-        likes = stats.get("likes", "N/A")
-        comments = stats.get("comments", "N/A")
+        likes = stats.get("likes_fmt", "N/A")
+        comments = stats.get("comments_fmt", "N/A")
         subs = channel_subs.get(channel_id, "N/A")
         
         if i == 1:
@@ -331,38 +603,213 @@ def search_videos(keyword, country, language, sort_by, date_filter, max_results)
         '''
     
     html += '</tbody></table></div>'
+    
+    # DB 통계 업데이트
+    db_stats = get_db_stats()
+    stats_html = f"📊 DB: 영상 {db_stats['videos']}개 | 기록 {db_stats['stats_records']}건 | 채널 {db_stats['channels']}개 | 검색 {db_stats['searches']}회 | 알림 {db_stats['alerts']}건"
+    
+    return html, stats_html
+
+def show_trending_alerts():
+    """급상승 알림 표시"""
+    alerts = get_trending_alerts()
+    
+    if not alerts:
+        return "<p>아직 급상승 알림이 없습니다. 데이터를 더 수집해주세요.</p>"
+    
+    html = '''
+    <style>
+        .alert-table { width: 100%; border-collapse: collapse; }
+        .alert-table th { background: #ff6b6b; color: white; padding: 10px; }
+        .alert-table td { padding: 10px; border-bottom: 1px solid #ddd; }
+        .surge-badge { background: #ff0000; color: white; padding: 2px 8px; border-radius: 10px; font-size: 12px; }
+    </style>
+    <h3>🔥 급상승 알림 (조회수 20% 이상 증가)</h3>
+    <table class="alert-table">
+        <thead>
+            <tr>
+                <th>영상</th>
+                <th>채널</th>
+                <th>이전</th>
+                <th>현재</th>
+                <th>증가율</th>
+                <th>감지 시간</th>
+            </tr>
+        </thead>
+        <tbody>
+    '''
+    
+    for alert in alerts:
+        video_id, title, channel, alert_type, old_val, new_val, change_pct, detected = alert
+        title = title[:30] + "..." if len(title) > 30 else title
+        url = f"https://youtube.com/watch?v={video_id}"
+        detected_fmt = detected[:16].replace("T", " ")
+        
+        html += f'''
+            <tr>
+                <td><a href="{url}" target="_blank">{title}</a></td>
+                <td>{channel}</td>
+                <td>{format_count(old_val)}</td>
+                <td>{format_count(new_val)}</td>
+                <td><span class="surge-badge">+{change_pct:.1f}%</span></td>
+                <td>{detected_fmt}</td>
+            </tr>
+        '''
+    
+    html += '</tbody></table>'
     return html
 
-initial_trending = get_default_trending()
+def show_top_growing():
+    """급성장 영상 TOP 10"""
+    results = get_top_growing_videos(24)
+    
+    if not results:
+        return "<p>최근 24시간 내 급성장 영상 데이터가 없습니다.</p>"
+    
+    html = '''
+    <h3>📈 24시간 급성장 TOP 10</h3>
+    <div style="display: flex; flex-wrap: wrap; gap: 15px;">
+    '''
+    
+    for i, (video_id, title, channel, thumbnail, min_views, max_views, growth) in enumerate(results, 1):
+        title = title[:25] + "..." if len(title) > 25 else title
+        url = f"https://youtube.com/watch?v={video_id}"
+        
+        html += f'''
+        <div style="width: 180px; border: 1px solid #ddd; border-radius: 8px; padding: 10px;">
+            <a href="{url}" target="_blank">
+                <img src="{thumbnail}" style="width: 100%; border-radius: 5px;">
+            </a>
+            <p style="margin: 5px 0; font-size: 12px;"><b>{i}.</b> {title}</p>
+            <p style="margin: 0; font-size: 11px; color: #666;">{channel}</p>
+            <p style="margin: 5px 0; font-size: 14px; color: #ff0000; font-weight: bold;">📈 +{growth:.1f}%</p>
+            <p style="margin: 0; font-size: 10px; color: #888;">{format_count(min_views)} → {format_count(max_views)}</p>
+        </div>
+        '''
+    
+    html += '</div>'
+    return html
 
-with gr.Blocks() as demo:
-    gr.Markdown("## YouTube 인기 영상 검색기")
+def show_search_history():
+    """검색 기록 표시"""
+    history = get_search_history()
     
-    gr.Markdown("### 🔥 실시간 인기 검색어")
-    trending_radio = gr.Radio(
-        choices=initial_trending,
-        label="클릭하면 검색창에 자동 입력됩니다",
-        interactive=True
-    )
+    if not history:
+        return "<p>검색 기록이 없습니다.</p>"
     
-    gr.Markdown("---")
+    html = '''
+    <h3>🕐 최근 검색 기록</h3>
+    <table style="width:100%; border-collapse: collapse;">
+        <thead>
+            <tr style="background: #333; color: white;">
+                <th style="padding: 10px;">검색어</th>
+                <th style="padding: 10px;">국가</th>
+                <th style="padding: 10px;">언어</th>
+                <th style="padding: 10px;">정렬</th>
+                <th style="padding: 10px;">결과 수</th>
+                <th style="padding: 10px;">검색 시간</th>
+            </tr>
+        </thead>
+        <tbody>
+    '''
     
-    with gr.Row():
-        keyword = gr.Textbox(label="검색어", placeholder="검색어 ��력...", scale=3)
-        btn = gr.Button("검색", variant="primary", scale=1)
+    for keyword, country, language, sort_by, count, searched_at in history:
+        searched_fmt = searched_at[:16].replace("T", " ")
+        html += f'''
+            <tr style="border-bottom: 1px solid #ddd;">
+                <td style="padding: 8px;"><b>{keyword}</b></td>
+                <td style="padding: 8px;">{country}</td>
+                <td style="padding: 8px;">{language}</td>
+                <td style="padding: 8px;">{sort_by}</td>
+                <td style="padding: 8px;">{count}</td>
+                <td style="padding: 8px;">{searched_fmt}</td>
+            </tr>
+        '''
     
-    with gr.Row():
-        country = gr.Dropdown(list(COUNTRIES.keys()), value="한국", label="국가 (인구순)")
-        language = gr.Dropdown(list(LANGUAGES.keys()), value="전체", label="언어 (사용인구순)")
-        sort_by = gr.Dropdown(list(SORT_OPTIONS.keys()), value="조회수 순", label="정렬")
-        date_filter = gr.Dropdown(list(DATE_OPTIONS.keys()), value="전체 기간", label="기간")
-        max_results = gr.Slider(10, 300, value=50, step=10, label="결과 수")
+    html += '</tbody></table>'
+    return html
+
+def refresh_all():
+    """전체 데이터 갱신"""
+    db_stats = get_db_stats()
+    alerts = show_trending_alerts()
+    growing = show_top_growing()
+    history = show_search_history()
+    stats_html = f"📊 DB: 영상 {db_stats['videos']}개 | 기록 {db_stats['stats_records']}건 | 채널 {db_stats['channels']}개 | 검색 {db_stats['searches']}회 | 알림 {db_stats['alerts']}건"
     
-    output = gr.HTML()
+    return alerts, growing, history, stats_html
+
+# 초기 트렌딩 키워드
+initial_trending = get_default_trending()
+
+with gr.Blocks() as demo:
+    gr.Markdown("## YouTube 인기 영상 검색기 + 트렌드 분석")
+    
+    # DB 통계
+    db_stats_display = gr.Markdown("📊 DB 통계 로딩중...")
     
+    with gr.Tabs():
+        # 탭 1: 검색
+        with gr.Tab("🔍 검색"):
+            gr.Markdown("### 🔥 실시간 인기 검색어")
+            trending_radio = gr.Radio(
+                choices=initial_trending,
+                label="클릭하면 검색창에 자동 입력",
+                interactive=True
+            )
+            
+            with gr.Row():
+                keyword = gr.Textbox(label="검색어", placeholder="검색어 입력...", scale=3)
+                btn = gr.Button("🔍 검색", variant="primary", scale=1)
+                refresh_btn = gr.Button("🔄 갱신", scale=1)
+            
+            with gr.Row():
+                country = gr.Dropdown(list(COUNTRIES.keys()), value="한국", label="국가 (인구순)")
+                language = gr.Dropdown(list(LANGUAGES.keys()), value="전체", label="언어 (사용인구순)")
+                sort_by = gr.Dropdown(list(SORT_OPTIONS.keys()), value="조회수 순", label="정렬")
+                date_filter = gr.Dropdown(list(DATE_OPTIONS.keys()), value="전체 기간", label="기간")
+                max_results = gr.Slider(10, 300, value=50, step=10, label="결과 수")
+            
+            search_output = gr.HTML()
+        
+        # 탭 2: 급상승
+        with gr.Tab("🔥 급상승"):
+            refresh_alerts_btn = gr.Button("🔄 새로고침", variant="secondary")
+            alerts_output = gr.HTML()
+        
+        # 탭 3: 급성장
+        with gr.Tab("📈 급성장 TOP"):
+            refresh_growing_btn = gr.Button("🔄 새로고침", variant="secondary")
+            growing_output = gr.HTML()
+        
+        # 탭 4: 검색 기록
+        with gr.Tab("🕐 검색 기록"):
+            refresh_history_btn = gr.Button("🔄 새로고침", variant="secondary")
+            history_output = gr.HTML()
+    
+    # 이벤트 연결
     trending_radio.change(use_trending_keyword, trending_radio, keyword)
     country.change(update_trending, country, trending_radio)
-    btn.click(search_videos, [keyword, country, language, sort_by, date_filter, max_results], output)
-    keyword.submit(search_videos, [keyword, country, language, sort_by, date_filter, max_results], output)
+    
+    btn.click(
+        search_videos, 
+        [keyword, country, language, sort_by, date_filter, max_results], 
+        [search_output, db_stats_display]
+    )
+    keyword.submit(
+        search_videos, 
+        [keyword, country, language, sort_by, date_filter, max_results], 
+        [search_output, db_stats_display]
+    )
+    
+    refresh_btn.click(
+        search_videos, 
+        [keyword, country, language, sort_by, date_filter, max_results], 
+        [search_output, db_stats_display]
+    )
+    
+    refresh_alerts_btn.click(show_trending_alerts, outputs=alerts_output)
+    refresh_growing_btn.click(show_top_growing, outputs=growing_output)
+    refresh_history_btn.click(show_search_history, outputs=history_output)
 
 demo.launch()