Update app.py

app.py

@@ -234,17 +234,19 @@ def get_table_config(table_type):
 
 def fetch_database_records(standard, version, selection, table_type):
     if not all([standard, version, selection]):
-        return pd.DataFrame({"Info": ["선택 필요"]}), None
+        return pd.DataFrame({"Info": ["선택 필요"]}), []
 
     try:
         db_path = os.path.join(UPLOAD_DIR, f"{standard}_{version}.db")
         if not os.path.exists(db_path):
-            return pd.DataFrame({"Error": [f"파일을 찾을 수 없습니다: {db_path}"]}), None
+            return pd.DataFrame({"Error": [f"파일을 찾을 수 없습니다: {db_path}"]}), []
             
         conn = sqlite3.connect(db_path)
         conn.text_factory = decode_sqlite_text 
 
         anchor_col_config, display_setting = get_table_config(table_type)
+        # 앵커가 쉼표로 여러 개일 경우 리스트로 분할
+        anchor_cols_config = [x.strip() for x in anchor_col_config.split(',')]
 
         tables = pd.read_sql("SELECT name FROM sqlite_master WHERE type='table';", conn)['name'].tolist()
         main_table = f"{standard}_{version}"
@@ -255,11 +257,7 @@ def fetch_database_records(standard, version, selection, table_type):
         pattern = re.compile(f"^{standard}[_\\s-]*{version}[_\\s-]*", re.IGNORECASE)
 
         for t in tables:
-            if t == selection:
-                target_table = t
-                break
-            short_name = pattern.sub("", t).strip(" _")
-            if short_name == selection:
+            if t == selection or pattern.sub("", t).strip(" _") == selection:
                 target_table = t
                 break
 
@@ -289,15 +287,20 @@ def fetch_database_records(standard, version, selection, table_type):
 
         df = df.drop(columns=[c for c in df.columns if c.lower() == "version"], errors="ignore")
         
-        # 대소문자 무시하고 실제 앵커 컬럼명 찾기
-        real_anchor = next((c for c in df.columns if c.lower() == anchor_col_config.lower()), anchor_col_config)
+        # 대소문자 무시하고 실제 앵커 컬럼명 찾기 (다중 앵커 지원)
+        real_anchors = []
+        for ac in anchor_cols_config:
+            real_ac = next((c for c in df.columns if c.lower() == ac.lower()), ac)
+            real_anchors.append(real_ac)
 
         if display_setting:
             cols_to_show = [c.strip() for c in display_setting.split(',')]
             actual_cols_to_show = [c for c in df.columns if next((True for req in cols_to_show if c.lower() == req.lower()), False)]
             
-            if real_anchor in df.columns and real_anchor not in actual_cols_to_show:
-                actual_cols_to_show.insert(0, real_anchor)
+            # 설정된 출력 열에 앵커들이 없으면 강제 삽입
+            for ra in reversed(real_anchors):
+                if ra in df.columns and ra not in actual_cols_to_show:
+                    actual_cols_to_show.insert(0, ra)
             
             if actual_cols_to_show:
                 df = df[actual_cols_to_show]
@@ -306,12 +309,12 @@ def fetch_database_records(standard, version, selection, table_type):
             df[col] = df[col].apply(convert_blob_to_html_img)
 
         conn.close()
-        return df, real_anchor
+        return df, real_anchors # 단일 값이 아닌 앵커 '리스트' 반환
 
     except Exception as e:
         import traceback
         traceback.print_exc()
-        return pd.DataFrame({"Error": [str(e)]}), None
+        return pd.DataFrame({"Error": [str(e)]}), []
 
 
 def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, comp_cat):
@@ -319,39 +322,46 @@ def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, com
         is_main = base_cat == "ALL" or (base_cat and base_cat[0].isdigit() and "." in base_cat)
         table_type = "Main" if is_main else base_cat
 
+        # 시각적 중복 제거 함수 (폭포수 방식: 상위 컬럼이 같을 때만 하위 컬럼 지움)
+        def apply_visual_merge(df, cols):
+            if not df.empty and len(cols) > 1:
+                is_dup = pd.Series([True] * len(df), index=df.index)
+                for col in cols:
+                    if col in df.columns:
+                        curr = df[col].astype(str).str.strip()
+                        match = (curr == curr.shift(1)) & (~curr.isin(["", "nan", "None"]))
+                        is_dup = is_dup & match
+                        df.loc[is_dup, col] = ""
+            return df
+
         # ----------------------------------------
-        # 1. 단일 조회 (원본의 중복 공백 처리 복원)
+        # 1. 단일 조회 
         # ----------------------------------------
         if base_std and base_ver and base_cat and (not comp_std or not comp_ver or not comp_cat):
             df, _ = fetch_database_records(base_std, base_ver, base_cat, table_type)
             if "Error" in df.columns or "Info" in df.columns: return df
-
-            if not df.empty and len(df.columns) > 1:
-                is_duplicate = pd.Series([True] * len(df), index=df.index)
-                for col in df.columns[:-1]:
-                    current_col_str = df[col].astype(str).str.strip()
-                    current_match = (current_col_str == current_col_str.shift(1)) & (~current_col_str.isin(["", "nan", "None", " "]))
-                    is_duplicate = is_duplicate & current_match
-                    df.loc[is_duplicate, col] = " "
-            return df
+            return apply_visual_merge(df, df.columns)
 
         # ----------------------------------------
-        # 2. 비교 조회 (원본의 완벽한 브릿지 매핑 복원 + 동적 N열)
+        # 2. 비교 조회 
         # ----------------------------------------
         if all([base_std, base_ver, base_cat, comp_std, comp_ver, comp_cat]):
-            df_base, real_anchor_b = fetch_database_records(base_std, base_ver, base_cat, table_type)
-            df_comp, real_anchor_c = fetch_database_records(comp_std, comp_ver, comp_cat, table_type)
+            df_base, real_anchors_b = fetch_database_records(base_std, base_ver, base_cat, table_type)
+            df_comp, real_anchors_c = fetch_database_records(comp_std, comp_ver, comp_cat, table_type)
 
             if "Error" in df_base.columns: return df_base
             if "Error" in df_comp.columns: return df_comp
-            if real_anchor_b not in df_base.columns or real_anchor_c not in df_comp.columns:
-                return pd.DataFrame({"Error": ["설정된 기준 열(Anchor)이 데이터에 존재하지 않습니다."]})
 
-            # [복원] 원본의 띄어쓰기 무시 키 생성
-            df_base['merge_key'] = df_base[real_anchor_b].astype(str).str.replace(" ", "")
-            df_comp['merge_key'] = df_comp[real_anchor_c].astype(str).str.replace(" ", "")
+            for ra in real_anchors_b:
+                if ra not in df_base.columns: return pd.DataFrame({"Error": [f"기준 열 '{ra}'이 데이터에 없습니다."]})
+            for ra in real_anchors_c:
+                if ra not in df_comp.columns: return pd.DataFrame({"Error": [f"비교 열 '{ra}'이 데이터에 없습니다."]})
+
+            # 다중 앵커를 하이픈(-)으로 연결해 단일 merge_key 생성 (예: "5.1-M6")
+            df_base['merge_key'] = df_base[real_anchors_b].apply(lambda row: '-'.join(row.values.astype(str)), axis=1).str.replace(" ", "")
+            df_comp['merge_key'] = df_comp[real_anchors_c].apply(lambda row: '-'.join(row.values.astype(str)), axis=1).str.replace(" ", "")
 
-            # [복원] 원본 매핑 로직 (정방향, 역방향, Explode)
+            # 브릿지 매핑 복원
             conn_map = sqlite3.connect(os.path.join(UPLOAD_DIR, "mapping.db"))
             query_fw = "SELECT Base_section, Comp_section FROM Mapping_table WHERE TRIM(Base_std)=? AND TRIM(Base_ver)=? AND TRIM(Comp_std)=? AND TRIM(Comp_ver)=?"
             df_fw = pd.read_sql(query_fw, conn_map, params=[base_std.strip(), base_ver.strip(), comp_std.strip(), comp_ver.strip()])
@@ -365,15 +375,11 @@ def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, com
             if not df_mapping.empty:
                 df_mapping['Base_section'] = df_mapping['Base_section'].astype(str).str.replace('\n', ',').str.replace('\r', '')
                 df_mapping['Comp_section'] = df_mapping['Comp_section'].astype(str).str.replace('\n', ',').str.replace('\r', '')
-                
                 df_mapping['Base_section'] = df_mapping['Base_section'].str.split(',')
                 df_mapping['Comp_section'] = df_mapping['Comp_section'].str.split(',')
-
                 df_mapping = df_mapping.explode('Base_section').explode('Comp_section')
-
                 df_mapping['Base_section'] = df_mapping['Base_section'].astype(str).str.strip().str.replace(" ", "")
                 df_mapping['Comp_section'] = df_mapping['Comp_section'].astype(str).str.strip().str.replace(" ", "")
-                
                 df_mapping = df_mapping[(df_mapping['Base_section'] != '') & (df_mapping['Base_section'] != 'nan')]
                 df_mapping = df_mapping[(df_mapping['Comp_section'] != '') & (df_mapping['Comp_section'] != 'nan')]
                 df_mapping = df_mapping.drop_duplicates()
@@ -390,7 +396,6 @@ def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, com
             df_implicit = pd.DataFrame({'Base_section': list(implicit_keys), 'Comp_section': list(implicit_keys)})
             bridge = pd.concat([df_mapping, df_implicit], ignore_index=True)
 
-            # 브릿지 병합 전 이름 변경 (버전별 접미사 추가)
             rename_b = {c: f"{c}_{base_ver}" for c in df_base.columns if c != 'merge_key'}
             df_base = df_base.rename(columns=rename_b)
             
@@ -400,7 +405,6 @@ def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, com
             df_base['base_idx'] = range(len(df_base))
             df_comp['comp_idx'] = range(len(df_comp))
 
-            # 브릿지를 이용해 조인
             merged = pd.merge(bridge, df_base, left_on='Base_section', right_on='merge_key', how='outer')
             merged = pd.merge(merged, df_comp, left_on='Comp_section', right_on='merge_key', how='outer')
 
@@ -412,22 +416,17 @@ def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, com
             result_rows = []
             b_cols_renamed = list(rename_b.values())
             c_cols_renamed = list(rename_c.values())
-            
-            b_anchor_renamed = f"{real_anchor_b}_{base_ver}"
-            c_anchor_renamed = f"{real_anchor_c}_{comp_ver}"
 
             for _, row in merged.iterrows():
                 row_dict = {}
-                has_b = not pd.isna(row.get(b_anchor_renamed))
-                has_c = not pd.isna(row.get(c_anchor_renamed))
+                has_b = not pd.isna(row.get('base_idx')) and row.get('base_idx') != float('inf')
+                has_c = not pd.isna(row.get('comp_idx')) and row.get('comp_idx') != float('inf')
 
                 for c in b_cols_renamed:
                     row_dict[c] = str(row.get(c)) if has_b and not pd.isna(row.get(c)) else ""
-                    
                 for c in c_cols_renamed:
                     row_dict[c] = str(row.get(c)) if has_c and not pd.isna(row.get(c)) else ""
 
-                # Main 테이블인 경우에만 Description에 한해 Diff 적용
                 if table_type == "Main" and has_b and has_c:
                     desc_b_col = next((c for c in b_cols_renamed if 'description' in c.lower()), None)
                     desc_c_col = next((c for c in c_cols_renamed if 'description' in c.lower()), None)
@@ -435,19 +434,15 @@ def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, com
                     if desc_b_col and desc_c_col:
                         b_val, c_val = row_dict[desc_b_col], row_dict[desc_c_col]
                         if b_val and c_val and "<img" not in b_val and "<img" not in c_val and b_val != c_val:
-                            b_diff, c_diff = generate_html_diff(b_val, c_val)
-                            row_dict[desc_b_col] = b_diff
-                            row_dict[desc_c_col] = c_diff
+                            row_dict[desc_b_col], row_dict[desc_c_col] = generate_html_diff(b_val, c_val)
 
                 result_rows.append(row_dict)
 
             final_df = pd.DataFrame(result_rows)
 
-            # [복원] 앵커(Section) 중복 시 공백 처리
-            if b_anchor_renamed in final_df.columns:
-                duplicate_mask = final_df.duplicated(subset=[b_anchor_renamed], keep='first') & (final_df[b_anchor_renamed] != "")
-                for c in b_cols_renamed:
-                    final_df.loc[duplicate_mask, c] = ""
+            # 좌/우 각각 시각적 병합(Cascading Blanking) 적용
+            final_df = apply_visual_merge(final_df, b_cols_renamed)
+            final_df = apply_visual_merge(final_df, c_cols_renamed)
 
             return final_df