DEVOCEAN

# 실행 성공한 내부 SQL 쿼리문에서 구문 수를 count 
keyword_counts
{'WITH': 1, 'AS': 9, 'SELECT': 7, 'CONCAT': 2, 'FROM': 7, 'WHERE': 5, 'LIKE': 2, 'TO_DATE': 4, 'INTERVAL': 1, 'JOIN': 1, 'ON': 1, 'IN': 2})
{'SELECT': 1, 'FROM': 1, 'WHERE': 1, 'LIKE': 1, 'LIMIT': 1})
{'SELECT': 1, 'CASE': 1, 'WHEN': 4, 'THEN': 4, 'AS': 9, 'FROM': 1, 'WHERE': 1, 'IN': 1, 'LIMIT': 1})
{'SELECT': 18, 'CAST': 8, 'AS': 28, 'IF': 11, 'CASE': 1, 'WHEN': 4, 'THEN': 4, 'ROUND': 6, 'FROM': 18, 'ROW_NUMBER': 1, 'OVER': 1, 'CONCAT': 3, 'JOIN': 11, 'WHERE': 13, 'ON': 11, 'IN': 1, 'SUBSTR': 3, 'SUM': 2})
{'SELECT': 1, 'FROM': 1, 'LIMIT': 1})
{'SELECT': 3, 'CONCAT': 1, 'AS': 13, 'FROM': 3, 'WHERE': 2, 'CAST': 2, 'LIKE': 1, 'JOIN': 1, 'ON': 1, 'LIMIT': 1})
{'SELECT': 1, 'FROM': 1, 'WHERE': 1, 'LIMIT': 1})
{'SELECT': 6, 'AS': 1, 'SUM': 24, 'ROUND': 2, 'FROM': 6, 'SUBSTR': 8, 'WHERE': 6, 'JOIN': 2, 'COUNT': 2, 'ON': 2, 'UNION': 1, 'ALL': 1, 'LIMIT': 1})
{'SELECT': 1, 'AS': 25, 'SUM': 15, 'CAST': 15, 'ROUND': 6, 'FROM': 1, 'WHERE': 1, 'IN': 1, 'LIMIT': 1})
{'SELECT': 18, 'CAST': 8, 'AS': 28, 'IF': 11, 'CASE': 1, 'WHEN': 4, 'THEN': 4, 'ROUND': 6, 'FROM': 18, 'ROW_NUMBER': 1, 'OVER': 1, 'CONCAT': 3, 'JOIN': 11, 'WHERE': 13, 'ON': 11, 'IN': 1, 'SUBSTR': 3, 'SUM': 2})
{'SELECT': 1, 'FROM': 1, 'WHERE': 1})
{'SELECT': 1, 'AVG': 3, 'AS': 1, 'FROM': 1, 'WHERE': 1, 'HAVING': 1, 'LIMIT': 1})
{'SELECT': 1, 'CAST': 1, 'AS': 1, 'FROM': 1, 'LIMIT': 1})
{'SELECT': 1, 'FROM': 1, 'WHERE': 1, 'LIMIT': 1})
{'SELECT': 1, 'FROM': 1, 'LIMIT': 1})
{'SELECT': 1, 'FROM': 1, 'WHERE': 1})
{'SELECT': 1, 'FROM': 1, 'WHERE': 1})
{'SELECT': 6, 'AVG': 21, 'FROM': 6, 'WHERE': 4, 'JOIN': 2, 'AS': 8, 'LIKE': 6, 'ON': 2, 'LIMIT': 1})
{'SELECT': 1, 'FROM': 1, 'WHERE': 1, 'IN': 1})

###instruction
너는 자연어를 입력받아 sql문을 생성하는 챗봇이야. Step by Step으로 생각하고 행동해.
1.입력으로 sql키워드 리스트를 받아.
2.자연어를 sql문으로 만들 때 사용하는 각 
키워드의 난이도를 0~1사이 실수(소수점 둘째 자리까지 넓은 분포로 표현) 점수를 매겨. 
3.각 키워드 오른쪽에 주석의 형태로 난이도 책정의 이유를 논리적으로 설명해.

###input
sql_commands = [
"SELECT",
"FROM",
"WHERE",
"JOIN",
"WITH",
"AS",
"ORDER BY",
"LIMIT",
"CASE",
"WHEN",
"THEN",
"LEFT JOIN",
"ON",
"INTERVAL",
"TO_DATE",
"ROUND",
"IF",
"SUM",
"ROW_NUMBER",
"PARTITION BY",
"OVER",
"CONCAT",
"CAST",
"GROUP BY",
"SUBSTR",
"DISTINCT",
"RIGHT JOIN",
"FULL OUTER JOIN",
"CROSS JOIN",
"UNION",
"UNION ALL",
"MIN",
"MAX",
"AVG",
"COUNT",
"HAVING",
"EXISTS",
"NOT EXISTS",
"ANY",
"ALL",
"IN",
"NOT IN",
"BETWEEN",
"LIKE",
"RANK",
"DENSE_RANK",
# AWS Athena specific commands
"UNLOAD",
"USING",
"EXTERNAL",
"LOCATION",
"STORED AS",
"SERDE",
"WITH SERDEPROPERTIES",
"WITH PARAMETERS",
"TBLPROPERTIES",
"MSCK REPAIR TABLE",
"ADD PARTITION",
"DROP PARTITION",
"SHOW PARTITIONS",
"SHOW CREATE TABLE",
"SHOW TBLPROPERTIES",
"DESCRIBE",
"SHOW DATABASES",
"SHOW TABLES",
"SHOW COLUMNS",
"SHOW FUNCTIONS",
"ANALYZE",
"VACUUM",
"COPY INTO",
"ALTER TABLE",
"ALTER DATABASE",
"ALTER VIEW",
"REFRESH TABLE",
"REFRESH DATABASE",
"MERGE INTO"
]

###output_format
sql_command_weights = {
"SELECT": 0.12, # ~~~
"FROM": ?, # ~~~
"WHERE": ?, # ~~~
"JOIN": 0.65, # ~~~

# CoT prompt를 통해, gpt4o로 구문 별 난이도 가중치를 초기화하고 논리적 근거를 주석 형태로 출
sql_command_weights = {
    "SELECT": 0.11, # 기본 SQL 구문이며, 데이터베이스에서 데이터를 선택하는 데 사용됨. 기본적인 문법으로 비교적 쉽다.
    "FROM": 0.12, # 데이터를 추출할 테이블을 지정하는 데 사용. 기본적인 SQL 문법의 일부로 쉽게 이해할 수 있다.
    "WHERE": 0.09, # 조건을 지정하여 데이터를 필터링하는 데 사용. 조건식 작성의 난이도가 조금 있지만 비교적 이해하기 쉬운 편.
    "JOIN": 0.52, # 0.5 두 개 이상의 테이블을 결합하는 데 사용. 결합 조건과 다양한 형태의 조인을 이해하는 데 약간의 난이도가 있다.
    "WITH": 0.58, # 서브쿼리를 정의하는 데 사용되는 공통 테이블 표현식(CTE) 구문. 서브쿼리를 다루는 점에서 약간의 복잡성이 있다.
    "AS": 0.1, # 0.1 별칭을 지정하는 데 사용. 단순한 구문으로 이해하기 쉽다.
    "ORDER BY": 0.11, # 결과 집합을 정렬하는 데 사용. 기본적인 정렬 개념으로 이해하기 쉬움.
    "LIMIT": 0.09, # 반환할 행의 수를 제한하는 데 사용. 사용법이 간단하여 이해하기 쉽다.
    "CASE": 0.51, # 조건에 따라 다른 값을 반환하는 데 사용. 다양한 조건을 처리할 수 있어 약간의 복잡성이 있다.
    "WHEN": 0.49, # CASE 구문의 일부로 조건을 지정. CASE 구문과 함께 이해해야 하므로 난이도가 비슷하다.
    "THEN": 0.48, # CASE 구문의 일부로 조건이 참일 때 반환할 값을 지정. WHEN과 유사한 난이도.
    "LEFT JOIN": 0.61, # 0.6 기본 JOIN에 비해 약간 더 복잡한 개념으로, 왼쪽 테이블의 모든 행과 오른쪽 테이블의 일치하는 행을 결합.
    "ON": 0.39, # JOIN 조건을 지정하는 데 사용. JOIN 구문과 함께 사용되므로 약간의 복잡성이 있다.
    "INTERVAL": 0.41, # 날짜나 시간을 조작하는 데 사용. 시간 연산을 이해해야 하므로 약간의 난이도가 있다.
    "TO_DATE": 0.31, # 문자열을 날짜로 변환하는 데 사용. 변환 함수로 이해하기 쉬움.
    "ROUND": 0.19, # 숫자를 반올림하는 데 사용. 수학적 함수로 이해하기 쉬움.
    "IF": 0.38, # 조건에 따라 다른 값을 반환하는 함수. 논리적 조건 처리가 필요하여 약간의 난이도가 있다.
    "SUM": 0.21, # 집계 함수로, 숫자의 합계를 구하는 데 사용. 단순한 집계 함수로 이해하기 쉬움.
    "ROW_NUMBER": 0.47, # 결과 집합에 순위 번호를 할당하는 윈도우 함수. 윈도우 함수 개념을 이해해야 하므로 난이도가 있다.
    "PARTITION BY": 0.53, # 윈도우 함수의 일부로, 결과 집합을 파티션으로 나누는 데 사용. 윈도우 함수와 함께 이해해야 하므로 난이도가 있다.
    "OVER": 0.48, # 윈도우 함수의 일부로, 윈도우를 정의하는 데 사용. 윈도우 함수와 함께 이해해야 하므로 난이도가 있다.
    "CONCAT": 0.23, # 문자열을 연결하는 함수. 사용법이 단순하여 이해하기 쉽다.
    "CAST": 0.29, # 데이터 타입을 변환하는 함수. 다양한 데이터 타입을 이해해야 하므로 약간의 난이도가 있다.
    "GROUP BY": 0.42, # 데이터를 그룹화하여 집계 결과를 생성하는 데 사용. 집계와 그룹화를 이해해야 하므로 약간의 난이도가 있다.
    "SUBSTR": 0.32, # 문자열의 일부를 추출하는 함수. 문자열 처리에 대한 기본 이해가 필요.
    "DISTINCT": 0.27, # 중복된 값을 제거하는 데 사용. 단순한 개념이지만 대용량 데이터에서는 성능 문제를 고려해야 함.
    "RIGHT JOIN": 0.59, # 0.6 오른쪽 테이블의 모든 행과 왼쪽 테이블의 일치하는 행을 결합. JOIN의 복잡성을 포함.
    "FULL OUTER JOIN": 0.71, # 두 테이블의 모든 행을 결합하며 일치하지 않는 행도 포함. 가장 복잡한 JOIN 형태 중 하나.
    "CROSS JOIN": 0.57, # 두 테이블의 모든 행을 결합하여 데카르트 곱을 생성. 사용 시 주의가 필요하여 난이도가 있다.
    "UNION": 0.49, # 두 결과 집합을 결합하여 중복을 제거. 중복을 처리하는 점에서 약간의 복잡성이 있다.
    "UNION ALL": 0.52, # 두 결과 집합을 결합하되 중복을 제거하지 않음. UNION과 비슷한 난이도.
    "MIN": 0.22, # 집계 함수로, 최소값을 구하는 데 사용. 단순한 집계 함수로 이해하기 쉽다.
    "MAX": 0.21, # 집계 함수로, 최대값을 구하는 데 사용. 단순한 집계 함수로 이해하기 쉽다.
    "AVG": 0.18, # 집계 함수로, 평균값을 구하는 데 사용. 단순한 집계 함수로 이해하기 쉽다.
    "COUNT": 0.2, # 집계 함수로, 행의 수를 구하는 데 사용. 단순한 집계 함수로 이해하기 쉽다.
    "HAVING": 0.43, # GROUP BY 결과에 조건을 적용하는 데 사용. WHERE과 유사하지만 그룹화된 데이터에 적용되므로 약간의 난이도가 있다.
    "EXISTS": 0.48, # 서브쿼리의 결과 존재 여부를 확인하는 조건문. 서브쿼리를 이해해야 하므로 난이도가 있다.
    "NOT EXISTS": 0.51, # 서브쿼리의 결과 존재 여부가 거짓인지 확인하는 조건문. EXISTS와 비슷한 난이도.
    "ANY": 0.39, # 서브쿼리의 결과 중 하나라도 조건을 만족하는지 확인. 서브쿼리를 이해해야 하므로 약간의 난이도가 있다.
    "ALL": 0.42, # 서브쿼리의 결과가 모두 조건을 만족하는지 확인. 서브쿼리를 이해해야 하므로 약간의 난이도가 있다.
    "IN": 0.31, # 지정된 목록이나 서브쿼리의 결과에 값이 포함되는지 확인. 간단한 조건문이지만 서브쿼리 사용 시 약간의 난이도가 있다.
    "NOT IN": 0.28, # 지정된 목록이나 서브쿼리의 결과에 값이 포함되지 않는지 확인. IN과 비슷한 난이도.
    "BETWEEN": 0.29, # 값이 두 값 사이에 있는지 확인. 간단한 조건문으로 이해하기 쉽다.
    "LIKE": 0.32, # 문자열 패턴 매칭을 위한 조건문. 기본적인 패턴 매칭으로 이해하기 쉬움.
    "RANK": 0.49, # 결과 집합에 순위를 매기는 윈도우 함수. 윈도우 함수의 개념을 이해해야 하므로 약간의 난이도가 있다.
    "DENSE_RANK": 0.52, # 결과 집합에 중복 없이 순위를 매기는 윈도우 함수. RANK와 비슷한 난이도.
    "UNLOAD": 0.51, # AWS Athena에서 결과를 파일로 저장하는 명령어. AWS 서비스와의 연동을 이해해야 하므로 약간의 난이도가 있다.
    "USING": 0.41, # 테이블 결합 시 사용할 칼럼을 지정하는 조건. JOIN 구문과 함께 사용되어 약간의 난이도가 있다.
    "EXTERNAL": 0.54, # 외부 테이블을 정의하는 데 사용. 외부 데이터 소스를 이해해야 하므로 약간의 난이도가 있다.
    "LOCATION": 0.42, # 외부 테이블의 위치를 지정. 외부 데이터 소스를 이해해야 하므로 약간의 난이도가 있다.
    "STORED AS": 0.38, # 데이터 저장 형식을 지정. 다양한 저장 형식을 이해해야 하므로 약간의 난이도가 있다.
    "SERDE": 0.48, # 직렬화 및 역직렬화 라이브러리를 지정. 기술적인 이해가 필요하여 난이도가 있다.
    "WITH SERDEPROPERTIES": 0.52, # SERDE의 속성을 지정. 세부 속성을 이해해야 하므로 약간의 난이도가 있다.
    "WITH PARAMETERS": 0.47, # 테이블 생성 시 파라미터를 지정. 다양한 파라미터를 이해해야 하므로 약간의 난이도가 있다.
    "TBLPROPERTIES": 0.36, # 테이블 속성을 지정. 다양한 속성을 이해해야 하므로 약간의 난이도가 있다.
    "MSCK REPAIR TABLE": 0.64, # AWS Athena에서 테이블 파티션을 복구. 특정 서비스와의 연동을 이해해야 하므로 난이도가 있다.
    "ADD PARTITION": 0.37, # 테이블에 파티션을 추가. 파티션 개념을 이해해야 하므로 약간의 난이도가 있다.
    "DROP PARTITION": 0.43, # 테이블에서 파티션을 삭제. 파티션 개념을 이해해야 하므로 약간의 난이도가 있다.
    "SHOW PARTITIONS": 0.29, # 테이블의 파티션을 표시. 단순한 명령어로 이해하기 쉽다.
    "SHOW CREATE TABLE": 0.28, # 테이블 생성 스크립트를 표시. 단순한 명령어로 이해하기 쉽다.
    "SHOW TBLPROPERTIES": 0.31, # 테이블 속성을 표시. 단순한 명령어로 이해하기 쉽다.
    "DESCRIBE": 0.3, # 테이블 구조를 설명. 단순한 명령어로 이해하기 쉽다.
    "SHOW DATABASES": 0.32, # 데이터베이스 목록을 표시. 단순한 명령어로 이해하기 쉽다.
    "SHOW TABLES": 0.33, # 테이블 목록을 표시. 단순한 명령어로 이해하기 쉽다.
    "SHOW COLUMNS": 0.29, # 테이블의 칼럼을 표시. 단순한 명령어로 이해하기 쉽다.
    "SHOW FUNCTIONS": 0.28, # 사용 가능한 함수를 표시. 단순한 명령어로 이해하기 쉽다.
    "ANALYZE": 0.41, # 테이블 통계를 수집 및 분석. 데이터 분석 개념을 이해해야 하므로 약간의 난이도가 있다.
    "VACUUM": 0.37, # 테이블을 정리하여 저장 공간을 확보. 데이터 정리 개념을 이해해야 하므로 약간의 난이도가 있다.
    "COPY INTO": 0.47, # 데이터를 테이블에 복사. 데이터 이동 개념을 이해해야 하므로 약간의 난이도가 있다.
    "ALTER TABLE": 0.39, # 테이블 구조를 변경. 다양한 변경 옵션을 이해해야 하므로 약간의 난이도가 있다.
    "ALTER DATABASE": 0.42, # 데이터베이스 구조를 변경. 다양한 변경 옵션을 이해해야 하므로 약간의 난이도가 있다.
    "ALTER VIEW": 0.37, # 뷰 구조를 변경. 다양한 변경 옵션을 이해해야 하므로 약간의 난이도가 있다.
    "REFRESH TABLE": 0.28, # 테이블을 새로 고침. 단순한 명령어로 이해하기 쉽다.
    "REFRESH DATABASE": 0.29, # 데이터베이스를 새로 고침. 단순한 명령어로 이해하기 쉽다.
    "MERGE INTO": 0.63, # 테이블을 병합하여 업데이트. 데이터 병합 개념을 이해해야 하므로 난이도가 있다.
}

def calculate_query_complextity_score(keyword_counts, weights):
    complextity_score = 0
    for keyword, count in keyword_counts.items():
        complextity_score += weights.get(keyword, 0) * count
    return complextity_score

score : 0.32, query : SELECT * FROM A.A LIMIT A
score : 0.32, query : select B from A.A where A = 'A'
score : 0.32, query : SELECT * FROM A.A WHERE A = 'A'
score : 0.32, query : SELECT A, A FROM A.A LIMIT A
score : 0.32, query : select * from A.A order by A LIMIT A

score : 0.81, query : SELECT A, A AS "A", A AS "A", A AS "A A", A AS "A", A FROM A.A WHERE A = 'A' AND A = 'A' LIMIT A
score : 0.82, query : select A as "A" from A.A where A(A, 'A') = A and A = 'A' and A != A order by A LIMIT A
score : 0.82, query : select A ,A as "A" from A.A where A(A, 'A') = A and A = 'A' and A != A order by A LIMIT A
score : 0.83, query : SELECT * FROM A.A where A like 'A' and A(NULLIF(A,'A') as A)=A LIMIT A
score : 0.83, query : select A, A(A) A, A(A) A FROM A.A where A='A' and A='A' group by A LIMIT A

score : 1.5, query : SELECT DISTINCT B FROM A.A A A A JOIN A.A A ON A.A ='A' and A.A = A.A WHERE A = 'A'
score : 1.5, query : SELECT DISTINCT B FROM A.A A A A JOIN A.A A ON A.A ='A' and A.A = A.A WHERE A = 'A' AND A = 'A'
score : 1.55, query : SELECT * FROM ( SELECT * from A.A where A(A as INTEGER) >= A and A = 'A' ) AS A, ( SELECT * FROM A.A ) AS A where A.A = A.A LIMIT A
score : 1.69, query : select B(A, 'A', A) AS "A", A from A.A where A like 'A' and A >= A and A(A, 'A') = A - INTERVAL 'A' A and A = 'A'
score : 1.71, query : select A, A(A(A as A) ) A, A(distinct A) A FROM A.A where A='A' and A='A' and (A like 'A') and A='A' group by A

score : 4.01, query : select A, A(A,A,'A') A, A(A,A(A,A,'A')) B(A) A, A(A) A, A(A)/A(A)/A A, A(A)/A(A) A , A(A) A, A(A) A ,A(A) A, A(A) A, A(A) A ,A(A)/A(A) A ,A(A)/A(A) A from A.A where A>='A' and A<='A' and A in ( 'A', 'A', 'A', 'A', 'A', 'A' ) group by B

score : 4.05, query : SELECT A AS "A", A AS "A", A AS "A", A AS "A", A AS "A/A", A AS "A", A AS "A", A AS "A", A AS "A", A AS "A(A)", A AS "A(A)", A AS "A(A)", A AS "A(A)", A AS "A(A)", A AS "A(A)", A AS "A(A)", A AS "A(A)", A AS "A", A AS "A", A AS "A", A AS "A", A AS "A", A AS "A", A AS "A", A AS "A", A AS "A", A AS "A", A AS "A", A AS "A(A)", A AS "A", A AS "A", A AS "A(A)" FROM A.A WHERE A = (SELECT A(A) FROM A.A) and A = 'A' LIMIT A

score : 4.07, query : select A.A, A.A, A.A, A.A, A.A, A.A, A.A as "A", A.A as "A", A(A.A as A)+A(A.A as A)/A as "A", A.A as "A", A.A as "A", A.A as "A", A.A as "A", A.A as "A", A.A as "A" from ( SELECT B FROM A.A where A = A(A(A('A', -A, A) AS A), 'A', 'A') and A like 'A' )A A join ( select A , A , A , A , A , A , A, A , A From A.A where A = A(A(A('A', -A, A) AS A), 'A', 'A') )A on A.A = A.A LIMIT A

score : 4.11, query : select A, A(A,A,'A') A, A(A,A(A,A,'A')) B(A) A, A(A) A, A(A)/A(A)/A A, A(A)/A(A) A , A(A) A, A(A) A ,A(A) A, A(A) A, A(A) A ,A(A)/A(A) A ,A(A)/A(A) A from A.A where A>='A' and A<='A' and A like 'A' group by B LIMIT A
score : 4.21, query : select A.A, A.A, A.A, A.A, A.A, A.A, A.A, A.A, A.A, A.A, A.A, A.A, A.A, A.A, A.A, A.A, A(A.A,'A',A.A,'A',A.A,'A',A.A) as A, A.A, A(A.A as A)+A(A.A as A)/A +(A(A.A as A)+A(A.A as A)/A)/A as "A", A(A.A as A)+A(A.A as A)/A +(A(A.A as A)+A(A.A as A)/A)/A as "A" from ( SELECT B FROM A.A where A = A(A(A('A', -A, A) AS A), 'A', 'A') and A like 'A' )A A join ( select A , A , A , A , A , A , A, A , A From A.A where A = A(A(A('A', -A, A) AS A), 'A', 'A') )A on A.A = A.A

Query 1: SELECT B(B) as A ,A(A(A),A) as A FROM A.A WHERE A>='A' AND A<='A' AND A>='A' AND A<='A' and A = 'A' group A B having A(A) >= A LIMIT A
Query 2: SELECT B,* FROM A.A WHERE A='A' and A='A' and A='A' and A='A' and A in ('A') LIMIT A
Query 3: SELECT B,* FROM A.A WHERE A='A' and A='A' and A='A' and A='A' and A in ('A') LIMIT A
Query 4: SELECT B FROM A.A WHERE A='A' and A='A' and A='A' and A='A' and A='A' and A='A' LIMIT A
Query 5: select A, A(A(A as A) ) A, A(distinct A) A FROM A.A where A='A' and A='A' and (A like 'A') and A='A' group A A
Query 6: select distinct A from A.A where A= 'A' and A like 'A' and A in (B)
Query 7: SELECT B FROM A.A WHERE A='A' and A='A' and A='A' and A='A' and A='A' and A='A' LIMIT A
Query 8: select A, A(A as A), A , A('A', A, A(A as A)) , A('A', A, A) , A(A(A as A) = B) from A.A where A='A' and A='A' limit A
Query 9: SELECT A, A(A) AS A, A(A) AS A ,A FROM A.A WHERE A = 'A' AND A = 'A' AND A = 'A' GROUP A A, A ORDER A A A LIMIT A

# SQL문 단순화 전략
# 1. 구조적 특성을 잘 표현하는 형태로 바꾸기 위함
# 2. 인하우스 데이터의 value값을 외부 유출시키지 않기 위함
def DELETE_blank(sql_query):
    sql_query = re.sub(r'\s+', ' ', sql_query).strip()
    return sql_query
    
def REPLACE_value_to_A(sql_query):
    # 정규 표현식 패턴 정의
    # 1. 문자열 리터럴
    string_pattern = r"'.*?'"
    # 2. 숫자 리터럴
    number_pattern = r"\b\d+(\.\d+)?\b"
    # 3. 테이블이나 필드명을 제외한 단어 리터럴
    word_pattern = r"\b(?!SELECT|FROM|WHERE|GROUP\s+BY|ORDER\s+BY|HAVING|JOIN|ON|AS|AND|OR|NOT|NULL|IS|LIKE|IN|BETWEEN|EXISTS|ALL|ANY|SOME|UNION|INTERSECT|LIMIT|MINUS|DISTINCT|CASE|WHEN|THEN|ELSE|END)\w+\b"
    # 문자열 리터럴을 "A"로 대체
    sql_query = re.sub(string_pattern, "'A'", sql_query, flags=re.IGNORECASE)
    # 숫자 리터럴을 "A"로 대체
    sql_query = re.sub(number_pattern, "A", sql_query, flags=re.IGNORECASE)
    # 단어 리터럴을 "A"로 대체
    sql_query = re.sub(word_pattern, "A", sql_query, flags=re.IGNORECASE)
    return sql_query
    
def REPLACE_consecutive_A_to_B(sql_query):
    # 연속적인 A를 B로 대체
    sql_query = re.sub(r'\b(A,\s*){2,}A\b', 'B', sql_query)
    sql_query = re.sub(r"\('A',\s*'A'(,\s*'A')*\)", '(B)', sql_query)
    return sql_query