Skip to content
The Chat Archive
claude-sonnet-4-20250514· Anthropic LMArena Human Preference 140K

해당 테이블이 2NF를 만족하는지 확인하는 파이썬 코드 작성해줘 TARGETDBCONFIG = { 'host': 'localhost', 'user':…

  1. User

    해당 테이블이 2NF를 만족하는지 확인하는 파이썬 코드 작성해줘

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

    TABLE_NAME = 'HashKeyInfo'

  2. Assistant

    2NF(제2정규형) 확인을 위한 파이썬 코드를 작성해드리겠습니다. 2NF는 1NF를 만족하면서 부분 함수 종속이 없어야 합니다.

    import mysql.connector
    from itertools import combinations
    from collections import defaultdict
    
    TARGET_DB_CONFIG = {
        'host': 'localhost',
        'user': 'root',
        'password': '',
        'database': 'norm_project_db'
    }
    
    TABLE_NAME = 'HashKeyInfo'
    
    class SecondNormalFormChecker:
        def __init__(self, db_config, table_name):
            self.db_config = db_config
            self.table_name = table_name
            self.connection = None
            self.cursor = None
            
        def connect_db(self):
            """데이터베이스 연결"""
            try:
                self.connection = mysql.connector.connect(**self.db_config)
                self.cursor = self.connection.cursor()
                print(f"데이터베이스 연결 성공: {self.db_config['database']}")
            except mysql.connector.Error as err:
                print(f"데이터베이스 연결 실패: {err}")
                return False
            return True
        
        def close_db(self):
            """데이터베이스 연결 종료"""
            if self.cursor:
                self.cursor.close()
            if self.connection:
                self.connection.close()
        
        def get_table_info(self):
            """테이블 구조 정보 가져오기"""
            try:
                query = f"DESCRIBE {self.table_name}"
                self.cursor.execute(query)
                columns_info = self.cursor.fetchall()
                
                columns = [col[0] for col in columns_info]
                print(f"\n테이블 '{self.table_name}' 컬럼: {columns}")
                
                return columns
            except mysql.connector.Error as err:
                print(f"테이블 정보 조회 실패: {err}")
                return None
        
        def get_primary_key(self):
            """기본키 정보 가져오기"""
            try:
                query = f"""
                SELECT COLUMN_NAME 
                FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE 
                WHERE TABLE_SCHEMA = '{self.db_config['database']}' 
                AND TABLE_NAME = '{self.table_name}' 
                AND CONSTRAINT_NAME = 'PRIMARY'
                ORDER BY ORDINAL_POSITION
                """
                self.cursor.execute(query)
                pk_columns = [row[0] for row in self.cursor.fetchall()]
                
                if pk_columns:
                    print(f"기본키: {pk_columns}")
                else:
                    print("기본키가 정의되지 않았습니다.")
                
                return pk_columns
            except mysql.connector.Error as err:
                print(f"기본키 조회 실패: {err}")
                return []
        
        def get_sample_data(self, limit=100):
            """샘플 데이터 가져오기"""
            try:
                query = f"SELECT * FROM {self.table_name} LIMIT {limit}"
                self.cursor.execute(query)
                data = self.cursor.fetchall()
                
                print(f"\n샘플 데이터 개수: {len(data)}개")
                return data
            except mysql.connector.Error as err:
                print(f"데이터 조회 실패: {err}")
                return []
        
        def check_functional_dependency(self, determinant_cols, dependent_col, data, all_columns):
            """함수 종속성 확인"""
            if not data:
                return False
                
            # 컬럼 인덱스 찾기
            determinant_indices = []
            for col in determinant_cols:
                try:
                    determinant_indices.append(all_columns.index(col))
                except ValueError:
                    return False
            
            try:
                dependent_index = all_columns.index(dependent_col)
            except ValueError:
                return False
            
            # 함수 종속성 확인
            dependency_map = {}
            
            for row in data:
                # determinant 값들의 조합
                determinant_values = tuple(row[i] for i in determinant_indices)
                dependent_value = row[dependent_index]
                
                if determinant_values in dependency_map:
                    if dependency_map[determinant_values] != dependent_value:
                        return False  # 함수 종속성 위반
                else:
                    dependency_map[determinant_values] = dependent_value
            
            return True
        
        def find_partial_dependencies(self, primary_key, columns, data):
            """부분 함수 종속 찾기"""
            if len(primary_key) <= 1:
                print("기본키가 단일 속성이므로 부분 함수 종속이 발생할 수 없습니다.")
                return []
            
            partial_dependencies = []
            non_key_columns = [col for col in columns if col not in primary_key]
            
            print(f"\n부분 함수 종속 검사 중...")
            print(f"기본키: {primary_key}")
            print(f"비키 속성: {non_key_columns}")
            
            # 기본키의 진부분집합들에 대해 검사
            for r in range(1, len(primary_key)):
                for pk_subset in combinations(primary_key, r):
                    pk_subset = list(pk_subset)
                    
                    for non_key_col in non_key_columns:
                        if self.check_functional_dependency(pk_subset, non_key_col, data, columns):
                            partial_dependencies.append((pk_subset, non_key_col))
                            print(f"부분 함수 종속 발견: {pk_subset} → {non_key_col}")
            
            return partial_dependencies
        
        def check_2nf(self):
            """2NF 확인"""
            print("=" * 60)
            print("제2정규형(2NF) 확인 시작")
            print("=" * 60)
            
            if not self.connect_db():
                return False
            
            try:
                # 테이블 정보 가져오기
                columns = self.get_table_info()
                if not columns:
                    return False
                
                # 기본키 정보 가져오기
                primary_key = self.get_primary_key()
                if not primary_key:
                    print("\n⚠️  기본키가 없습니다. 2NF 확인을 위해서는 기본키가 필요합니다.")
                    return False
                
                # 샘플 데이터 가져오기
                data = self.get_sample_data()
                if not data:
                    print("\n⚠️  데이터가 없습니다.")
                    return False
                
                # 부분 함수 종속 확인
                partial_dependencies = self.find_partial_dependencies(primary_key, columns, data)
                
                print("\n" + "=" * 60)
                print("2NF 확인 결과")
                print("=" * 60)
                
                if not partial_dependencies:
                    print("✅ 테이블이 2NF를 만족합니다!")
                    print("   부분 함수 종속이 발견되지 않았습니다.")
                    return True
                else:
                    print("❌ 테이블이 2NF를 만족하지 않습니다!")
                    print(f"   {len(partial_dependencies)}개의 부분 함수 종속이 발견되었습니다:")
                    
                    for determinant, dependent in partial_dependencies:
                        print(f"   - {determinant} → {dependent}")
                    
                    print("\n📋 2NF로 정규화하려면:")
                    print("   1. 부분 함수 종속을 제거해야 합니다.")
                    print("   2. 각 부분 함수 종속을 별도 테이블로 분리하세요.")
                    
                    return False
                    
            except Exception as e:
                print(f"오류 발생: {e}")
                return False
            finally:
                self.close_db()
    
    def main():
        """메인 함수"""
        checker = SecondNormalFormChecker(TARGET_DB_CONFIG, TABLE_NAME)
        result = checker.check_2nf()
        
        print(f"\n최종 결과: {'2NF 만족' if result else '2NF 불만족'}")
    
    if __name__ == "__main__":
        main()
    

    이 코드의 주요 기능들:

    핵심 기능:

    • 테이블의 기본키와 컬럼 정보 자동 추출
    • 부분 함수 종속성 자동 검사
    • 2NF 만족 여부 판단

    검사 과정:

    1. 데이터베이스 연결 및 테이블 정보 수집
    2. 기본키가 복합키인지 확인 (단일키면 부분 함수 종속 불가능)
    3. 기본키의 진부분집합들과 비키 속성 간의 함수 종속성 검사
    4. 부분 함수 종속이 발견되면 2NF 위반으로 판단

    출력 정보:

    • 테이블 구조 및 기본키 정보
    • 발견된 부분 함수 종속 목록
    • 2NF 만족 여부 및 정규화 가이드

    코드를 실행하면 HashKeyInfo 테이블이 2NF를 만족하는지 자동으로 확인하고 결과를 출력합니다.

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