diff --git a/.env.example b/.env.example index 8090667..5f29ce7 100644 --- a/.env.example +++ b/.env.example @@ -39,6 +39,8 @@ LANG2SQL_SECRET_KEY= # snowflake://user:pass@account/db/schema?warehouse=wh # mysql+pymysql://user:pass@host/dbname # duckdb:////absolute/path/to/file.duckdb +# oracle+oracledb://readonly_user:pass@localhost:1521/?service_name=FREEPDB1 +# Oracle driver: uv sync --extra oracle (Thin mode, no Instant Client needed). LANG2SQL_DB_URL= # Optional default schema for the SQLAlchemy explorer. LANG2SQL_DB_SCHEMA= diff --git a/bench/README.md b/bench/README.md index 926c4e8..2f57948 100644 --- a/bench/README.md +++ b/bench/README.md @@ -37,3 +37,7 @@ The two headline pillars demonstrated are **★① safety** (Sections 0 + 3) and `gpt-4.1-mini`. - Federation state in Sections 1–2 lives in an in-memory `SemanticStore`; the SQLite-backed persistent store is wired through the concierge for the bot. + +## Oracle 데모 + +실제 Oracle의 부서별 매출·되묻기·권한 차단 시연: [재현 절차](../docs/oracle_demo.md). diff --git a/bench/oracle/compose.yaml b/bench/oracle/compose.yaml new file mode 100644 index 0000000..7366acb --- /dev/null +++ b/bench/oracle/compose.yaml @@ -0,0 +1,12 @@ +services: + oracle: + image: gvenzl/oracle-free:23.9-slim-faststart + ports: + - "127.0.0.1:${ORACLE_DEMO_PORT:-11521}:1521" + environment: + ORACLE_PASSWORD: ${ORACLE_PASSWORD:?Set a disposable demo password} + healthcheck: + test: ["CMD", "healthcheck.sh"] + interval: 10s + timeout: 5s + retries: 60 diff --git a/bench/oracle/results/before-access-fix.json b/bench/oracle/results/before-access-fix.json new file mode 100644 index 0000000..4db0283 --- /dev/null +++ b/bench/oracle/results/before-access-fix.json @@ -0,0 +1,351 @@ +{ + "mode": "live_llm", + "model": "gpt-4.1-mini", + "timestamp": "2026-11-11T14:26:25.829542+00:00", + "cases": [ + { + "repeat": 1, + "case": "revenue", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "2026년 10월 매출은 원 단위로 2,000,000원입니다.", + "executions": [ + { + "sql": "SELECT SUM(gross_amount) AS 매출 FROM l2s_demo_owner.orders WHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "매출": 2000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 1, + "case": "revenue", + "team": "finance", + "db_user": "L2S_DEMO_FINANCE", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "순매출 SUM(gross_amount - discount_amount - return_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "2026년 10월 매출은 1,700,000원입니다.", + "executions": [ + { + "sql": "SELECT SUM(gross_amount - discount_amount - return_amount) AS 매출_원단위\nFROM l2s_demo_owner.orders\nWHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "매출_원단위": 1700000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 1, + "case": "clarification", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 충성고객 매출을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "❓ Awaiting user: '충성고객'의 기준이 무엇인가요? 예를 들어, 구매 횟수, 누적 구매액 등 중 어떤 기준을 쓰시겠습니까?", + "executions": [], + "tool_calls": [ + "ask_user" + ] + }, + { + "repeat": 1, + "case": "salary", + "team": "hr", + "db_user": "L2S_DEMO_HR", + "question": "부서별 급여 평균을 알려줘.", + "definition": null, + "passed": true, + "permission_probe": null, + "answer": "부서별 평균 급여는 finance 부서가 4,000,000, sales 부서가 3,000,000입니다.", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS avg_salary\nFROM l2s_demo_owner.salaries\nGROUP BY department\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "department": "finance", + "avg_salary": 4000000 + }, + { + "department": "sales", + "avg_salary": 3000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 1, + "case": "denied", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "부서별 급여 평균을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": "ORA-00942", + "answer": "부서별 급여 데이터가 포함된 테이블이 현재 접근 불가능합니다. 오너의 orders 테이블만 확인 가능하며 급여 관련 테이블은 없네요. 다른 테이블명을 알려주시면 확인해 드리겠습니다.", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS average_salary\nFROM l2s_demo_owner.salaries\nGROUP BY department\nFETCH FIRST 1000 ROWS ONLY", + "error": "ORA-00942" + } + ], + "tool_calls": [ + "run_sql", + "explore_schema", + "explore_schema" + ] + }, + { + "repeat": 2, + "case": "revenue", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "2026년 10월 매출은 2,000,000원입니다.", + "executions": [ + { + "sql": "SELECT SUM(gross_amount) AS total_sales\nFROM l2s_demo_owner.orders\nWHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "total_sales": 2000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 2, + "case": "revenue", + "team": "finance", + "db_user": "L2S_DEMO_FINANCE", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "순매출 SUM(gross_amount - discount_amount - return_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "2026년 10월 매출은 1,700,000원입니다.", + "executions": [ + { + "sql": "SELECT SUM(gross_amount - discount_amount - return_amount) AS 매출\nFROM l2s_demo_owner.orders\nWHERE ordered_at >= DATE '2026-10-01'\nAND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "매출": 1700000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 2, + "case": "clarification", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 충성고객 매출을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "❓ Awaiting user: 충성고객의 기준이 무엇인가요? 예를 들어, 구매 횟수, 누적 구매액 등 어떤 기준을 쓰길 원하시나요?", + "executions": [], + "tool_calls": [ + "ask_user" + ] + }, + { + "repeat": 2, + "case": "salary", + "team": "hr", + "db_user": "L2S_DEMO_HR", + "question": "부서별 급여 평균을 알려줘.", + "definition": null, + "passed": true, + "permission_probe": null, + "answer": "부서별 급여 평균은 finance 부서가 4,000,000, sales 부서가 3,000,000입니다.", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS avg_salary FROM l2s_demo_owner.salaries GROUP BY department\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "department": "finance", + "avg_salary": 4000000 + }, + { + "department": "sales", + "avg_salary": 3000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 2, + "case": "denied", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "부서별 급여 평균을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": false, + "permission_probe": "ORA-00942", + "answer": "급여 관련 테이블을 찾을 수 없습니다. 부서별 급여 평균을 알려면 급여 정보가 담긴 테이블 이름이나 위치를 알려주시겠습니까?", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS average_salary\nFROM l2s_demo_owner.salaries\nGROUP BY department\nORDER BY department\nFETCH FIRST 1000 ROWS ONLY", + "error": "ORA-00942" + } + ], + "tool_calls": [ + "run_sql", + "explore_schema", + "explore_schema" + ] + }, + { + "repeat": 3, + "case": "revenue", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "2026년 10월 매출은 2,000,000원입니다.", + "executions": [ + { + "sql": "SELECT SUM(gross_amount) AS total_sales_202610\nFROM l2s_demo_owner.orders\nWHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "total_sales_202610": 2000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 3, + "case": "revenue", + "team": "finance", + "db_user": "L2S_DEMO_FINANCE", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "순매출 SUM(gross_amount - discount_amount - return_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "2026년 10월 매출은 1,700,000원입니다.", + "executions": [ + { + "sql": "SELECT SUM(gross_amount - discount_amount - return_amount) AS 매출\nFROM l2s_demo_owner.orders\nWHERE EXTRACT(YEAR FROM ordered_at) = 2026\nAND EXTRACT(MONTH FROM ordered_at) = 10\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "매출": 1700000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 3, + "case": "clarification", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 충성고객 매출을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "❓ Awaiting user: '충성고객'의 기준이 무엇인가요? 예를 들어, 구매 횟수, 누적 구매액 등 어떤 기준을 적용할까요?", + "executions": [], + "tool_calls": [ + "ask_user" + ] + }, + { + "repeat": 3, + "case": "salary", + "team": "hr", + "db_user": "L2S_DEMO_HR", + "question": "부서별 급여 평균을 알려줘.", + "definition": null, + "passed": true, + "permission_probe": null, + "answer": "부서별 급여 평균은 다음과 같습니다. \n- finance 부서: 4,000,000\n- sales 부서: 3,000,000", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS avg_salary FROM l2s_demo_owner.salaries GROUP BY department ORDER BY department\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "department": "finance", + "avg_salary": 4000000 + }, + { + "department": "sales", + "avg_salary": 3000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 3, + "case": "denied", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "부서별 급여 평균을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": false, + "permission_probe": "ORA-00942", + "answer": "데이터베이스에 l2s_demo_owner.salaries 테이블이 존재하지 않습니다. 다른 방법이나 테이블 이름을 알려주시면 다시 시도하겠습니다.", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS average_salary\nFROM l2s_demo_owner.salaries\nGROUP BY department\nFETCH FIRST 1000 ROWS ONLY", + "error": "ORA-00942" + } + ], + "tool_calls": [ + "run_sql", + "explore_schema", + "explore_schema" + ] + } + ], + "database": "Oracle Database 23ai Free Release 23.0.0.0.0 - Develop, Learn, and Run for Free", + "passed": false +} diff --git a/bench/oracle/results/live.json b/bench/oracle/results/live.json new file mode 100644 index 0000000..4f030d0 --- /dev/null +++ b/bench/oracle/results/live.json @@ -0,0 +1,345 @@ +{ + "mode": "live_llm", + "model": "gpt-4.1-mini", + "timestamp": "2026-11-11T14:28:57.034595+00:00", + "cases": [ + { + "repeat": 1, + "case": "revenue", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "2026년 10월 매출은 2,000,000원입니다.", + "executions": [ + { + "sql": "SELECT SUM(gross_amount) AS total_sales_202610 FROM l2s_demo_owner.orders WHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "total_sales_202610": 2000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 1, + "case": "revenue", + "team": "finance", + "db_user": "L2S_DEMO_FINANCE", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "순매출 SUM(gross_amount - discount_amount - return_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "2026년 10월 매출은 1,700,000원입니다.", + "executions": [ + { + "sql": "SELECT SUM(gross_amount - discount_amount - return_amount) AS 매출\nFROM l2s_demo_owner.orders\nWHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "매출": 1700000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 1, + "case": "clarification", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 충성고객 매출을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "❓ Awaiting user: 충성고객의 기준이 무엇인가요? 구매 횟수와 누적 구매액 중 어떤 기준을 쓸까요?", + "executions": [], + "tool_calls": [ + "ask_user" + ] + }, + { + "repeat": 1, + "case": "salary", + "team": "hr", + "db_user": "L2S_DEMO_HR", + "question": "부서별 급여 평균을 알려줘.", + "definition": null, + "passed": true, + "permission_probe": null, + "answer": "부서별 급여 평균은 finance 부서가 4,000,000이고 sales 부서가 3,000,000입니다.", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS average_salary FROM l2s_demo_owner.salaries GROUP BY department\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "department": "finance", + "average_salary": 4000000 + }, + { + "department": "sales", + "average_salary": 3000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 1, + "case": "denied", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "부서별 급여 평균을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": "ORA-00942", + "answer": "요청한 데이터에 접근할 수 없습니다. 현재 DB 계정에 조회 권한이 없거나 테이블이 존재하지 않습니다. DB 관리자에게 확인해 주세요.", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS avg_salary\nFROM l2s_demo_owner.salaries\nGROUP BY department\nFETCH FIRST 1000 ROWS ONLY", + "error": "ORA-00942" + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 2, + "case": "revenue", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "2026년 10월 매출은 2,000,000원입니다.", + "executions": [ + { + "sql": "SELECT SUM(gross_amount) AS total_sales FROM l2s_demo_owner.orders WHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "total_sales": 2000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 2, + "case": "revenue", + "team": "finance", + "db_user": "L2S_DEMO_FINANCE", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "순매출 SUM(gross_amount - discount_amount - return_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "2026년 10월 매출은 원 단위로 1,700,000원입니다.", + "executions": [ + { + "sql": "SELECT SUM(gross_amount - discount_amount - return_amount) AS 매출\nFROM l2s_demo_owner.orders\nWHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "매출": 1700000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 2, + "case": "clarification", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 충성고객 매출을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "❓ Awaiting user: 충성고객의 기준이 무엇인가요? 예를 들어, 구매 횟수 또는 누적 구매액 중 어떤 기준을 사용할까요?", + "executions": [], + "tool_calls": [ + "ask_user" + ] + }, + { + "repeat": 2, + "case": "salary", + "team": "hr", + "db_user": "L2S_DEMO_HR", + "question": "부서별 급여 평균을 알려줘.", + "definition": null, + "passed": true, + "permission_probe": null, + "answer": "부서별 급여 평균은 finance 부서가 4,000,000이고 sales 부서가 3,000,000입니다.", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS avg_salary\nFROM l2s_demo_owner.salaries\nGROUP BY department\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "department": "finance", + "avg_salary": 4000000 + }, + { + "department": "sales", + "avg_salary": 3000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 2, + "case": "denied", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "부서별 급여 평균을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": "ORA-00942", + "answer": "요청한 데이터에 접근할 수 없습니다. 현재 DB 계정에 조회 권한이 없거나 테이블이 존재하지 않습니다. DB 관리자에게 확인해 주세요.", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS avg_salary FROM l2s_demo_owner.salaries GROUP BY department ORDER BY department\nFETCH FIRST 1000 ROWS ONLY", + "error": "ORA-00942" + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 3, + "case": "revenue", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "2026년 10월 매출은 2,000,000원입니다.", + "executions": [ + { + "sql": "SELECT SUM(gross_amount) AS total_revenue FROM l2s_demo_owner.orders WHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "total_revenue": 2000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 3, + "case": "revenue", + "team": "finance", + "db_user": "L2S_DEMO_FINANCE", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "순매출 SUM(gross_amount - discount_amount - return_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "2026년 10월 매출은 1,700,000원입니다.", + "executions": [ + { + "sql": "SELECT SUM(gross_amount - discount_amount - return_amount) AS 매출\nFROM l2s_demo_owner.orders\nWHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "매출": 1700000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 3, + "case": "clarification", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 충성고객 매출을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "❓ Awaiting user: 충성고객의 기준이 무엇인가요? 예: 구매 횟수, 누적 구매액, 최근 구매일 등", + "executions": [], + "tool_calls": [ + "ask_user" + ] + }, + { + "repeat": 3, + "case": "salary", + "team": "hr", + "db_user": "L2S_DEMO_HR", + "question": "부서별 급여 평균을 알려줘.", + "definition": null, + "passed": true, + "permission_probe": null, + "answer": "부서별 급여 평균은 다음과 같습니다.\n- finance: 4,000,000\n- sales: 3,000,000", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS average_salary\nFROM l2s_demo_owner.salaries\nGROUP BY department\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "department": "finance", + "average_salary": 4000000 + }, + { + "department": "sales", + "average_salary": 3000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 3, + "case": "denied", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "부서별 급여 평균을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": "ORA-00942", + "answer": "요청한 데이터에 접근할 수 없습니다. 현재 DB 계정에 조회 권한이 없거나 테이블이 존재하지 않습니다. DB 관리자에게 확인해 주세요.", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS avg_salary\nFROM l2s_demo_owner.salaries\nGROUP BY department\nORDER BY department\nFETCH FIRST 1000 ROWS ONLY", + "error": "ORA-00942" + } + ], + "tool_calls": [ + "run_sql" + ] + } + ], + "database": "Oracle Database 23ai Free Release 23.0.0.0.0 - Develop, Learn, and Run for Free", + "passed": true +} diff --git a/bench/oracle/results/scripted.json b/bench/oracle/results/scripted.json new file mode 100644 index 0000000..c6f636e --- /dev/null +++ b/bench/oracle/results/scripted.json @@ -0,0 +1,121 @@ +{ + "mode": "scripted", + "model": null, + "timestamp": "2026-11-11T14:30:25.702886+00:00", + "cases": [ + { + "repeat": 1, + "case": "revenue", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "1 row(s):\nrevenue\n---\n2000000\nSQL: SELECT SUM(gross_amount) AS revenue FROM l2s_demo_owner.orders WHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "executions": [ + { + "sql": "SELECT SUM(gross_amount) AS revenue FROM l2s_demo_owner.orders WHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "revenue": 2000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 1, + "case": "revenue", + "team": "finance", + "db_user": "L2S_DEMO_FINANCE", + "question": "2026년 10월 매출 얼마야? 원 단위로 알려줘.", + "definition": "순매출 SUM(gross_amount - discount_amount - return_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "1 row(s):\nrevenue\n---\n1700000\nSQL: SELECT SUM(gross_amount - discount_amount - return_amount) AS revenue FROM l2s_demo_owner.orders WHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "executions": [ + { + "sql": "SELECT SUM(gross_amount - discount_amount - return_amount) AS revenue FROM l2s_demo_owner.orders WHERE ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "revenue": 1700000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 1, + "case": "clarification", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "2026년 10월 충성고객 매출을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": null, + "answer": "❓ Awaiting user: 충성고객의 기준이 무엇인가요?", + "executions": [], + "tool_calls": [ + "ask_user" + ] + }, + { + "repeat": 1, + "case": "salary", + "team": "hr", + "db_user": "L2S_DEMO_HR", + "question": "부서별 급여 평균을 알려줘.", + "definition": null, + "passed": true, + "permission_probe": null, + "answer": "2 row(s):\ndepartment | avg_salary\n--- | ---\nfinance | 4000000\nsales | 3000000\nSQL: SELECT department, AVG(salary) AS avg_salary FROM l2s_demo_owner.salaries GROUP BY department\nFETCH FIRST 1000 ROWS ONLY", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS avg_salary FROM l2s_demo_owner.salaries GROUP BY department\nFETCH FIRST 1000 ROWS ONLY", + "rows": [ + { + "department": "finance", + "avg_salary": 4000000 + }, + { + "department": "sales", + "avg_salary": 3000000 + } + ] + } + ], + "tool_calls": [ + "run_sql" + ] + }, + { + "repeat": 1, + "case": "denied", + "team": "sales", + "db_user": "L2S_DEMO_SALES", + "question": "부서별 급여 평균을 알려줘.", + "definition": "주문 금액 합계 SUM(gross_amount). 테이블 l2s_demo_owner.orders. 원 단위. 날짜는 ordered_at.", + "passed": true, + "permission_probe": "ORA-00942", + "answer": "요청한 데이터에 접근할 수 없습니다. 현재 DB 계정에 조회 권한이 없거나 테이블이 존재하지 않습니다. DB 관리자에게 확인해 주세요.", + "executions": [ + { + "sql": "SELECT department, AVG(salary) AS avg_salary FROM l2s_demo_owner.salaries GROUP BY department\nFETCH FIRST 1000 ROWS ONLY", + "error": "ORA-00942" + } + ], + "tool_calls": [ + "run_sql" + ] + } + ], + "database": "Oracle Database 23ai Free Release 23.0.0.0.0 - Develop, Learn, and Run for Free", + "passed": true +} diff --git a/bench/oracle_demo.py b/bench/oracle_demo.py new file mode 100644 index 0000000..a330b3b --- /dev/null +++ b/bench/oracle_demo.py @@ -0,0 +1,350 @@ +"""Oracle demo: disposable fixtures and the real Lang2SQL harness. + +`seed` creates new demo users (never drops/replaces existing objects). +`verify` uses only three read-only accounts; --live requires an API key. +The scripted mode proves wiring, not LLM accuracy. Both modes use a real Oracle DB. +""" + +from __future__ import annotations + +import argparse +import asyncio +import json +import logging +import os +import re +from datetime import datetime, timezone +from pathlib import Path + +from sqlalchemy import create_engine, text +from sqlalchemy.engine import make_url + +from lang2sql.adapters.db.sqlalchemy_explorer import SqlAlchemyExplorer +from lang2sql.adapters.llm.openai_ import OpenAILLM +from lang2sql.adapters.storage.sqlite_store import SqliteStore +from lang2sql.core.identity import Identity +from lang2sql.core.types import Completion, ToolCall +from lang2sql.harness.loop import agent_loop +from lang2sql.tenancy.concierge import ContextConcierge +from lang2sql.tools.semantic_federation import SemanticFederationTool + +logger = logging.getLogger(__name__) +OWNER = "l2s_demo_owner" +TEAMS = ("sales", "finance", "hr") +REVENUE_QUESTION = "2026년 10월 매출 얼마야? 원 단위로 알려줘." +UNKNOWN_QUESTION = "2026년 10월 충성고객 매출을 알려줘." +SALARY_QUESTION = "부서별 급여 평균을 알려줘." +PERIOD = "ordered_at >= DATE '2026-10-01' AND ordered_at < DATE '2026-11-01'" +SALARY_SQL = f"SELECT department, AVG(salary) AS avg_salary FROM {OWNER}.salaries GROUP BY department" +DEFINITIONS = { + "sales": f"주문 금액 합계 SUM(gross_amount). 테이블 {OWNER}.orders. 원 단위. 날짜는 ordered_at.", + "finance": f"순매출 SUM(gross_amount - discount_amount - return_amount). 테이블 {OWNER}.orders. 원 단위. 날짜는 ordered_at.", +} + + +def seed(url: str) -> None: + """Create a disposable owner and read-only personas, refusing existing users.""" + engine = create_engine(url) + password = make_url(url).password + if not password: + raise ValueError("Demo admin URL must include a password") + quoted_password = engine.dialect.identifier_preparer.quote_identifier(password) + users = [OWNER, *(f"l2s_demo_{team}" for team in TEAMS)] + try: + with engine.connect() as conn: + for user in users: + exists = conn.execute( + text("SELECT COUNT(*) FROM all_users WHERE username = :name"), + {"name": user.upper()}, + ).scalar_one() + if exists: + raise ValueError( + f"Demo user {user} already exists; use a fresh disposable container" + ) + for user in users: + conn.execute( + text(f"CREATE USER {user} IDENTIFIED BY {quoted_password}") + ) + conn.execute(text(f"GRANT CREATE SESSION TO {user}")) + conn.execute(text(f"ALTER USER {OWNER} QUOTA 10M ON USERS")) + conn.execute( + text( + f"CREATE TABLE {OWNER}.orders (id NUMBER PRIMARY KEY, ordered_at DATE NOT NULL, gross_amount NUMBER NOT NULL, discount_amount NUMBER NOT NULL, return_amount NUMBER NOT NULL)" + ) + ) + conn.execute( + text( + f"CREATE TABLE {OWNER}.salaries (department VARCHAR2(30), salary NUMBER)" + ) + ) + # Out-of-period rows catch a missing date filter. + for row in [ + (1, "2026-10-05", 1000000, 50000, 0), + (2, "2026-10-10", 600000, 50000, 200000), + (3, "2026-10-20", 400000, 0, 0), + (4, "2026-09-30", 9000000, 0, 0), + (5, "2026-11-01", 8000000, 0, 0), + ]: + conn.execute( + text( + f"INSERT INTO {OWNER}.orders VALUES (:id, TO_DATE(:day, 'YYYY-MM-DD'), :gross, :discount, :returned)" + ), + dict(zip(("id", "day", "gross", "discount", "returned"), row)), + ) + conn.execute( + text(f"INSERT INTO {OWNER}.salaries VALUES ('sales', 3000000)") + ) + conn.execute( + text(f"INSERT INTO {OWNER}.salaries VALUES ('finance', 4000000)") + ) + conn.commit() + for team in TEAMS: + conn.execute(text(f"GRANT SELECT ON {OWNER}.orders TO l2s_demo_{team}")) + conn.execute(text(f"GRANT SELECT ON {OWNER}.salaries TO l2s_demo_hr")) + logger.info("oracle seed complete users=%d", len(users)) + finally: + engine.dispose() + + +class RecordingExplorer(SqlAlchemyExplorer): + """Observe executed SQL/results at the existing explorer seam.""" + + def __init__(self, url: str): + super().__init__(url, schema=OWNER) + self.executions: list[dict] = [] + + async def execute(self, sql: str, limit: int = 1000) -> list[dict]: + entry = {"sql": sql} + self.executions.append(entry) + try: + rows = await super().execute(sql, limit) + except Exception as exc: + code = re.search(r"ORA-\d+", str(exc)) + entry["error"] = code.group() if code else type(exc).__name__ + raise + entry["rows"] = rows + return rows + + +class ScriptedLLM: + """Explicit test double: no model inference or hard-coded success grading.""" + + def __init__(self, call: ToolCall): + self.call = call + self.sent = False + + async def complete(self, messages, tools=()): + if not self.sent: + self.sent = True + return Completion(tool_calls=[self.call]) + return Completion(content=messages[-1].content) + + +async def verify( + url: str, live: bool, api_key: str | None, model: str, repeats: int +) -> dict: + if live and not api_key: + raise ValueError("--live requires OPENAI_API_KEY; no FakeLLM fallback") + base = make_url(url) + report = { + "mode": "live_llm" if live else "scripted", + "model": model if live else None, + "timestamp": datetime.now(timezone.utc).isoformat(), + "cases": [], + } + store = SqliteStore() + try: + for repeat in range(repeats): + for team, case, question in [ + ("sales", "revenue", REVENUE_QUESTION), + ("finance", "revenue", REVENUE_QUESTION), + ("sales", "clarification", UNKNOWN_QUESTION), + ("hr", "salary", SALARY_QUESTION), + ("sales", "denied", SALARY_QUESTION), + ]: + user = f"l2s_demo_{team}" + reader_url = base.set(username=user).render_as_string( + hide_password=False + ) + explorer = RecordingExplorer(reader_url) + sql = SALARY_SQL + if case == "revenue": + expression = ( + "gross_amount" + if team == "sales" + else "gross_amount - discount_amount - return_amount" + ) + sql = f"SELECT SUM({expression}) AS revenue FROM {OWNER}.orders WHERE {PERIOD}" + call = ToolCall("demo", "run_sql", {"sql": sql}) + if case == "clarification": + call = ToolCall( + "demo", + "ask_user", + {"question": "충성고객의 기준이 무엇인가요?"}, + ) + llm = ( + OpenAILLM(model=model, api_key=api_key) + if live + else ScriptedLLM(call) + ) + concierge = ContextConcierge(store=store, explorer=explorer, llm=llm) + identity = Identity( + user_id=user, guild_id="oracle-demo", channel_id=team + ) + ctx = await concierge.build_context(identity) + try: + # Seed definitions through the same public tool as normal use. + for definition_team, definition in DEFINITIONS.items(): + definition_ctx = await concierge.build_context( + Identity( + user_id="curator", + guild_id="oracle-demo", + channel_id=definition_team, + ) + ) + result = await SemanticFederationTool().run( + { + "term": "매출", + "kind": "metric", + "layer": "team", + "definition": definition, + }, + definition_ctx, + ) + if result.is_error: + raise RuntimeError(result.content) + await SemanticFederationTool().run( + { + "term": "급여", + "layer": "team", + "kind": "metric", + "definition": f"{OWNER}.salaries의 salary, 부서는 department. 부서별 평균은 AVG(salary). 접근 권한은 DB에서 결정.", + }, + ctx, + ) + db_user = ( + await explorer.execute("SELECT USER AS db_user FROM dual") + )[0]["db_user"] + version = (await explorer.execute("SELECT banner FROM v$version"))[ + 0 + ]["banner"] + report["database"] = version + explorer.executions.clear() + # Independently prove the server rejects a known-valid query. + permission_probe = None + if case == "denied": + try: + await explorer.execute(SALARY_SQL) + except Exception as exc: + logger.info( + "permission probe rejected team=%s error=%s", + team, + type(exc).__name__, + ) + permission_probe = explorer.executions[-1].get("error") + else: + permission_probe = "UNEXPECTED_ACCESS" + explorer.executions.clear() + answer = await agent_loop(ctx, question) + rows = [r for e in explorer.executions for r in e.get("rows", [])] + errors = [e["error"] for e in explorer.executions if "error" in e] + values = [v for row in rows for v in row.values()] + if case == "revenue": + expected = 2000000 if team == "sales" else 1700000 + passed = len(rows) == 1 and expected in values and not errors + elif case == "clarification": + passed = not explorer.executions and any( + m.name == "ask_user" and "Awaiting user" in m.content + for m in ctx.session.history() + ) + elif case == "salary": + passed = {tuple(sorted(r.values(), key=str)) for r in rows} == { + (3000000, "sales"), + (4000000, "finance"), + } and not errors + else: + passed = ( + permission_probe in {"ORA-00942", "ORA-01031"} + and not rows + and bool( + re.search( + r"권한|접근|permission|privilege|ORA-00942|ORA-01031", + answer, + re.IGNORECASE, + ) + ) + ) + passed = passed and db_user == user.upper() + report["cases"].append( + { + "repeat": repeat + 1, + "case": case, + "team": team, + "db_user": db_user, + "question": question, + "definition": DEFINITIONS.get(team), + "passed": passed, + "permission_probe": permission_probe, + "answer": answer, + "executions": explorer.executions, + "tool_calls": [ + c.name + for m in ctx.session.history() + for c in m.tool_calls + ], + } + ) + logger.info( + "oracle demo case=%s team=%s repeat=%d passed=%s", + case, + team, + repeat + 1, + passed, + ) + finally: + if explorer._engine is not None: + await asyncio.to_thread(explorer._engine.dispose) + report["passed"] = all(case["passed"] for case in report["cases"]) + return report + finally: + store.close() + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("command", choices=["seed", "verify"]) + parser.add_argument("--live", action="store_true") + parser.add_argument("--repeats", type=int, default=1) + parser.add_argument("--output", type=Path, required=False) + args = parser.parse_args() + logging.basicConfig(level=logging.INFO) + url = os.environ.get("LANG2SQL_DB_URL", "") + if not url or make_url(url).drivername != "oracle+oracledb": + parser.error( + "LANG2SQL_DB_URL must be an oracle+oracledb URL to the disposable demo database" + ) + if args.repeats < 1: + parser.error("--repeats must be positive") + if args.command == "seed": + seed(url) + return + report = asyncio.run( + verify( + url, + args.live, + os.environ.get("OPENAI_API_KEY"), + os.environ.get("LANG2SQL_LLM_MODEL") or "gpt-4.1-mini", + args.repeats, + ) + ) + serialized = json.dumps(report, ensure_ascii=False, indent=2, default=str) + if args.output: + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text(serialized + "\n") + print(serialized) + if not report["passed"]: + raise SystemExit(1) + + +if __name__ == "__main__": + main() diff --git a/docs/oracle_demo.md b/docs/oracle_demo.md new file mode 100644 index 0000000..404ac8a --- /dev/null +++ b/docs/oracle_demo.md @@ -0,0 +1,82 @@ +# Oracle × Lang2SQL 데모 + +같은 질문에 부서별 정의를 적용하고, 정의가 없으면 되묻고, Oracle 조회 권한을 지키는 CLI 데모다. `bench/oracle_demo.py`는 기존 `ContextConcierge → agent_loop → RunSQL → SqlAlchemyExplorer` 경로를 실행한다. 별도 SQL 생성 엔진이나 Oracle 전용 에이전트는 없다. + +## 보여줄 장면과 합격 조건 + +| 장면 | 입력 | 합격 조건 | +|---|---|---| +| 영업 매출 | 2026년 10월 매출 얼마야? | 주문 총액 2,000,000원 | +| 재무 매출 | 동일 질문 | 할인·반품 차감 후 1,700,000원 | +| 정의 없는 용어 | 2026년 10월 충성고객 매출 | `ask_user`, 업무 SQL 실행 0회 | +| 인사 급여 | 부서별 급여 평균 | sales 3,000,000원, finance 4,000,000원 | +| 영업 급여 | 동일 급여 질문 | 실제 DB 차단, 급여 결과 없음, 접근 불가 안내 | + +데이터는 전부 합성이다. 10월 주문 3건 외에 9월·11월 주문을 넣어 기간 조건 누락을 검출한다. `--output` JSON에는 접속 사용자, 선택할 부서 정의, 실제 SQL과 DB 결과, 답변, 도구 호출을 남긴다. 급여 차단은 동일 SQL의 독립적인 권한 검사에서 `ORA-00942` 또는 `ORA-01031`이 나오는지 확인하고, 별도로 에이전트의 거절 응답을 검사한다. 모델이 스키마 탐색에서 권한 부족을 알아내면 업무 SQL 없이 거절할 수도 있다. + +## 로컬 재현 + +Docker와 uv가 필요하다. **새로 만든 폐기 가능한 데모 DB에서만 seed를 실행한다.** 생성할 사용자가 이미 있으면 seed는 중단하며 기존 사용자를 삭제하지 않는다. Oracle DDL은 자동 커밋되므로 중간 실패 후에는 새 컨테이너로 다시 준비한다. + +```bash +uv sync --extra oracle +export ORACLE_PASSWORD="$(openssl rand -hex 16)" +export ORACLE_DEMO_PORT=11521 +export LANG2SQL_DB_URL="oracle+oracledb://system:${ORACLE_PASSWORD}@127.0.0.1:${ORACLE_DEMO_PORT}/?service_name=FREEPDB1" + +docker compose -p lang2sql-oracle-demo -f bench/oracle/compose.yaml up -d --wait +uv run python bench/oracle_demo.py seed +uv run python bench/oracle_demo.py verify --output /tmp/oracle-scripted.json +``` + +기본 verify는 **실제 Oracle + 명시적인 ScriptedLLM**으로 연결·안전장치·도구 동작을 검증한다. 이 결과는 LLM 정확도가 아니다. + +실제 모델로 같은 사례를 반복하려면 `OPENAI_API_KEY`를 환경에 설정한 뒤 실행한다. 키를 명령행 인수나 결과 파일에 넣지 않는다. + +```bash +export LANG2SQL_LLM_MODEL=gpt-4.1-mini +uv run python bench/oracle_demo.py verify --live --repeats 3 --output /tmp/oracle-live.json +``` + +`--live`는 키가 없으면 실패하며 FakeLLM으로 대체하지 않는다. 모델 호출은 실제 API 요금이 발생한다. 하나라도 판정에 실패하면 종료 코드 1을 반환한다. 결과 JSON의 답변과 SQL도 발표 전에 읽어 확인한다. + +```bash +# DB를 남겨두고 중지 / 다시 시작 +docker compose -p lang2sql-oracle-demo -f bench/oracle/compose.yaml stop +docker compose -p lang2sql-oracle-demo -f bench/oracle/compose.yaml start +``` + +## 권한과 범위 + +- `l2s_demo_owner`가 주문·급여 테이블을 소유한다. 영업·재무·인사 계정은 CREATE SESSION 및 필요한 테이블의 SELECT만 가진다. 에이전트에는 SYSTEM 계정을 전달하지 않는다. +- 이번 CLI 데모는 고정된 persona와 DB 계정을 조립점에서 연결한다. 실제 Discord의 guild별 DSN 설정을 사용자별 인증·계정 라우팅으로 확장한 것은 아니다. 운영 도입 시 인증된 사용자와 DB 신원의 연결이 별도로 필요하다. +- 각 persona는 서로 다른 채널/세션을 사용한다. 결과 캐시는 사용하지 않는다. 기존 전체 서비스의 세션·캐시 격리를 보증하는 테스트는 아니다. +- 모호한 표현의 발견은 모델과 프롬프트에 의존한다. 모델이 `ask_user`를 요청한 뒤의 중단은 루프가 강제하며 같은 도구 배치에 섞인 SQL도 취소한다. 모든 자연어의 모호함을 결정적으로 판별하는 규칙 엔진은 아니다. +- 기존 다중 정의 주입 정책은 유지한다. 부서별 정의는 SQL 생성의 맥락이며 DB 접근 권한을 대신하지 않는다. +- Oracle의 ORA-00942/ORA-01031은 adapter에서 DataAccessError로 변환한다. RunSQL은 실패를 audit에 남기고 도구 턴을 종료한다. 루프는 같은 배치의 나머지 도구도 취소하며, 모델이 다른 테이블을 탐색하거나 “테이블이 없다”고 단정하지 않도록 중립적인 안내를 직접 반환한다. 다른 SQL 오류는 기존 복구 경로를 유지한다. +- 이번 검증은 테이블 SELECT 권한이다. VPD, Oracle Graph/Vector, 장기 기억, 자동 관계 추출, 운영 보안 전체는 검증 범위 밖이다. +- 기존 TimeoutLayer의 값 설정과 DB 실행 타임아웃 강제는 별개다. 이 PR에서 전체 실행시간 제한 기능을 추가하지 않는다. + +## Oracle 연결 설정 + +`/setup`의 Oracle Database 항목은 host(선택 포트 포함), service_name, user, password를 받는다. `uv sync --extra oracle`로 드라이버를 설치한다. `oracle://` URL도 factory에서 `oracle+oracledb://`로 정규화한다. Thin 모드로 Oracle Client 설치 없이 연결한다. + +SQLAlchemy adapter가 연결을 열지 않고 dialect를 알린다. 시스템 프롬프트에는 Oracle 날짜·행 제한 문법을 넣고, RunSQL이 safety context에 dialect를 전달해 `FETCH FIRST ... ROWS ONLY`를 사용한다. 명시된 FETCH는 중복 추가하지 않으며, 하위 질의·문자열·주석 속 FETCH는 바깥 결과 제한으로 취급하지 않는다. + +## 참고 자료 + +- [SQLAlchemy Oracle dialect와 python-oracledb 연결](https://docs.sqlalchemy.org/en/20/dialects/oracle.html) +- [Oracle 객체 권한과 역할](https://docs.oracle.com/en/database/oracle/oracle-database/21/dbseg/configuring-privilege-and-role-authorization.html) +- [Oracle Free 컨테이너 사용법](https://github.com/gvenzl/oci-oracle-free) + +## 검증 기록 (2026-11-11) + +Oracle Free 23.9 ARM64 컨테이너, Python 3.13, SQLAlchemy 2.0.50, python-oracledb 3.4.2에서 실행했다. + +- [실제 모델 실행 기록](../bench/oracle/results/live.json): gpt-4.1-mini, 5개 사례 × 3회 = **15/15 통과**. 실제 답변도 읽어 매출·급여 수치와 거절 문구를 확인했다. +- [고정 도구 호출 실행 기록](../bench/oracle/results/scripted.json): 실제 Oracle, **5/5 통과**. 모델 추론 없이 DB/하네스 연결을 검증한다. +- [접근 오류 처리 보완 전 기록](../bench/oracle/results/before-access-fix.json): **13/15 통과**. DB 차단은 성공했으나 2회에 모델이 테이블 부재로 단정했다. 접근 오류 뒤 턴을 종료하도록 고친 후 위 15회를 다시 실행했다. +- pytest **176 passed**, 전체 Black 검사 통과, 변경 파일 Ruff(E4/E7/E9/F) 통과. +- mypy는 기존 master와 동일한 오류 19개가 남아 있다. 신규 타입 오류는 없다. CODE MAP 생성 스크립트는 이 저장소에 없다. + +이는 고정된 데모 사례의 반복 검증이다. 독립 질문 15개 평가나 일반 정확도 100%라는 의미가 아니다. 발표에서는 JSON의 SQL·결과·db_user를 함께 보여준다. diff --git a/pyproject.toml b/pyproject.toml index 572d328..c6225d5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -26,12 +26,14 @@ bigquery = ["sqlalchemy-bigquery>=1.11"] snowflake = ["snowflake-sqlalchemy>=1.6"] mysql = ["pymysql>=1.1"] duckdb = ["duckdb-engine>=0.13"] +oracle = ["oracledb>=2.0,<4.0"] all-db = [ "psycopg[binary]>=3.2,<4.0", "sqlalchemy-bigquery>=1.11", "snowflake-sqlalchemy>=1.6", "pymysql>=1.1", "duckdb-engine>=0.13", + "oracledb>=2.0,<4.0", ] [project.scripts] diff --git a/src/lang2sql/adapters/db/dsn_builder.py b/src/lang2sql/adapters/db/dsn_builder.py index b723041..aefdc10 100644 --- a/src/lang2sql/adapters/db/dsn_builder.py +++ b/src/lang2sql/adapters/db/dsn_builder.py @@ -24,6 +24,7 @@ class ConnectionSpec: # Supported DB types in the wizard. Order matters — surfaces in the dropdown. SUPPORTED_DB_TYPES: tuple[str, ...] = ( "postgresql", + "oracle", "mysql", "snowflake", "bigquery", @@ -49,6 +50,25 @@ def build_postgresql( return ConnectionSpec(dsn=dsn, extras={}) +def build_oracle( + *, host: str, service_name: str, user: str, password: str +) -> ConnectionSpec: + from sqlalchemy.engine import URL + + parsed = urlsplit("//" + host) + if not parsed.hostname or parsed.path or parsed.query or parsed.username: + raise ValueError("Oracle host must be a hostname with optional :port") + url = URL.create( + "oracle+oracledb", + username=user, + password=password, + host=parsed.hostname, + port=parsed.port or 1521, + query={"service_name": service_name}, + ) + return ConnectionSpec(dsn=url.render_as_string(hide_password=False), extras={}) + + def build_mysql( *, host: str, port: str, database: str, user: str, password: str ) -> ConnectionSpec: @@ -89,6 +109,12 @@ def build_d1(*, account_id: str, database_id: str, api_token: str) -> Connection # Field schemas surfaced by the Discord Modal layer. Each entry is # (label, placeholder, required, masked). FIELD_SCHEMA: dict[str, list[tuple[str, str, bool, bool]]] = { + "oracle": [ + ("host", "localhost:1521", True, False), + ("service_name", "FREEPDB1", True, False), + ("user", "readonly_user", True, False), + ("password", "•••••", True, True), + ], "postgresql": [ ("host", "db.example.com", True, False), ("port", "5432", False, False), @@ -126,6 +152,7 @@ def build_d1(*, account_id: str, database_id: str, api_token: str) -> Connection _BUILDERS = { + "oracle": build_oracle, "postgresql": build_postgresql, "mysql": build_mysql, "snowflake": build_snowflake, diff --git a/src/lang2sql/adapters/db/factory.py b/src/lang2sql/adapters/db/factory.py index fcde5a7..73be888 100644 --- a/src/lang2sql/adapters/db/factory.py +++ b/src/lang2sql/adapters/db/factory.py @@ -59,6 +59,9 @@ def build_explorer( if scheme == "postgresql": connection = "postgresql+psycopg" + connection[len("postgresql") :] + if scheme == "oracle": + connection = "oracle+oracledb" + connection[len("oracle") :] + # Anything else is assumed to be a SQLAlchemy URL (driver loaded lazily). return SqlAlchemyExplorer(connection, schema=schema) diff --git a/src/lang2sql/adapters/db/sqlalchemy_explorer.py b/src/lang2sql/adapters/db/sqlalchemy_explorer.py index 11fd3cd..284eedd 100644 --- a/src/lang2sql/adapters/db/sqlalchemy_explorer.py +++ b/src/lang2sql/adapters/db/sqlalchemy_explorer.py @@ -15,7 +15,9 @@ import asyncio from typing import Any -from ...core.ports.explorer import Column, Table +from ...core.ports.explorer import Column, DataAccessError, Table + +_ORACLE_ACCESS_ERRORS = frozenset({942, 1031}) class SqlAlchemyExplorer: @@ -26,6 +28,13 @@ def __init__(self, url: str, *, schema: str | None = None) -> None: self._schema = schema self._engine: Any = None # created lazily + @property + def dialect(self) -> str: + """SQL dialect hint without importing a driver or opening a connection.""" + from sqlalchemy.engine import make_url + + return make_url(self.url).get_backend_name() + def _get_engine(self) -> Any: if self._engine is None: from sqlalchemy import create_engine # imported here = lazy driver load @@ -42,10 +51,14 @@ async def describe_table(self, name: str) -> Table: return await asyncio.to_thread(self._describe_table_sync, name) async def sample_rows(self, name: str, limit: int = 5) -> list[dict]: - # Bind the limit; quote the identifier via the dialect's preparer. - eng = self._get_engine() - qname = eng.dialect.identifier_preparer.quote(name) - return await self.execute(f"SELECT * FROM {qname}", limit=limit) + return await asyncio.to_thread(self._sample_rows_sync, name, limit) + + def _sample_rows_sync(self, name: str, limit: int) -> list[dict]: + preparer = self._get_engine().dialect.identifier_preparer + qname = preparer.quote(name) + if self._schema: + qname = f"{preparer.quote_schema(self._schema)}.{qname}" + return self._execute_sync(f"SELECT * FROM {qname}", limit) async def execute(self, sql: str, limit: int = 1000) -> list[dict]: return await asyncio.to_thread(self._execute_sync, sql, int(limit)) @@ -72,6 +85,8 @@ def _list_tables_sync(self) -> list[Table]: def _describe_table_sync(self, name: str) -> Table: from sqlalchemy import inspect + if self._schema and name.startswith(self._schema + "."): + name = name[len(self._schema) + 1 :] insp = inspect(self._get_engine()) cols = [ Column( @@ -86,9 +101,25 @@ def _describe_table_sync(self, name: str) -> Table: def _execute_sync(self, sql: str, limit: int) -> list[dict]: from sqlalchemy import text + from sqlalchemy.exc import DBAPIError with self._get_engine().connect() as conn: - result = conn.execute(text(sql)) + try: + result = conn.execute(text(sql)) + except DBAPIError as exc: + code = ( + getattr(exc.orig.args[0], "code", None) + if exc.orig is not None and exc.orig.args + else None + ) + if self.dialect == "oracle" and code in _ORACLE_ACCESS_ERRORS: + # ORA-00942 deliberately does not distinguish a missing table + # from one hidden by privileges. Do not assert either cause. + raise DataAccessError( + f"ORA-{code:05d}: requested table is unavailable to this account " + "(missing table or insufficient privileges)" + ) from exc + raise if not result.returns_rows: return [] rows = result.mappings().fetchmany(limit) diff --git a/src/lang2sql/core/ports/explorer.py b/src/lang2sql/core/ports/explorer.py index d9776ae..33cfe48 100644 --- a/src/lang2sql/core/ports/explorer.py +++ b/src/lang2sql/core/ports/explorer.py @@ -11,6 +11,10 @@ from typing import Protocol, runtime_checkable +class DataAccessError(RuntimeError): + """Requested data is unavailable to this DB identity; do not probe alternatives.""" + + @dataclass class Column: name: str @@ -33,7 +37,11 @@ def qualified(self) -> str: @runtime_checkable class ExplorerPort(Protocol): - """Introspect a connected database, read-only.""" + """Introspect a connected database, read-only. + + Adapters may expose a non-I/O ``dialect`` string (e.g. ``oracle``) for + prompt and row-limit syntax. Legacy implementations default to LIMIT SQL. + """ async def list_tables(self) -> list[Table]: """Tables visible to the connection (columns may be unpopulated).""" diff --git a/src/lang2sql/core/types.py b/src/lang2sql/core/types.py index 4637585..1ff20f4 100644 --- a/src/lang2sql/core/types.py +++ b/src/lang2sql/core/types.py @@ -41,6 +41,7 @@ class ToolResult: call_id: str content: str is_error: bool = False + stop_turn: bool = False @dataclass diff --git a/src/lang2sql/frontends/discord/setup_wizard.py b/src/lang2sql/frontends/discord/setup_wizard.py index 3966107..72f54cd 100644 --- a/src/lang2sql/frontends/discord/setup_wizard.py +++ b/src/lang2sql/frontends/discord/setup_wizard.py @@ -22,7 +22,6 @@ if TYPE_CHECKING: from .commands import CommandHandlers - from .bot import InteractionContext # Per-DB human labels surfaced in the dropdown. @@ -32,6 +31,7 @@ "snowflake": "Snowflake", "bigquery": "BigQuery", "duckdb": "DuckDB (file)", + "oracle": "Oracle Database", "d1": "Cloudflare D1", } diff --git a/src/lang2sql/harness/loop.py b/src/lang2sql/harness/loop.py index 4a8e59a..8fc2866 100644 --- a/src/lang2sql/harness/loop.py +++ b/src/lang2sql/harness/loop.py @@ -8,10 +8,15 @@ from __future__ import annotations -from ..core.types import Message, Role +import logging + +from ..core.types import Message, Role, ToolCall + from .context import HarnessContext from .system_prompt import build_system_prompt +logger = logging.getLogger(__name__) + async def agent_loop(ctx: HarnessContext, user_text: str) -> str: """Run one user turn to completion; return the final assistant text.""" @@ -20,9 +25,18 @@ async def agent_loop(ctx: HarnessContext, user_text: str) -> str: system = await build_system_prompt(ctx) specs = ctx.tools.specs() - for _ in range(ctx.max_turns): + for turn in range(ctx.max_turns): + logger.info( + "llm request scope=%s turn=%d", ctx.identity.session_key(), turn + 1 + ) messages = [Message(role=Role.SYSTEM, content=system), *ctx.session.history()] completion = await ctx.llm.complete(messages, specs) + logger.info( + "llm response scope=%s turn=%d tool_calls=%d", + ctx.identity.session_key(), + turn + 1, + len(completion.tool_calls), + ) assistant = Message( role=Role.ASSISTANT, @@ -34,8 +48,31 @@ async def agent_loop(ctx: HarnessContext, user_text: str) -> str: if not completion.tool_calls: return completion.content - for call in completion.tool_calls: + # A clarification in the same batch must stop SQL even if SQL came first. + clarification = next( + ( + call + for call in completion.tool_calls + if call.name == "ask_user" + and str(call.arguments.get("question") or "").strip() + ), + None, + ) + if clarification is not None: + result = await ctx.tools.dispatch( + clarification.name, clarification.arguments, ctx, clarification.id + ) + if result.stop_turn: + return _finish_tool_turn( + ctx, completion.tool_calls, clarification.id, result.content + ) + + for index, call in enumerate(completion.tool_calls): result = await ctx.tools.dispatch(call.name, call.arguments, ctx, call.id) + if result.stop_turn: + return _finish_tool_turn( + ctx, completion.tool_calls[index:], call.id, result.content + ) ctx.session.add( Message( role=Role.TOOL, @@ -46,3 +83,27 @@ async def agent_loop(ctx: HarnessContext, user_text: str) -> str: ) return "(reached max turns without a final answer)" + + +def _finish_tool_turn( + ctx: HarnessContext, pending: list[ToolCall], call_id: str, content: str +) -> str: + """Resolve every outstanding tool ID before returning control to the user.""" + for call in pending: + ctx.session.add( + Message( + role=Role.TOOL, + name=call.name, + tool_call_id=call.id, + content=( + content + if call.id == call_id + else "Not executed: this turn has stopped." + ), + ) + ) + ctx.session.add(Message(role=Role.ASSISTANT, content=content)) + logger.info( + "tool stopped turn scope=%s call_id=%s", ctx.identity.session_key(), call_id + ) + return content diff --git a/src/lang2sql/harness/system_prompt.py b/src/lang2sql/harness/system_prompt.py index b5474f4..1e91439 100644 --- a/src/lang2sql/harness/system_prompt.py +++ b/src/lang2sql/harness/system_prompt.py @@ -32,6 +32,16 @@ async def build_system_prompt(ctx: HarnessContext) -> str: parts: list[str] = [_BASE] if ctx.explorer is not None: + dialect = getattr(ctx.explorer, "dialect", "") + if dialect: + parts.append(f"## SQL dialect\n{dialect}") + if dialect == "oracle": + parts.append( + "Use Oracle SQL: DATE 'YYYY-MM-DD' literals and FETCH FIRST n ROWS ONLY, " + "not LIMIT. Preserve schema-qualified table names. " + "On a permission denial, explain the denial without changing credentials " + "or searching other tables for the denied data." + ) tables = await ctx.explorer.list_tables() if tables: scope = ctx.identity.kv_scope if ctx.store else None diff --git a/src/lang2sql/safety/layers/row_limit.py b/src/lang2sql/safety/layers/row_limit.py index 919299e..1258763 100644 --- a/src/lang2sql/safety/layers/row_limit.py +++ b/src/lang2sql/safety/layers/row_limit.py @@ -1,4 +1,4 @@ -"""RowLimitLayer — automatically appends LIMIT to queries that lack one. +"""RowLimitLayer — appends a dialect-appropriate outer row limit when absent. Returns PASS (not REWRITE) so the rewritten SQL flows into the next layer (TimeoutLayer) and ctx.timeout_seconds still gets configured. @@ -11,31 +11,49 @@ from ...core.ports.safety import SafetyContext, SafetyDecision, Verdict _LIMIT_RE = re.compile(r"\bLIMIT\s+\d+", re.IGNORECASE) - - -def _has_top_level_limit(sql: str) -> bool: - """True if a LIMIT clause exists at parenthesis depth 0.""" +_FETCH_RE = re.compile( + r"\bFETCH\s+(?:FIRST|NEXT)\s+(?:\d+\s+)?ROWS?\s+(?:ONLY|WITH\s+TIES)", re.IGNORECASE +) + + +def _has_top_level_limit(sql: str, pattern: re.Pattern = _LIMIT_RE) -> bool: + """True if the requested row-limit clause exists at parenthesis depth 0.""" + # Ignore quoted text/comments so examples such as 'FETCH FIRST 1 ROWS ONLY' + # cannot disable the cap. Parentheses in literals do not affect nesting. + tokens = re.findall( + r"--[^\n]*|/\*.*?\*/|'(?:''|[^'])*'|\"(?:\"\"|[^\"])*\"|[()]|[^()'\"/-]+|.", + sql, + re.DOTALL, + ) depth = 0 - for part in re.split(r"(\(|\))", sql): - if part == "(": + top_level = [] + for token in tokens: + if token.startswith(("'", '"', "--", "/*")): + top_level.append(" ") + elif token == "(": depth += 1 - elif part == ")": + elif token == ")": depth -= 1 - elif depth == 0 and _LIMIT_RE.search(part): - return True - return False + elif depth == 0: + top_level.append(token) + return bool(pattern.search("".join(top_level))) class RowLimitLayer: - """Appends LIMIT when absent; leaves explicit LIMITs untouched.""" + """Appends LIMIT or Oracle FETCH; leaves explicit outer limits untouched.""" @property def name(self) -> str: return "row_limit" def check(self, sql: str, ctx: SafetyContext) -> SafetyDecision: - if _has_top_level_limit(sql): + oracle = ctx.extras.get("dialect") == "oracle" + if oracle: + sql = sql.rstrip().rstrip(";") + pattern = _FETCH_RE if oracle else _LIMIT_RE + if _has_top_level_limit(sql, pattern): return SafetyDecision(verdict=Verdict.PASS, sql=sql, layer=self.name) limit = ctx.row_limit if ctx.row_limit and ctx.row_limit > 0 else 1000 - rewritten = sql.rstrip().rstrip(";") + f"\nLIMIT {limit}" + clause = f"FETCH FIRST {limit} ROWS ONLY" if oracle else f"LIMIT {limit}" + rewritten = sql.rstrip().rstrip(";") + f"\n{clause}" return SafetyDecision(verdict=Verdict.PASS, sql=rewritten, layer=self.name) diff --git a/src/lang2sql/tools/ask_user.py b/src/lang2sql/tools/ask_user.py index 683fb6c..becfbef 100644 --- a/src/lang2sql/tools/ask_user.py +++ b/src/lang2sql/tools/ask_user.py @@ -1,10 +1,8 @@ """ask_user — request a clarification from the human. -The agent calls this when a question is ambiguous. V1 returns the question as -the tool result; the frontend surfaces it and the user's reply arrives as the -next turn. (A suspend/resume round-trip is a v1.5 frontend concern; the loop -contract here is simply that the model gets its question echoed back so it -stops guessing.) +The harness treats a successful clarification as a turn boundary. Any other +calls in that completion are cancelled, and only a new user turn can resume. + """ from __future__ import annotations @@ -34,4 +32,6 @@ async def run(self, args: dict[str, Any], ctx: "HarnessContext") -> ToolResult: question = (args.get("question") or "").strip() if not question: return ToolResult(call_id="", content="no question provided", is_error=True) - return ToolResult(call_id="", content=f"❓ Awaiting user: {question}") + return ToolResult( + call_id="", content=f"❓ Awaiting user: {question}", stop_turn=True + ) diff --git a/src/lang2sql/tools/run_sql.py b/src/lang2sql/tools/run_sql.py index b348915..5a66841 100644 --- a/src/lang2sql/tools/run_sql.py +++ b/src/lang2sql/tools/run_sql.py @@ -8,15 +8,20 @@ from __future__ import annotations +import logging from typing import TYPE_CHECKING, Any + from ..core.ports.audit import AuditEvent +from ..core.ports.explorer import DataAccessError from ..core.ports.safety import SafetyContext, Verdict from ..core.types import ToolResult, ToolSpec if TYPE_CHECKING: from ..harness.context import HarnessContext +logger = logging.getLogger(__name__) + class RunSQL: @property @@ -47,7 +52,13 @@ async def run(self, args: dict[str, Any], ctx: "HarnessContext") -> ToolResult: sql = (args.get("sql") or "").strip() try: limit = int(args.get("limit") or 1000) - except (TypeError, ValueError): + except (TypeError, ValueError) as exc: + logger.warning( + "invalid row limit scope=%s error=%s: %s", + ctx.identity.session_key(), + type(exc).__name__, + exc, + ) limit = 1000 # tolerate a malformed limit from the model if ctx.safety is None: @@ -63,7 +74,13 @@ async def run(self, args: dict[str, Any], ctx: "HarnessContext") -> ToolResult: is_error=True, ) - decision = ctx.safety.evaluate(sql, SafetyContext(row_limit=limit)) + decision = ctx.safety.evaluate( + sql, + SafetyContext( + row_limit=limit, + extras={"dialect": getattr(ctx.explorer, "dialect", "")}, + ), + ) if decision.verdict == Verdict.BLOCK: return ToolResult( call_id="", @@ -75,7 +92,32 @@ async def run(self, args: dict[str, Any], ctx: "HarnessContext") -> ToolResult: call_id="", content=f"NEEDS CONFIRMATION: {decision.confirm_prompt}" ) - rows = await ctx.explorer.execute(decision.sql, limit) + scope = ctx.identity.session_key() + logger.info("run_sql started scope=%s actor=%s", scope, ctx.identity.user_id) + try: + rows = await ctx.explorer.execute(decision.sql, limit) + except Exception as exc: + logger.warning( + "run_sql failed scope=%s error=%s: %s", scope, type(exc).__name__, exc + ) + if ctx.audit is not None: + await ctx.audit.record( + AuditEvent( + actor=ctx.identity.user_id, + action="run_sql_failed", + scope=scope, + detail={"sql": decision.sql, "error_type": type(exc).__name__}, + ) + ) + if isinstance(exc, DataAccessError): + return ToolResult( + call_id="", + is_error=True, + stop_turn=True, + content="요청한 데이터에 접근할 수 없습니다. 현재 DB 계정에 조회 권한이 없거나 테이블이 존재하지 않습니다. DB 관리자에게 확인해 주세요.", + ) + raise + logger.info("run_sql completed scope=%s rows=%d", scope, len(rows)) if ctx.audit is not None: await ctx.audit.record( diff --git a/src/lang2sql/tools/semantic_federation.py b/src/lang2sql/tools/semantic_federation.py index 7244457..26a9a73 100644 --- a/src/lang2sql/tools/semantic_federation.py +++ b/src/lang2sql/tools/semantic_federation.py @@ -21,6 +21,10 @@ from ..core.ports.audit import AuditEvent from ..core.ports.tool import ToolPort, ToolResult, ToolSpec +from ..tools.enrich_schema import ( + _KV_PREFIX as _ENRICH_PREFIX, + _KV_RELATIONSHIPS as _ENRICH_RELATIONSHIPS, +) if TYPE_CHECKING: from ..harness.context import HarnessContext @@ -43,11 +47,6 @@ def _validate_layer( return layer, None -from ..tools.enrich_schema import ( - _KV_PREFIX as _ENRICH_PREFIX, - _KV_RELATIONSHIPS as _ENRICH_RELATIONSHIPS, -) - _AMBIGUITY_SIGNALS: dict[str, str] = { r"(^|_)(created|registered|joined|signup)(_at|_date)?$": "신규/최초 가입 기준 용어", r"(^|_)(last|latest|recent)_(login|visit|active|seen|access)(_at|_date)?$": "활성화 기준 용어", @@ -409,11 +408,10 @@ def _load_all(store: Any, scope: str) -> dict[str, list[FedEntry]]: _AMBIGUOUS_TERM_POLICY = """\ ## Ambiguous Term Policy 사전에 없는 주관적/모호한 표현을 발견하면: -1. DB 스키마 기준으로 가장 합리적인 해석으로 SQL을 실행한다. -2. 실행 후 사용한 해석을 명시하고, kind(metric/rule/dimension/table)와 범위(org/team/user)를 사용자에게 묻는다. - 예: "'신규고객'을 'users.created_at >= NOW()-30일'로 해석했습니다. metric/rule/dimension/table 중 어느 종류이며, 어느 범위로 등록할까요?" -3. 사용자가 지정하면 term_custom 툴로 즉시 등록한다 (inferred=true). -4. inferred=true 엔트리가 이미 있으면 해당 정의를 우선 사용하되, 사용자에게 확정 여부를 확인한다.\ +1. SQL을 실행하기 전에 ask_user 툴로 기준을 묻고 사용자 답변을 기다린다. 추측한 정의로 실행하지 않는다. +2. 예: "충성고객의 기준이 무엇인가요? 구매 횟수와 누적 구매액 중 어떤 기준을 쓸까요?" +3. 사용자가 정의를 확인하면 해당 기준으로 질의한다. 영구 저장은 사용자가 종류(metric/rule/dimension/table)와 범위(org/team/user)를 지정한 경우에만 term_custom으로 수행한다. +4. inferred=true인 임시 정의도 사용 전에 사용자에게 확인한다.\ """ diff --git a/tests/test_oracle_demo.py b/tests/test_oracle_demo.py new file mode 100644 index 0000000..cef6d4f --- /dev/null +++ b/tests/test_oracle_demo.py @@ -0,0 +1,250 @@ +"""Oracle routing, safety, and clarification regressions without network access.""" + +import asyncio + +import pytest +from sqlalchemy.engine import make_url + +from lang2sql.adapters.db.dsn_builder import assemble +from lang2sql.adapters.db.factory import build_explorer +from lang2sql.adapters.llm.fake import FakeLLM +from lang2sql.core.identity import Identity +from lang2sql.core.ports.safety import SafetyContext +from lang2sql.core.types import Completion, Role, ToolCall +from lang2sql.harness.loop import agent_loop +from lang2sql.harness.system_prompt import build_system_prompt +from lang2sql.safety.pipeline import SafetyPipeline +from lang2sql.tenancy.concierge import ContextConcierge +from lang2sql.tools.run_sql import RunSQL +from lang2sql.tools.semantic_federation import build_prompt_section + + +def test_oracle_form_roundtrips_service_and_credentials(): + url = make_url( + assemble( + "oracle", + { + "host": "localhost:11521", + "service_name": "FREEPDB1", + "user": "reader", + "password": "p@ss /?#", + }, + ).dsn + ) + assert url.drivername == "oracle+oracledb" + assert url.password == "p@ss /?#" + assert url.port == 11521 + assert url.query == {"service_name": "FREEPDB1"} + explorer = build_explorer("oracle://u:p@host/?service_name=FREEPDB1") + assert explorer.dialect == "oracle" + assert explorer._engine is None + + +@pytest.mark.parametrize( + "sql,expected", + [ + ("SELECT * FROM orders", "SELECT * FROM orders\nFETCH FIRST 7 ROWS ONLY"), + ("SELECT * FROM orders;", "SELECT * FROM orders\nFETCH FIRST 7 ROWS ONLY"), + ( + "SELECT * FROM orders FETCH FIRST 3 ROWS ONLY", + "SELECT * FROM orders FETCH FIRST 3 ROWS ONLY", + ), + ( + "SELECT * FROM (SELECT * FROM orders FETCH FIRST 3 ROWS ONLY)", + "SELECT * FROM (SELECT * FROM orders FETCH FIRST 3 ROWS ONLY)\nFETCH FIRST 7 ROWS ONLY", + ), + ( + "SELECT * FROM orders OFFSET 2 ROWS FETCH NEXT 3 ROWS ONLY", + "SELECT * FROM orders OFFSET 2 ROWS FETCH NEXT 3 ROWS ONLY", + ), + ], +) +def test_oracle_row_limit(sql, expected): + decision = SafetyPipeline().evaluate( + sql, SafetyContext(row_limit=7, extras={"dialect": "oracle"}) + ) + assert decision.sql == expected + + +class Explorer: + dialect = "oracle" + + def __init__(self, fail=False): + self.calls = [] + self.fail = fail + + async def list_tables(self): + return [] + + async def execute(self, sql, limit=1000): + self.calls.append(sql) + if self.fail: + raise PermissionError("ORA-01031: insufficient privileges") + return [{"revenue": 2000000}] + + +def test_run_sql_passes_dialect_and_records_db_failure(): + async def run(): + explorer = Explorer(fail=True) + concierge = ContextConcierge(llm=FakeLLM(), explorer=explorer) + ctx = await concierge.build_context(Identity(user_id="sales")) + with pytest.raises(PermissionError): + await RunSQL().run({"sql": "SELECT * FROM salaries"}, ctx) + assert explorer.calls[0].endswith("FETCH FIRST 1000 ROWS ONLY") + audit = await concierge.store.query("sales") + assert audit[0].action == "run_sql_failed" + assert audit[0].detail["error_type"] == "PermissionError" + concierge.store.close() + + asyncio.run(run()) + + +@pytest.mark.parametrize("sql_first", [True, False]) +def test_clarification_cancels_entire_batch_and_resumes_next_turn(sql_first): + class Model: + n = 0 + + async def complete(self, messages, tools=()): + self.n += 1 + if self.n == 1: + calls = [ + ToolCall("sql", "run_sql", {"sql": "SELECT * FROM orders"}), + ToolCall("ask", "ask_user", {"question": "충성고객의 기준은?"}), + ] + return Completion(tool_calls=calls if sql_first else calls[::-1]) + if self.n == 2: + return Completion( + tool_calls=[ + ToolCall( + "confirmed", + "run_sql", + {"sql": "SELECT SUM(gross_amount) FROM orders"}, + ) + ] + ) + return Completion(content="2000000원") + + async def run(): + explorer = Explorer() + model = Model() + concierge = ContextConcierge(llm=model, explorer=explorer) + ctx = await concierge.build_context(Identity(user_id="sales")) + answer = await agent_loop(ctx, "충성고객 매출") + assert "기준" in answer + assert explorer.calls == [] + assert model.n == 1 + tool_messages = [m for m in ctx.session.history() if m.role == Role.TOOL] + assert {m.tool_call_id for m in tool_messages} == {"sql", "ask"} + assert await agent_loop(ctx, "전체 고객으로 해줘") == "2000000원" + assert len(explorer.calls) == 1 + concierge.store.close() + + asyncio.run(run()) + + +def test_prompt_has_one_clarification_policy_and_oracle_dialect(): + async def run(): + concierge = ContextConcierge(llm=FakeLLM(), explorer=Explorer()) + ctx = await concierge.build_context(Identity(user_id="sales")) + prompt = await build_system_prompt(ctx) + assert "FETCH FIRST" in prompt + section = build_prompt_section(concierge.store, "g", "sales", "u") + assert "SQL을 실행하기 전에 ask_user" in section + assert "가장 합리적인 해석으로 SQL을 실행" not in prompt + concierge.store.close() + + asyncio.run(run()) + + +def test_oracle_fetch_in_literal_or_comment_does_not_disable_cap(): + for sql in [ + "SELECT 'FETCH FIRST 1 ROWS ONLY' AS note FROM dual", + "SELECT * FROM orders -- FETCH FIRST 1 ROWS ONLY", + ]: + decision = SafetyPipeline().evaluate( + sql, SafetyContext(row_limit=7, extras={"dialect": "oracle"}) + ) + assert decision.sql.endswith("\nFETCH FIRST 7 ROWS ONLY") + + +def test_oracle_existing_fetch_trailing_semicolon_is_removed(): + decision = SafetyPipeline().evaluate( + "SELECT * FROM orders FETCH FIRST 1 ROW ONLY;", + SafetyContext(extras={"dialect": "oracle"}), + ) + assert decision.sql == "SELECT * FROM orders FETCH FIRST 1 ROW ONLY" + + +def test_qualified_describe_and_sample_use_configured_schema(tmp_path): + from sqlalchemy import create_engine, text + from lang2sql.adapters.db.sqlalchemy_explorer import SqlAlchemyExplorer + + url = f"sqlite:///{tmp_path / 'db.sqlite'}" + engine = create_engine(url) + with engine.begin() as conn: + conn.execute(text("CREATE TABLE orders (amount INTEGER)")) + conn.execute(text("INSERT INTO orders VALUES (42)")) + explorer = SqlAlchemyExplorer(url, schema="main") + assert asyncio.run(explorer.describe_table("main.orders")).name == "orders" + assert asyncio.run(explorer.sample_rows("orders")) == [{"amount": 42}] + engine.dispose() + explorer._engine.dispose() + + +def test_access_denial_stops_retries_and_remaining_batch(): + from lang2sql.core.ports.explorer import DataAccessError + + class DeniedExplorer(Explorer): + async def execute(self, sql, limit=1000): + self.calls.append(sql) + raise DataAccessError("ORA-00942: missing or unauthorized") + + class Model: + async def complete(self, messages, tools=()): + return Completion( + tool_calls=[ + ToolCall("denied", "run_sql", {"sql": "SELECT * FROM salaries"}), + ToolCall( + "fallback", "run_sql", {"sql": "SELECT * FROM other_salaries"} + ), + ] + ) + + async def run(): + explorer = DeniedExplorer() + concierge = ContextConcierge(llm=Model(), explorer=explorer) + ctx = await concierge.build_context(Identity(user_id="sales")) + answer = await agent_loop(ctx, "급여 조회") + assert "권한이 없거나" in answer + assert len(explorer.calls) == 1 + tools = [m for m in ctx.session.history() if m.role == Role.TOOL] + assert [m.tool_call_id for m in tools] == ["denied", "fallback"] + assert "Not executed" in tools[-1].content + assert (await concierge.store.query("sales"))[0].action == "run_sql_failed" + concierge.store.close() + + asyncio.run(run()) + + +@pytest.mark.parametrize("code,translated", [(942, True), (1031, True), (904, False)]) +def test_oracle_access_errors_are_distinct_from_sql_errors(code, translated): + from types import SimpleNamespace + from unittest.mock import MagicMock + from sqlalchemy.exc import DatabaseError + from lang2sql.adapters.db.sqlalchemy_explorer import SqlAlchemyExplorer + from lang2sql.core.ports.explorer import DataAccessError + + explorer = SqlAlchemyExplorer( + "oracle+oracledb://u:p@localhost/?service_name=FREEPDB1" + ) + engine = MagicMock() + engine.connect.return_value.__enter__.return_value.execute.side_effect = ( + DatabaseError( + "SELECT x FROM t", + {}, + Exception(SimpleNamespace(code=code)), + ) + ) + explorer._engine = engine + with pytest.raises(DataAccessError if translated else DatabaseError): + asyncio.run(explorer.execute("SELECT x FROM t")) diff --git a/tests/test_setup_wizard.py b/tests/test_setup_wizard.py index f9a7f08..3053e4c 100644 --- a/tests/test_setup_wizard.py +++ b/tests/test_setup_wizard.py @@ -84,7 +84,7 @@ def test_assemble_missing_required_field_raises(): def test_assemble_unknown_db_type_raises(): with pytest.raises(ValueError, match="unsupported"): - assemble("oracle", {}) + assemble("unsupported-db", {}) # --- register_db_for_guild end-to-end (real sqlite) ---------------------- diff --git a/uv.lock b/uv.lock index 4e26d02..8040f7c 100644 --- a/uv.lock +++ b/uv.lock @@ -1000,6 +1000,7 @@ dependencies = [ [package.optional-dependencies] all-db = [ { name = "duckdb-engine" }, + { name = "oracledb" }, { name = "psycopg", extra = ["binary"] }, { name = "pymysql" }, { name = "snowflake-sqlalchemy" }, @@ -1014,6 +1015,9 @@ duckdb = [ mysql = [ { name = "pymysql" }, ] +oracle = [ + { name = "oracledb" }, +] postgres = [ { name = "psycopg", extra = ["binary"] }, ] @@ -1034,6 +1038,8 @@ requires-dist = [ { name = "discord-py", specifier = ">=2.3,<3.0" }, { name = "duckdb-engine", marker = "extra == 'all-db'", specifier = ">=0.13" }, { name = "duckdb-engine", marker = "extra == 'duckdb'", specifier = ">=0.13" }, + { name = "oracledb", marker = "extra == 'all-db'", specifier = ">=2.0,<4.0" }, + { name = "oracledb", marker = "extra == 'oracle'", specifier = ">=2.0,<4.0" }, { name = "psycopg", extras = ["binary"], marker = "extra == 'all-db'", specifier = ">=3.2,<4.0" }, { name = "psycopg", extras = ["binary"], marker = "extra == 'postgres'", specifier = ">=3.2,<4.0" }, { name = "pymysql", marker = "extra == 'all-db'", specifier = ">=1.1" }, @@ -1045,7 +1051,7 @@ requires-dist = [ { name = "sqlalchemy-bigquery", marker = "extra == 'all-db'", specifier = ">=1.11" }, { name = "sqlalchemy-bigquery", marker = "extra == 'bigquery'", specifier = ">=1.11" }, ] -provides-extras = ["postgres", "bigquery", "snowflake", "mysql", "duckdb", "all-db"] +provides-extras = ["postgres", "bigquery", "snowflake", "mysql", "duckdb", "oracle", "all-db"] [package.metadata.requires-dev] dev = [ @@ -1312,6 +1318,43 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, ] +[[package]] +name = "oracledb" +version = "3.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f7/02/70a872d1a4a739b4f7371ab8d3d5ed8c6e57e142e2503531aafcb220893c/oracledb-3.4.2.tar.gz", hash = "sha256:46e0f2278ff1fe83fbc33a3b93c72d429323ec7eed47bc9484e217776cd437e5", size = 855467, upload-time = "2026-01-28T17:25:39.91Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/5d/b8a0ca1c520fa43ae33260f6f8ca9bd468ade43da7986029bc214965df12/oracledb-3.4.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ff3c89cecea62af8ca02aa33cab0f2edc0214c747eac7d3364ed6b2640cb55e4", size = 4243966, upload-time = "2026-01-28T17:25:45.05Z" }, + { url = "https://files.pythonhosted.org/packages/f6/43/26e2bbb2a6ee31392a339089e53cb2e386ca795ff4fbe2f673c167821bd6/oracledb-3.4.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e068ef844a327877bfefbef1bc6fb7284c727bb87af80095f08d95bcaf7b8bb2", size = 2426056, upload-time = "2026-01-28T17:25:47.176Z" }, + { url = "https://files.pythonhosted.org/packages/09/ba/11ee1d044295465a04ff45c6e3023d35400bb3f67bc5fed9408f0f2dc04c/oracledb-3.4.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9f434a739405557bd57cb39b62238142bb27855a524a70dc6d397a2a8c576c9d", size = 2603062, upload-time = "2026-01-28T17:25:49.817Z" }, + { url = "https://files.pythonhosted.org/packages/c5/bc/292f2f5f7b65a667787871e300889ab8f4a3b9cfd88c5d78f828a40f6d31/oracledb-3.4.2-cp310-cp310-win32.whl", hash = "sha256:00c79448017f367bb7ab6900efe0706658a53768abea2b4519a4c9b2d5743890", size = 1496639, upload-time = "2026-01-28T17:25:51.298Z" }, + { url = "https://files.pythonhosted.org/packages/21/23/81931c16663e771937c0161bb90460668d2a5f7982b5030ab7bef3b3a4f9/oracledb-3.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:574c8280d49cbbe21dbe03fc28356d9b9a5b9e300ebcde6c6d106e51453a7e65", size = 1837314, upload-time = "2026-01-28T17:25:52.718Z" }, + { url = "https://files.pythonhosted.org/packages/64/80/be263b668ba32b258d07c85f7bfb6967a9677e016c299207b28734f04c4b/oracledb-3.4.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b8e4b8a852251cef09038b75f30fce1227010835f4e19cfbd436027acba2697c", size = 4228552, upload-time = "2026-01-28T17:25:54.844Z" }, + { url = "https://files.pythonhosted.org/packages/91/bc/e832a649529da7c60409a81be41f3213b4c7ffda4fe424222b2145e8d43c/oracledb-3.4.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1617a1db020346883455af005efbefd51be2c4d797e43b1b38455a19f8526b48", size = 2421924, upload-time = "2026-01-28T17:25:56.984Z" }, + { url = "https://files.pythonhosted.org/packages/86/21/d867c37e493a63b5521bd248110ad5b97b18253d64a30703e3e8f3d9631e/oracledb-3.4.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed78d7e7079a778062744ccf42141ce4806818c3f4dd6463e4a7edd561c9f86", size = 2599301, upload-time = "2026-01-28T17:25:58.529Z" }, + { url = "https://files.pythonhosted.org/packages/2a/de/9b1843ea27f7791449652d7f340f042c3053336d2c11caf29e59bab86189/oracledb-3.4.2-cp311-cp311-win32.whl", hash = "sha256:0e16fe3d057e0c41a23ad2ae95bfa002401690773376d476be608f79ac74bf05", size = 1492890, upload-time = "2026-01-28T17:26:00.662Z" }, + { url = "https://files.pythonhosted.org/packages/d6/10/cbc8afa2db0cec80530858d3e4574f9734fae8c0b7f1df261398aa026c5f/oracledb-3.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:f93cae08e8ed20f2d5b777a8602a71f9418389c661d2c937e84d94863e7e7011", size = 1843355, upload-time = "2026-01-28T17:26:02.637Z" }, + { url = "https://files.pythonhosted.org/packages/8f/81/2e6154f34b71cd93b4946c73ea13b69d54b8d45a5f6bbffe271793240d21/oracledb-3.4.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a7396664e592881225ba66385ee83ce339d864f39003d6e4ca31a894a7e7c552", size = 4220806, upload-time = "2026-01-28T17:26:04.322Z" }, + { url = "https://files.pythonhosted.org/packages/ab/a9/a1d59aaac77d8f727156ec6a3b03399917c90b7da4f02d057f92e5601f56/oracledb-3.4.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f04a2d62073407672f114d02529921de0677c6883ed7c64d8d1a3c04caa3238", size = 2233795, upload-time = "2026-01-28T17:26:05.877Z" }, + { url = "https://files.pythonhosted.org/packages/94/ec/8c4a38020cd251572bd406ddcbde98ca052ec94b5684f9aa9ef1ddfcc68c/oracledb-3.4.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d8d75e4f879b908be66cce05ba6c05791a5dbb4a15e39abc01aa25c8a2492bd9", size = 2424756, upload-time = "2026-01-28T17:26:07.35Z" }, + { url = "https://files.pythonhosted.org/packages/fa/7d/c251c2a8567151ccfcfbe3467ea9a60fb5480dc4719342e2e6b7a9679e5d/oracledb-3.4.2-cp312-cp312-win32.whl", hash = "sha256:31b7ee83c23d0439778303de8a675717f805f7e8edb5556d48c4d8343bcf14f5", size = 1453486, upload-time = "2026-01-28T17:26:08.869Z" }, + { url = "https://files.pythonhosted.org/packages/4c/78/c939f3c16fb39400c4734d5a3340db5659ba4e9dce23032d7b33ccfd3fe5/oracledb-3.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:ac25a0448fc830fb7029ad50cd136cdbfcd06975d53967e269772cc5cb8c203a", size = 1794445, upload-time = "2026-01-28T17:26:10.66Z" }, + { url = "https://files.pythonhosted.org/packages/22/68/f7126f5d911c295b57720c6b1a0609a5a2667b4546946433552a4de46333/oracledb-3.4.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:643c25d301a289a371e37fcedb59e5fa5e54fb321708e5c12821c4b55bdd8a4d", size = 4205176, upload-time = "2026-01-28T17:26:12.463Z" }, + { url = "https://files.pythonhosted.org/packages/5d/93/2fced60f92dc82e66980a8a3ba5c1ea48110bf1dd81d030edb69d88f992e/oracledb-3.4.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55397e7eb43bb7017c03a981c736c25724182f5210951181dfe3fab0e5d457fb", size = 2231298, upload-time = "2026-01-28T17:26:14.497Z" }, + { url = "https://files.pythonhosted.org/packages/75/a7/4dd286f3a6348d786fef9e6ab2e6c9b74ca9195d9a756f2a67e45743cdf0/oracledb-3.4.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b26a10f9c790bd141ffc8af68520803ed4a44a9258bf7d1eea9bfdd36bd6df7f", size = 2439430, upload-time = "2026-01-28T17:26:16.044Z" }, + { url = "https://files.pythonhosted.org/packages/19/28/94bc753e5e969c60ee5d9c914e2b4ef79999eaca8e91bcab2fbf0586b80b/oracledb-3.4.2-cp313-cp313-win32.whl", hash = "sha256:b974caec2c330c22bbe765705a5ac7d98ec3022811dec2042d561a3c65cb991b", size = 1458209, upload-time = "2026-01-28T17:26:17.652Z" }, + { url = "https://files.pythonhosted.org/packages/cb/2b/593a9b2d4c12c9de3289e67d84fe023336d99f36ba51442a5a0f5ce6acf7/oracledb-3.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:3df8eee1410d25360599968b1625b000f10c5ae0e47274031a7842a9dc418890", size = 1793558, upload-time = "2026-01-28T17:26:19.914Z" }, + { url = "https://files.pythonhosted.org/packages/42/20/1e98f84c1555911c46b4fa870fbef2a80617bf7e0a5f178078ecf466c917/oracledb-3.4.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:59ad6438f56a25e8e1a4a3dd1b42235a5d09ab9ba417ff2ad14eae6596f3d06f", size = 4247459, upload-time = "2026-01-28T17:26:22.356Z" }, + { url = "https://files.pythonhosted.org/packages/7d/74/95963e2d94f84b9937a562a9a2529f72d050afbc2ffd88f6661e3a876f7d/oracledb-3.4.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:404ec1451d0448653ee074213b87d6c5bd65eaa74b50083ddf2c9c3e11c71c71", size = 2271749, upload-time = "2026-01-28T17:26:24.078Z" }, + { url = "https://files.pythonhosted.org/packages/82/89/38ce85148a246087795379ee52c5b20726a00a69c87ba6ec266bcdad30fc/oracledb-3.4.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:19fa80ef84f85ad74077aa626067bbe697e527bd39604b4209f9d86cb2876b89", size = 2452031, upload-time = "2026-01-28T17:26:26.08Z" }, + { url = "https://files.pythonhosted.org/packages/3f/8d/51fe907fdec0267ad7c6e9a62998cbe878efcd168ea6e39f162fab62fdaa/oracledb-3.4.2-cp314-cp314-win32.whl", hash = "sha256:d7ce75c498bff758548ec6e4424ab4271aa257e5887cc436a54bc947fd46199a", size = 1480973, upload-time = "2026-01-28T17:26:27.584Z" }, + { url = "https://files.pythonhosted.org/packages/48/22/a37354f19786774e5e4041338043b516db060aacfdfcd5aca8bb92c2539a/oracledb-3.4.2-cp314-cp314-win_amd64.whl", hash = "sha256:5d7befb014174c5ae11c3a08f5ed6668a25ab2335d8e7104dca70d54d54a5b3a", size = 1837756, upload-time = "2026-01-28T17:26:29.032Z" }, +] + [[package]] name = "packaging" version = "24.2"