Oracle PL/SQL, parsed the way it is actually written.

PL/SQL does not call SQL. It embeds SQL as a first-class statement form — and the two halves disagree about almost everything. That disagreement is the whole difficulty of the language, and it is what a single-namespace SQL parser cannot represent.

-- installation script, not a clean unit source
prompt installing hr_util
CREATE OR REPLACE PACKAGE BODY hr_util AS
  FUNCTION chain(p_root IN employees.employee_id%TYPE)
    RETURN emp_tab PIPELINED IS
    l_msg VARCHAR2(200) := q'{can't walk the tree}';
  BEGIN
    FOR r IN (SELECT e.* FROM employees e
                START WITH e.employee_id = p_root
              CONNECT BY PRIOR e.employee_id = e.manager_id)
    LOOP
      PIPE ROW (r);
    END LOOP;
  EXCEPTION
    WHEN NO_DATA_FOUND THEN
      RAISE_APPLICATION_ERROR(-20101, l_msg);
  END chain;
END hr_util;
/
SHOW ERRORS

plsql_script
├── sql_plus_command PROMPT_MESSAGE, line 2
├── unit_statement
│   └── package_body hr_util, line 3
│       └── create_function chain, PIPELINED
│           ├── plsql_parameter p_root IN … %TYPE
│           ├── ⋯
│           │   └── connect_by line 9
│           └── exception_handler WHEN NO_DATA_FOUND
├── sql_plus_command SOLIDUS — end of unit, line 19
└── sql_plus_command SHOW ERRORS, line 20

Four constructs decide whether a PL/SQL parser survives contact with a real Oracle estate. Each one is a place where the lexer, not the parser, has to make the decision — which is why generic SQL grammars fail them.

l_msg := q'{can't walk the tree}';
l_ddl := q'[ALTER TABLE emp ADD (x NUMBER)]';
l_utf := nq'#il n'y a qu'un#';

  END chain;
END hr_util;
/  -- ends the unit, not the statement
SHOW ERRORS

  v_row  employees%ROWTYPE;
  v_id   employees.employee_id%TYPE;
  TYPE emp_tab IS TABLE OF employees%ROWTYPE
    INDEX BY PLS_INTEGER;

SELECT LEVEL, SYS_CONNECT_BY_PATH(last_name, '/')
  FROM employees
 START WITH manager_id IS NULL
CONNECT BY PRIOR employee_id = manager_id;

Two more belong on the same list. Conditional compilation — $IF … $THEN … $ELSE … $END and $$name inquiry directives — is a preprocessor handled inside the grammar, so the directives survive into the tree instead of being stripped before anyone can analyze them. And the MODEL clause is a spreadsheet-style calculation language nested inside a SELECT, with its own PARTITION BY, DIMENSION BY and MEASURES.

Coverage, by construct

On versions, we would rather be exact than impressive. The grammar’s lineage is the antlr/grammars-v4 Oracle PL/SQL 11g grammar; our extensions go well past it — flashback queries, MODEL, PIVOT, materialized views and blockchain tables (a 21c feature) are all in the grammar and in the shipped example corpus. We do not publish a certified “Oracle X through Y” range, because the number would not answer your question. Send us a representative set of your own sources and we will tell you what parses.

We license five SQL-family engines. This file parses with exactly one of them, and it is a fair sample of what an Oracle estate looks like from the inside.

PROMPT installing hr_util
CREATE OR REPLACE PACKAGE hr_util AUTHID CURRENT_USER AS
    TYPE emp_tab IS TABLE OF employees%ROWTYPE INDEX BY PLS_INTEGER;
    bad_grade EXCEPTION;
    PRAGMA EXCEPTION_INIT(bad_grade, -20101);
    FUNCTION chain(p_root IN employees.employee_id%TYPE)
      RETURN emp_tab PIPELINED;
END hr_util;
/
CREATE OR REPLACE PACKAGE BODY hr_util AS
    FUNCTION chain(p_root IN employees.employee_id%TYPE)
      RETURN emp_tab PIPELINED IS
        l_msg VARCHAR2(200) := q'{can't walk the tree}';
    BEGIN
        FOR r IN (SELECT e.* FROM employees e
                    START WITH e.employee_id = p_root
                  CONNECT BY PRIOR e.employee_id = e.manager_id)
        LOOP
            PIPE ROW (r);
        END LOOP;
    EXCEPTION
        WHEN NO_DATA_FOUND THEN RAISE_APPLICATION_ERROR(-20101, l_msg);
    END chain;
END hr_util;
/

A jar, the documents that explain the tree it produces, and a person to write to. The engine runs inside your own network, on your own machines, with no connection back to us and none to the database the code came from.

Five kinds of work, in the order customers usually reach them. The first three need only the parser; the last two are the reason the code generator exists.

A technical buyer already knows there is a free PL/SQL grammar, and we are not going to pretend otherwise: ours started as that grammar. The file header still credits Alexandre Porcelli, Ivan Kochurkin and Mark Adams, and the upstream project stays Apache 2.0. What a license buys is everything downstream of the parse tree — which is where all the work is.

The same reasoning applies to every engine in the family, and the method behind it has a name: read the Chisel Method for how we make parser work estimable, or Parsers and transpilers for the three ways into this work.

Five things we would rather tell you now than have you find in week three.