- import sqlite3
+ import json          # 벡터가 문자로 들어 있어서 필요하다
+ import sqlite3

def load_vectors(table, key, connection=None):
    """문자로 넣어 둔 벡터를 numpy 행렬로 되살린다.

    '[0.018827,-0.024955,...]' 라는 글자를 숫자 목록으로 되돌린다.
    한 번만 하면 된다 ― 그다음부터는 그냥 숫자 행렬이라 BLOB 과 속도가 같다.
    돌려주는 것: (아이디 목록, (행 수 x 차원) 행렬)

    connection 을 안 주면 이 파일의 연결을 쓴다. 
    파이프라인은 자기 연결을 들고 있어서 그것을 넘긴다.  안 넘기면 같은
       DB 에 연결이 하나 더 열린다 (pipeline/04_verify.py 가 그 자리다).
    """
    #    numpy 는 여기서만 쓴다. 파일 맨 위에 두면 SELECT 만 하는 파일까지
    #    (features/profile.py 가 그렇다) numpy 를 끌고 온다. 아래 load_documents 가
    #    LangChain 을 함수 안에서 부르는 것과 같은 이유다
    import numpy as np

    con_in_use = connection if connection is not None else con

    ids, rows = [], []
    for row_id, vector in con_in_use.execute(f"SELECT {key}, vector FROM {table}"):
        ids.append(row_id)
        rows.append(json.loads(vector))
    return ids, np.array(rows, dtype="float32")

"""점검 ― 만든 것이 쓸 수 있는 물건인지 재는 함수들.

    04_verify.py   무엇을 어떤 순서로 점검하나    (verifying.py에 있는 함수를 호출해서 조립하는 위치)
    verifying.py   그 점검을 실제로 어떻게 하나   (실제 04_verify.py에서 활용되는 함수 모음집)

   이 파일은 아무것도 만들지 않는다. `CREATE` 도 `INSERT` 도 `DROP` 도 없다.
   그래서 몇 번을 돌려도 데이터가 안 바뀐다. 재는 파일의 조건이다.

   연결(con)을 **인자로 받는다. 자기가 열지 않는다.** 부르는 쪽이 이미 하나
   열었는데 여기서 또 열면 같은 DB 에 연결이 둘이 된다. storage.py 와 같은 규칙이다.

   검사 결과를 `problems` 목록에 **쌓아서 돌려준다.** 첫 실패에서 멈추지 않는다 ―
   한 번 돌려서 「무엇이 몇 개 틀렸나」를 다 보는 것이 점검표의 값이다.
"""

import numpy as np

#    되살리는 일은 앱도 똑같이 한다. 여기서 한 벌 더 짜면 언젠가 둘이
#    어긋난다 ― 그때 검색은 조용히 이상해진다. 그래서 앱이 쓰는 것을 그대로 쓴다.
#    연결만 우리 것을 넘긴다 (app/core/db.py 의 connection 인자가 그 자리다)
from app.core.db import load_vectors


def check(ok, message, problems):
    """참/거짓을 화면에 한 줄로 찍고, 실패한 것만 problems 에 쌓는다.

       이 함수는 **무엇을 검사하는지 모른다.** 이미 판정된 참/거짓만 받는다.
       그래서 검사가 몇 개로 늘어도 이 함수는 안 바뀐다.

    problems 는 목록이라 append 한 결과가 부른 쪽에도 그대로 남는다.
    그래서 여러 검사 함수가 실패를 **한 목록**에 모을 수 있다.
    """
    print(f"  [{'OK  ' if ok else '문제'}] {message}")
    if not ok:
        problems.append(message)


# ═════════════════════════════ 3일차 5교시 ― 만든 것을 잰다 (1~4번)

# ─────────────────────────────────────────────── 1. 개수

def check_table_data(con, table_names, problems):
    """표마다 몇 행인가. 벡터가 빠진 행은 없는가. 돌려주는 것: {표 이름: 행 수}

    개수가 같다고 열쇠가 하나하나 맞는다는 증명은 아니다. 그래서 FK 검사를 같이 한다.
    """
    counts = {}
    for table in table_names:
        counts[table] = con.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]
        print(f"  {table:18s} {counts[table]:>7,}")

    print()
    check(counts["chunk_vectors"] == counts["chunks"],
          f"모든 조각에 벡터가 있다 ({counts['chunk_vectors']:,}/{counts['chunks']:,})",
          problems)
    check(counts["product_vectors"] == counts["products"],
          f"모든 상품에 벡터가 있다 ({counts['product_vectors']:,}/{counts['products']:,})",
          problems)

    orphan = con.execute("""
        SELECT COUNT(*) FROM chunks
        WHERE section_id NOT IN (SELECT section_id FROM sections)
    """).fetchone()[0]
    check(orphan == 0,
          f"조각이 전부 원문 섹션에 연결돼 있다 (끊긴 것 {orphan}개) ― small-to-big 의 전제",
          problems)

    fk_errors = con.execute("PRAGMA foreign_key_check").fetchall()
    check(len(fk_errors) == 0, f"FK 위반 없음 (어긴 행 {len(fk_errors)}개)", problems)

    #    채점의 전제다. hit@k 는 「숨겨 둔 정답이 상위 k 안에 오나」를 세는데,
    #    고객에게 숨겨 둔 정답이 없으면 셀 것이 없다. compare_recommendations() 가
    #    answers[customer_id] 로 바로 꺼내 쓰기 때문에 **없으면 그 자리에서 죽는다**
    holdout = con.execute(
        "SELECT COUNT(*) FROM purchases WHERE is_holdout = 1").fetchone()[0]
    check(holdout == counts["customers"],
          f"채점용 정답이 고객당 1건이다 ({holdout}건 / 고객 {counts['customers']}명)",
          problems)

    return counts


# ─────────────────────────────────────────────── 2. 벡터

def check_vector_data(con, kinds, expected_dim, expected_model, problems):
    """네 벌을 되살려 차원 · 모델 · 정규화를 본다.

    돌려주는 것: {종류: (아이디 목록, (행 수 x 차원) 행렬)}
    """
    vectors = {}
    for kind, key in kinds:
        ids, matrix = load_vectors(f"{kind}_vectors", key, connection=con)
        vectors[kind] = (ids, matrix)

        # matrix.shape 는 (행 수, 차원) 이다. 행 하나가 벡터 하나다
        models = [m for (m,) in
                  con.execute(f"SELECT DISTINCT model FROM {kind}_vectors")]
        print(f"  {kind:9s} {matrix.shape[0]:>6,} x {matrix.shape[1]}  "
              f"모델 {', '.join(models)}")

    print()
    all_dims = {matrix.shape[1] for _, matrix in vectors.values()}
    check(all_dims == {expected_dim},
          f"네 벌 모두 {expected_dim}차원이다 (실제 {all_dims})", problems)

    all_models = {model for kind, _ in kinds
                  for (model,) in
                  con.execute(f"SELECT DISTINCT model FROM {kind}_vectors")}
    check(all_models == {expected_model},
          f"네 벌이 같은 모델로 만들어졌다 ― 다른 모델끼리는 비교 자체가 무의미하다 "
          f"(실제 {all_models})", problems)

    #    아래 4·5번이 통째로 이 한 줄 위에 서 있다. 길이가 1 이면 내적이 곧
    #    코사인 유사도라 나눗셈을 안 해도 된다. 길이가 1 이 아닌데 내적을 쓰면
    #    **긴 벡터가 무조건 이긴다** ― 그래도 오류는 안 난다
    norms = {kind: np.linalg.norm(matrix, axis=1)
             for kind, (_, matrix) in vectors.items()}
    worst = max(abs(n - 1).max() for n in norms.values())
    check(worst < 1e-3,
          f"전부 길이 1 로 정규화돼 있다 -> 내적이 곧 코사인 유사도 "
          f"(제일 어긋난 것도 {worst:.6f})", problems)

    return vectors


# ─────────────────────────────────────────────── 3. 저장 방식

def check_vector_storage(con, kinds, vectors, embed_dim):
    """문자로 넣은 대가를 크기로 잰다. 돌려주는 것: {개수, 문자 바이트, BLOB 바이트}

    지금 벡터는 '[0.018827,-0.024955,...]' 라는 **글자**로 들어 있다. 같은 숫자를
    BLOB(이진)으로 넣으면 float 하나가 딱 4바이트다. 얼마나 차이 나는지 잰다.

       그런데도 문자를 골랐다. `SELECT vector FROM ...` 하면 숫자가 그대로 보이기
       때문이다. 이건 교재라서 그렇게 골랐고, 100만 개가 되면 다시 판단할 일이다.
    """
    vector_count = sum(matrix.shape[0] for _, matrix in vectors.values())

    # LENGTH() 는 글자 수를 센다. 벡터 문자는 숫자와 기호뿐이라 바이트와 사실상 같다
    text_bytes = sum(
        con.execute(f"SELECT COALESCE(SUM(LENGTH(vector)), 0) FROM {kind}_vectors")
           .fetchone()[0]
        for kind, _ in kinds)
    blob_bytes = vector_count * embed_dim * 4      # float32 하나가 4바이트

    print(f"  벡터 {vector_count:,}개 ({embed_dim}차원)")
    print(f"      문자   {text_bytes / 1024 / 1024:>5.1f}MB   (지금 이 방식)")
    print(f"      BLOB   {blob_bytes / 1024 / 1024:>5.1f}MB   (같은 숫자를 이진으로)")
    print(f"      -> 문자가 {text_bytes / blob_bytes:.1f}배 크다. "
          "대신 SELECT 하면 눈에 보인다")

    return {"vector_count": vector_count,
            "text_bytes": text_bytes,
            "blob_bytes": blob_bytes}


# ─────────────────────────────────────────────── 4. 토큰

def check_token_sizes(con, max_tokens, problems):
    """상한을 넘어 조용히 잘리는 조각이 있는가.

    돌려주는 것: {조각 토큰 목록, 섹션 토큰 목록, 넘은 개수, 조각 평균 토큰}

    토큰은 글자 수도 낱말 수도 아니다. 모델이 글을 나누는 단위다. 상한을 넘으면
    **뒤가 잘린 채로 벡터가 된다** ― 그래도 오류는 안 난다.
    """
    chunk_tokens = sorted(n for (n,) in con.execute("SELECT n_tokens FROM chunks"))
    section_tokens = [n for (n,) in con.execute("SELECT n_tokens FROM sections")]

    over = sum(n > max_tokens for n in chunk_tokens)
    average_chunk_tokens = sum(chunk_tokens) / len(chunk_tokens)

    check(over == 0,
          f"상한({max_tokens}) 을 넘는 조각 {over}개 ― 넘으면 뒤가 조용히 잘린다",
          problems)
    print(f"  조각 평균 {average_chunk_tokens:.1f}토큰 · 제일 긴 것 {max(chunk_tokens)}토큰")
    print(f"  상한 대비 여유가 {(1 - max(chunk_tokens) / max_tokens) * 100:.0f}% 남았다")

    return {"chunk_tokens": chunk_tokens,
            "section_tokens": section_tokens,
            "over": over,
            "average_chunk_tokens": average_chunk_tokens}


# ─────────────────────────────────────────────── 마무리

def print_final_result(problems):
    """쌓아 둔 문제를 한 번에 요약한다. 새로 검사하지 않는다."""
    print()
    print("=" * 74)
    if problems:
        print(f"문제 {len(problems)}건 ― 앱을 붙이기 전에 고친다")
        for message in problems:
            print(f"  - {message}")
    else:
        print("전부 통과. 1단계(파이프라인) 끝. 다음은 2단계 ― uvicorn app.main:app --reload")
    print("=" * 74)

"""점검 ― 파이프라인이 만든 것이 쓸 수 있는 물건인지 확인한다.

    1. 개수      표마다 몇 행인가. 벡터가 빠진 행은 없는가
    2. 벡터      차원 · 모델 · 정규화가 맞는가
    3. 저장      문자로 넣은 대가가 얼마인가 (BLOB 과 크기를 견준다)
    4. 토큰      조각 분포. 상한을 넘어 잘리는 것은 없는가

   **이 파일은 순서만 정한다.** 재는 일은 전부 prep/verifying.py 안에 있다.
   02_chunk.py 가 chunking.py 를, 03_embed.py 가 embedding.py 를 부르는 것과
   같은 모양이다 ― 조립하는 파일을 읽으면 **무엇을 하는지**가 보이고,
   몸통 파일을 열면 **어떻게 하는지**가 보인다.

   이 파일은 아무것도 만들지 않는다. 몇 번을 돌려도 데이터가 안 바뀐다.
   여기서 [문제] 가 하나라도 나오면 앱을 붙이기 전에 고친다.

앞:    python pipeline/03_embed.py
실행:  python pipeline/04_verify.py
"""

import sqlite3
import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
sys.stdout.reconfigure(errors="replace")

from app.core.config import DB_PATH, EMBED_DIM, EMBED_MAX_TOKENS, EMBED_MODEL
from pipeline.prep import verifying

con = sqlite3.connect(DB_PATH)
problems = []          # 여기 쌓인 게 있으면 마지막에 빨갛게 요약한다

# 벡터 네 벌과 각 표의 열쇠 컬럼. 여기서 한 줄을 빠뜨리면 점검이 세 벌만 보고
# 「이상 없음」이라고 말한다 ― 검사가 조용히 거짓말을 하는 자리다
KINDS = (("chunk", "chunk_id"), ("product", "product_id"),
         ("customer", "customer_id"), ("review", "purchase_id"))

TABLES = ("customers", "products", "purchases", "product_details",
          "sections", "chunks", "chunk_vectors", "product_vectors",
          "customer_vectors", "review_vectors")


def banner(title):
    print()
    print("=" * 74)
    print(title)
    print("=" * 74)


# ═══════════════════════════════════════════════ 1. 개수
banner("1. 개수")
counts = verifying.check_table_data(con, TABLES, problems)

# ═══════════════════════════════════════════════ 2. 벡터
banner("2. 벡터")
vectors = verifying.check_vector_data(con, KINDS, EMBED_DIM, EMBED_MODEL, problems)

# ═══════════════════════════════════════════════ 3. 저장 방식
banner("3. 저장 방식 ― 문자로 넣은 대가를 잰다")
verifying.check_vector_storage(con, KINDS, vectors, EMBED_DIM)

# ═══════════════════════════════════════════════ 4. 토큰
banner("4. 토큰 ― 잘리는 것이 있는가")
token_result = verifying.check_token_sizes(con, EMBED_MAX_TOKENS, problems)

verifying.print_final_result(problems)
con.close()

import json
import sqlite3
import time

import numpy as np

# ① 같은 조건에서 재려고 BLOB 판을 임시로 만든다 (메모리 DB · 끝나면 사라진다)
flat = np.vstack([matrix for _, matrix in vectors.values()])
tmp = sqlite3.connect(":memory:")
tmp.execute("CREATE TABLE v (id INTEGER PRIMARY KEY, vec BLOB)")
tmp.executemany("INSERT INTO v VALUES (?, ?)",
                [(i, row.tobytes()) for i, row in enumerate(flat)])


def timed(fn, repeat=3):
    """세 번 재서 제일 빠른 값을 쓴다 ― 다른 프로그램에 밀린 판을 버린다."""
    best = None
    for _ in range(repeat):
        started = time.perf_counter()
        fn()
        elapsed = time.perf_counter() - started
        best = elapsed if best is None else min(best, elapsed)
    return best


def read_text():
    return np.array([json.loads(v) for kind, _ in KINDS
                     for (v,) in con.execute(f"SELECT vector FROM {kind}_vectors")],
                    dtype="float32")


def read_blob():
    return np.vstack([np.frombuffer(v, dtype="float32", count=EMBED_DIM)
                      for (v,) in tmp.execute("SELECT vec FROM v")])


print(f"문자 {timed(read_text) * 1000:.1f}ms · BLOB {timed(read_blob) * 1000:.1f}ms")
tmp.close()

# ② 자릿수를 줄이면서 얼마나 손해 봤나
exact = np.array(json.loads(con.execute(
    "SELECT vector FROM product_vectors LIMIT 1").fetchone()[0]), dtype="float64")
first = vectors["product"][1][0]
print(f"길이 오차 {abs(np.linalg.norm(exact) - 1):.8f} · "
      f"벡터끼리 코사인 {float(first @ first):.8f}")

import time

from app.core.db import query
from pipeline.prep import chunking, embedding

chunks = [t for (t,) in query("SELECT text FROM chunks ORDER BY chunk_id")]
reviews = [t for (t,) in query(
    "SELECT review FROM purchases WHERE is_holdout = 0 AND review != '' ORDER BY purchase_id")]

total_tokens = sum(chunking.count_tokens(t) for t in chunks + reviews)
print(f"  조각 {len(chunks):,}건 + 후기 {len(reviews):,}건 = {total_tokens:,} 토큰")

started = time.perf_counter()
embedding.get_embeddings()
print(f"  모델 올리기 {time.perf_counter() - started:.1f}초\n")

# ① 후기 한 건이 새로 들어왔다면 ― 그것만 임베딩한다
one = reviews[0]
best = None
for _ in range(5):
    started = time.perf_counter()
    embedding.embed_documents([one])
    elapsed = time.perf_counter() - started
    best = elapsed if best is None else min(best, elapsed)
print(f"  ① 새 후기 1건만        {best * 1000:>8.1f}ms  ({chunking.count_tokens(one)} 토큰)")

# ② 지금 방식 ― 표를 DROP 하고 전부 다시 만든다
started = time.perf_counter()
embedding.embed_documents(chunks)
full = time.perf_counter() - started
print(f"  ② 조각 전량 다시       {full:>8.1f}초   ({sum(chunking.count_tokens(t) for t in chunks):,} 토큰)")

print(f"\n  같은 일을 하는 데 {full / best:,.0f}배")