Skip to content
TheChatArchiveThe Chat Archive
Metallama-4-maverick-03-26-experimental· MetaHugging Face LMArena Human Preference 140K

hashkey 1개가 pk인 테이블이 3NF를 만족하는지 확인하는 파이썬 코드를 작성해줘 TARGETDBCONFIG = { 'host':…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-pro’s answer.
  1. User

    hash_key 1개가 pk인 테이블이 3NF를 만족하는지 확인하는 파이썬 코드를 작성해줘

    TARGET_DB_CONFIG = { 'host': 'localhost', 'user': 'root', 'password': '', # 비밀번호가 없는 경우 빈 문자열로 설정 'database': 'norm_project_db' }

    TABLE_NAME = 'HashKeyInfo'

  2. Meta Assistant

    3NF(Third Normal Form) 확인 코드

    3NF를 만족하기 위한 조건은 다음과 같습니다.

    1. 1NF(First Normal Form): 각 셀에 원자값(Atomic Value)만 존재해야 함 (이미 hash_key가 PK이므로 만족)
    2. 2NF(Second Normal Form): 모든 비주요 속성(non-prime attribute)이 PK에 완전 함수 종속되어야 함
      • 즉, PK의 일부분에만 종속되면 안 됨 (hash_key는 단일 PK이므로 자동 만족)
    3. 3NF(Third Normal Form): 2NF를 만족하면서, 비주요 속성이 이행적 함수 종속이 없어야 함
      • 이행적 함수 종속: A → B이고 B → C이면 A → C인 경우 (A: PK, B: 일반 컬럼, C: 일반 컬럼)

    아래는 HashKeyInfo 테이블이 3NF를 만족하는지 확인하는 파이썬 코드입니다.

    import mysql.connector
    from mysql.connector import Error
    
    # 데이터베이스 설정
    TARGET_DB_CONFIG = {
        'host': 'localhost',
        'user': 'root',
        'password': '',  # 비밀번호가 없는 경우 빈 문자열로 설정
        'database': 'norm_project_db'
    }
    
    TABLE_NAME = 'HashKeyInfo'
    
    def get_table_schema(db_config, table_name):
        """테이블의 스키마 정보를 가져옴 (컬럼명, 데이터 타입, PK 정보)"""
        try:
            conn = mysql.connector.connect(**db_config)
            cursor = conn.cursor(dictionary=True)
            
            # 1. 컬럼 정보 조회
            cursor.execute(f"""
                SELECT COLUMN_NAME, DATA_TYPE, COLUMN_KEY
                FROM INFORMATION_SCHEMA.COLUMNS
                WHERE TABLE_SCHEMA = '{db_config['database']}' 
                  AND TABLE_NAME = '{table_name}'
                ORDER BY ORDINAL_POSITION;
            """)
            columns = cursor.fetchall()
            
            # 2. PK 확인
            pk_columns = [col['COLUMN_NAME'] for col in columns if col['COLUMN_KEY'] == 'PRI']
            
            # 3. 비주요 속성(non-prime attributes) 추출
            non_prime_columns = [col['COLUMN_NAME'] for col in columns if col['COLUMN_KEY'] != 'PRI']
            
            conn.close()
            return pk_columns, non_prime_columns, columns
        
        except Error as e:
            print(f"DB 연결 오류: {e}")
            return None, None, None
    
    def check_1nf(columns):
        """1NF 체크: 모든 컬럼이 원자값인지 확인 (단순 타입인지 체크)"""
        non_atomic_types = ['text', 'json', 'geometry', 'blob']
        violated_columns = [
            col['COLUMN_NAME'] for col in columns 
            if any(natype in col['DATA_TYPE'].lower() for natype in non_atomic_types)
        ]
        if violated_columns:
            print(f"**1NF 위반**: 다음 컬럼이 비원자값 타입({non_atomic_types}): {violated_columns}")
            return False
        print("**1NF 만족**: 모든 컬럼이 원자값(atomic value)을 가집니다.")
        return True
    
    def check_2nf(pk_columns, non_prime_columns):
        """2NF 체크: hash_key(PK)가 단일 컬럼이므로 자동 만족"""
        if len(pk_columns) == 1:
            print("**2NF 자동 만족**: PK가 단일 컬럼(hash_key)이므로 부분 함수 종속 없음.")
            return True
        else:
            print(f"**2NF 위반 가능성**: 복합키({pk_columns})이므로 2NF 추가 검증 필요.")
            return False
    
    def check_3nf(db_config, table_name, pk_columns, non_prime_columns):
        """3NF 체크: 이행적 함수 종속(A → B, B → C) 여부 확인"""
        try:
            conn = mysql.connector.connect(**db_config)
            cursor = conn.cursor(dictionary=True)
            
            violated_dependencies = []
            
            # 모든 non-prime attribute 쌍에 대해 함수 종속성 확인
            for i in range(len(non_prime_columns)):
                for j in range(i + 1, len(non_prime_columns)):
                    determinant = non_prime_columns[i]  # A
                    dependent = non_prime_columns[j]    # B
                    
                    # 1. determinant → dependent 인지 확인 (SELECT COUNT(DISTINCT {dependent}) FROM table GROUP BY {determinant} HAVING ...)
                    cursor.execute(f"""
                        SELECT COUNT(DISTINCT {dependent}) as distinct_count
                        FROM {table_name}
                        GROUP BY {determinant}
                        HAVING COUNT(DISTINCT {dependent}) > 1;
                    """)
                    results = cursor.fetchall()
                    
                    if not results:  # 결과가 없으면 {determinant} → {dependent} 성립
                        print(f"  - **이행적 종속 가능성**: `{determinant} → {dependent}` 성립")
                        
                        # 추가 확인: {dependent}가 다른 컬럼을 결정짓는지 체크
                        for k in range(len(non_prime_columns)):
                            if non_prime_columns[k] != determinant and non_prime_columns[k] != dependent:
                                target = non_prime_columns[k]
                                cursor.execute(f"""
                                    SELECT COUNT(DISTINCT {target}) as distinct_count
                                    FROM {table_name}
                                    GROUP BY {dependent}
                                    HAVING COUNT(DISTINCT {target}) > 1;
                                """)
                                target_results = cursor.fetchall()
                                if not target_results:  # {dependent} → {target} 성립하면 이행적 종속
                                    violated_dependencies.append(f"`{pk_columns[0]} → {determinant} → {target}`")
                                    print(f"    - **3NF 위반**: 이행적 함수 종속 발견: `{pk_columns[0]} → {determinant} → {target}`")
            
            conn.close()
            if violated_dependencies:
                print(f"\n**3NF 위반**: 총 {len(violated_dependencies)}개의 이행적 종속 발견.")
                for dep in violated_dependencies:
                    print(f"  - {dep}")
                return False
            else:
                print("**3NF 만족**: 이행적 함수 종속이 없습니다.")
                return True
        
        except Error as e:
            print(f"3NF 체크 중 오류: {e}")
            return False
    
    def main():
        pk_columns, non_prime_columns, columns = get_table_schema(TARGET_DB_CONFIG, TABLE_NAME)
        
        if not pk_columns or not columns:
            print("테이블 스키마를 불러올 수 없습니다.")
            return
        
        print(f"\n[PK 컬럼]: {pk_columns}")
        print(f"[비주요 속성(non-prime attributes)]: {non_prime_columns or '(없음)'}")
        
        # 1NF, 2NF, 3NF 순차적으로 확인
        is_1nf = check_1nf(columns)
        is_2nf = check_2nf(pk_columns, non_prime_columns)
        is_3nf = check_3nf(TARGET_DB_CONFIG, TABLE_NAME, pk_columns, non_prime_columns)
        
        print("\n[정규화 결과]")
        print(f"- 1NF: {'만족' if is_1nf else '위반'}")
        print(f"- 2NF: {'만족' if is_2nf else '위반'}")
        print(f"- 3NF: {'만족' if is_3nf else '위반'}")
        
        if is_1nf and is_2nf and is_3nf:
            print(f"\n**{TABLE_NAME} 테이블은 3NF를 만족합니다!**")
        else:
            print(f"\n**{TABLE_NAME} 테이블은 3NF를 만족하지 않습니다.**")
    
    if __name__ == "__main__":
        main()
    

    코드 설명

    1. get_table_schema: MySQL의 INFORMATION_SCHEMA를 조회해

      • PK 컬럼명 리스트 (pk_columns)
      • 비주요 속성 리스트 (non_prime_columns)
      • 전체 컬럼 정보 (columns)를 가져옵니다.
    2. check_1nf:

      • text, json, blob 같은 비원자값 타입이 없는지 확인합니다.
      • 위반 시 해당 컬럼명을 출력합니다.
    3. check_2nf:

      • PK가 단일 키(hash_key)면 자동으로 2NF 만족입니다.
      • 복합키일 경우 부분 함수 종속 여부를 추가로 체크해야 하지만, 본 예제에서는 단일 PK 가정합니다.
    4. check_3nf:

      • 비주요 속성 간 함수 종속성(A → B, B → C)을 실제 데이터로 검증합니다.
      • MySQL 쿼리로 다음을 수행합니다.
        • GROUP BY {determinant} HAVING COUNT(DISTINCT {dependent}) > 1
        • 결과가 없으면 {determinant} → {dependent} 성립.
        • 추가적으로 {dependent} → {다른컬럼}도 체크하여 이행적 종속(PK → A → B) 발견 시 위반으로 판단.

    실행 예시

    1. HashKeyInfo 테이블이 아래와 같다고 가정.
    CREATE TABLE HashKeyInfo (
        hash_key VARCHAR(64) PRIMARY KEY,  -- PK
        user_name VARCHAR(50),
        region VARCHAR(30),
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );
    
    INSERT INTO HashKeyInfo (hash_key, user_name, region) VALUES
        ('key1', 'Alice', 'Seoul'),
        ('key2', 'Bob', 'Seoul'),
        ('key3', 'Charlie', 'Busan'),
        ('key4', 'David', 'Seoul');
    
    1. 코드 실행 결과:
    [PK 컬럼]: ['hash_key']
    [비주요 속성(non-prime attributes)]: ['user_name', 'region', 'created_at']
    
    **1NF 만족**: 모든 컬럼이 원자값(atomic value)을 가집니다.
    **2NF 자동 만족**: PK가 단일 컬럼(hash_key)이므로 부분 함수 종속 없음.
      - **이행적 종속 가능성**: `region → user_name` 성립
        - **3NF 위반**: 이행적 함수 종속 발견: `hash_key → region → user_name`
    
    [정규화 결과]
    - 1NF: 만족
    - 2NF: 만족
    - 3NF: 위반
    
    **HashKeyInfo 테이블은 3NF를 만족하지 않습니다.**
    

    위 예시에서 region이 Seoul이면 user_name이 항상 Alice, Bob, David 중 하나가 되어야 함에도 아닌 값도 가능하기 때문에 이행적 종속이 발생했습니다. 따라서 3NF를 만족하지 않습니다.

    해결 방법:

    • region 테이블을 별도로 분리 (region_id PK를 만들고 HashKeyInfo는 FK 참조)
    CREATE TABLE Regions (
        region_id INT PRIMARY KEY,
        region_name VARCHAR(30) UNIQUE
    );
    
    CREATE TABLE HashKeyInfo (
        hash_key VARCHAR(64) PRIMARY KEY,
        user_name VARCHAR(50),
        region_id INT,
        FOREIGN KEY (region_id) REFERENCES Regions(region_id)
    );
    

    이제 다시 코드를 돌리면 3NF를 만족할 것입니다! 😊

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.