pythia-plsql 0.11.0__tar.gz → 0.11.1__tar.gz

{pythia_plsql-0.11.0/scripts/pythia_plsql.egg-info → pythia_plsql-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythia-plsql
-Version: 0.11.0
+Version: 0.11.1
 Summary: PL/SQL development for AI agents on Oracle Database - expert data-dictionary queries, impact analysis, and a snapshot-verified write path with honest rollback.
 License: MIT
 Project-URL: Homepage, https://github.com/thaildhe172591/pythia

{pythia_plsql-0.11.0 → pythia_plsql-0.11.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythia-plsql"
-version = "0.11.0"
+version = "0.11.1"
 description = "PL/SQL development for AI agents on Oracle Database - expert data-dictionary queries, impact analysis, and a snapshot-verified write path with honest rollback."
 readme = "README.md"
 license = { text = "MIT" }

{pythia_plsql-0.11.0 → pythia_plsql-0.11.1}/scripts/pythia.py

@@ -713,7 +713,12 @@ def plscope_message(name, has_any_data):
 GROUPS = ("plsql_source", "data_dml", "structural", "grants", "session")
 
 PLSQL_SOURCE_RE = re.compile(
-    r"^create\s+(?:or\s+replace\s+)?(?:(?:no)?editionable\s+|(?:no)?force\s+)*"
+    # NONEDITIONABLE, not "noeditionable": Oracle's keyword has the middle N,
+    # and missing it dropped every NONEDITIONABLE object into structural —
+    # deny by default, and counted by semicolons, so a PL/SQL body read as
+    # "more than one statement". Both spellings are accepted here; only the
+    # database decides whether the statement is valid.
+    r"^create\s+(?:or\s+replace\s+)?(?:(?:non?)?editionable\s+|(?:no)?force\s+)*"
     r"(procedure|function|package\s+body|package|trigger|view|type\s+body|type)\b",
     re.I | re.S)
 
@@ -1231,12 +1236,29 @@ def prune_expired_grants(root, now=None):
     return gone
 
 
-def render_restore(obj_type, name, before_text):
+EDITIONABLE_KW_RE = re.compile(
+    r"^create\s+(?:or\s+replace\s+)?((?:non?)?editionable)\b", re.I)
+
+
+def create_prefix(after_text):
+    """The CREATE header ALL_SOURCE does not store, rebuilt for the version
+    held in the database. The editionable keyword is read off the file being
+    applied, because the database's own answer is not in ALL_SOURCE and
+    Oracle refuses to *change* the property through CREATE OR REPLACE
+    (ORA-38824) — so a file that applies cleanly already spells the property
+    the object has. Getting this wrong costs twice: a restore that fails
+    exactly when it is needed, and a phantom line in the diff the developer
+    approves."""
+    m = EDITIONABLE_KW_RE.match(skip_leading_noise(after_text))
+    return "CREATE OR REPLACE " + (f"{m.group(1).upper()} " if m else "")
+
+
+def render_restore(obj_type, name, before_text, after_text=""):
     """The statement that puts things back. For an object that did not exist,
     undo means DROP — a genuinely different promise than restoring source, so
     the caller records created=True and the report says it plainly."""
     if before_text.strip():
-        return "CREATE OR REPLACE " + before_text.rstrip() + "\n"
+        return create_prefix(after_text) + before_text.rstrip() + "\n"
     return f"DROP {obj_type} {name}\n"
 
 
@@ -1256,7 +1278,7 @@ def write_journal_entry(root, obj_type, name, before, after, meta, now=None):
     d.mkdir(parents=True)
     (d / "before.sql").write_text(before, encoding="utf-8")
     (d / "after.sql").write_text(after, encoding="utf-8")
-    (d / "restore.sql").write_text(render_restore(obj_type, name, before),
+    (d / "restore.sql").write_text(render_restore(obj_type, name, before, after),
                                    encoding="utf-8")
     full = {"object": name, "type": obj_type, "created": not before.strip(),
             "entry": eid, **meta}
@@ -2105,8 +2127,10 @@ def run_apply(conn, schema, ns, file_text, origin=None):
 
     # 3. PREVIEW — diff like against like: ALL_SOURCE never stores the
     # CREATE OR REPLACE header, so prepend it before comparing, or an
-    # unchanged object would show a phantom two-line change forever.
-    base = ("CREATE OR REPLACE " + db_source) if db_source.strip() else ""
+    # unchanged object would show a phantom two-line change forever. The
+    # editionable keyword is part of that header, or a NONEDITIONABLE file
+    # shows its own first line as a change that is not one.
+    base = (create_prefix(stmt) + db_source) if db_source.strip() else ""
     diff_text, changed = render_diff(base, stmt)
     warn = privilege_warning(conn, schema, ns.conn_user)
     style = (naming_violation(otype, name, load_conventions(ns.project_root))

{pythia_plsql-0.11.0 → pythia_plsql-0.11.1/scripts/pythia_plsql.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythia-plsql
-Version: 0.11.0
+Version: 0.11.1
 Summary: PL/SQL development for AI agents on Oracle Database - expert data-dictionary queries, impact analysis, and a snapshot-verified write path with honest rollback.
 License: MIT
 Project-URL: Homepage, https://github.com/thaildhe172591/pythia

{pythia_plsql-0.11.0 → pythia_plsql-0.11.1}/tests/test_phase3.py

@@ -32,6 +32,11 @@ def test_classify_groups():
     assert c("alter table t_order add (x number)") == "structural"  # session tested first
     assert c("CREATE OR REPLACE PROCEDURE p AS BEGIN NULL; END;") == "plsql_source"
     assert c("create or replace editionable package body pkg_order as end;") == "plsql_source"
+    # Oracle's keyword is NONEDITIONABLE, with the middle N. Missing it sent
+    # every such object to structural — deny by default, and counted by
+    # semicolons, so a PL/SQL body came back as "more than one statement".
+    assert c("create or replace NONEDITIONABLE procedure p as begin null; end;") == "plsql_source"
+    assert c("CREATE OR REPLACE NONEDITIONABLE PACKAGE BODY pkg AS END;") == "plsql_source"
     assert c("CREATE OR REPLACE FORCE VIEW v AS SELECT 1 FROM dual") == "plsql_source"
     assert c("CREATE TABLE t (x number)") == "structural"  # other CREATE
     assert c("insert into t values (1)") == "data_dml"
@@ -54,6 +59,27 @@ def test_parse_object():
     assert (t, n, s) == ("TYPE BODY", "T_THING", None)
     t, n, s = pythia.parse_object("CREATE OR REPLACE TRIGGER trg_x BEFORE INSERT ON t BEGIN NULL; END;")
     assert (t, n, s) == ("TRIGGER", "TRG_X", None)
+    # the identity drives the snapshot, so the editionable keyword must not
+    # shift what is parsed out of the statement
+    t, n, s = pythia.parse_object(
+        "CREATE OR REPLACE NONEDITIONABLE PROCEDURE core_bh.pbh_file_nh AS BEGIN NULL; END;")
+    assert (t, n, s) == ("PROCEDURE", "PBH_FILE_NH", "CORE_BH")
+
+
+def test_restore_keeps_the_editionable_property():
+    """ALL_SOURCE holds no CREATE prefix, so the restore builds one. On an
+    editions-enabled schema a bare CREATE OR REPLACE over a NONEDITIONABLE
+    object is ORA-38824 — an undo that fails exactly when it is needed."""
+    body = "PROCEDURE p AS BEGIN NULL; END;"
+    assert pythia.render_restore("PROCEDURE", "P", body, "CREATE OR REPLACE " + body) \
+        == "CREATE OR REPLACE " + body + "\n"
+    assert pythia.render_restore(
+        "PROCEDURE", "P", body,
+        "create or replace noneditionable procedure p as begin null; end;") \
+        == "CREATE OR REPLACE NONEDITIONABLE " + body + "\n"
+    # a new object still has no source to put back: undo is a DROP
+    assert pythia.render_restore("PROCEDURE", "P", "", "CREATE OR REPLACE NONEDITIONABLE PROCEDURE p") \
+        == "DROP PROCEDURE P\n"
 
 
 def test_prepare_statement_terminators():
@@ -1475,6 +1501,38 @@ def test_apply_reads_a_bom_file_as_the_statement_it_is():
         assert "approve --card" in buf.getvalue()      # it previewed
 
 
+def test_apply_previews_a_noneditionable_object_end_to_end():
+    """The reported bug, from the outside: NONEDITIONABLE missed the
+    classifier, fell through to structural — which counts statements by
+    semicolon — and a PL/SQL body came back as 'more than one statement'.
+    The only escape was dropping the keyword, which Oracle then met with
+    ORA-38824. Preview must produce a token, and the restore must keep the
+    property."""
+    import contextlib
+    import io
+    import pathlib
+    src = ("CREATE OR REPLACE NONEDITIONABLE PACKAGE BODY pkg_order AS\n"
+           "  new line;\nEND;\n/\n")
+    with tempfile.TemporaryDirectory() as td:
+        f = pathlib.Path(td) / "f.sql"
+        f.write_text(src, encoding="utf-8")
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            pythia.cmd_apply(FakeConn(base_script()), "APP",
+                             apply_ns(td, file=str(f)))
+        out = buf.getvalue()
+        assert "more than one statement" not in out
+        assert "approve --card" in out                  # it previewed
+        entry = pythia.list_journal_entries(td)[0]
+        restore = (pythia.journal_root(td) / entry / "restore.sql").read_text(
+            encoding="utf-8")
+        assert restore.startswith("CREATE OR REPLACE NONEDITIONABLE ")
+        # and the keyword is not shown as a change it is not: ALL_SOURCE holds
+        # no header, so the diff's base has to carry the same one
+        assert "-CREATE OR REPLACE" not in out and "+CREATE OR REPLACE" not in out
+        assert "2 lines changed" in out          # the body line, not the header
+
+
 def test_apply_refuses_when_the_session_schema_is_not_the_configured_one():
     """A proxy into another user, or a stale `schema` in connections.json:
     an unqualified CREATE would land in one schema while pythia snapshots