DotGram.Sql 0.2.0

• .NETStandard 2.0

  • System.Memory (>= 4.6.3)

• net10.0

  • No dependencies.

Every method that was here before still reads what it read: what moved is what the grammars read, the tree of the standard, which grows toward T-SQL, and there is one more way to ask. One public type built by SqlStandardParser's own GRANT and REVOKE (the standard's, not T-SQL's, which build their own Statement.Grant/Deny/Revoke unchanged) changes shape: PrivilegeObject was a single record with a nullable Class beside the standard's Kind; it is now a family of two (below), so code that constructed or pattern-matched the old PrivilegeObject needs PrivilegeObject.Named or PrivilegeObject.Classed instead.

The standard's tree (DotGram.Sql.Ast) gains values it will need to hold T-SQL as well: operators (Modulo, the bitwise and shift operators, BitwiseNot, NotLess and NotGreater for !< and !>), Bracketed identifiers, a Money literal, CROSS and OUTER APPLY and a join hint, the Snapshot isolation level, three flags on a parameter definition, a table type, and two spellings kept as flags so that the text writes back: Exclamation for != and Max for a length of MAX. A new optional property shows up in a record's printed form. Sql2023Writer prints every one of them, and a value it has no text for is now an ArgumentOutOfRangeException naming the enum and the value, where before it printed some other operator. It also carries the first of T-SQL’s own nodes, which no parser builds yet: the parts a statement is made of — TOP, INTO, OUTPUT, FOR XML and FOR JSON, table and query hints, the generic WITH option, an execution context — the SET options as one family instead of five, and ALTER DATABASE’s thirteen actions with the files and filegroups they take. The DROP statements are one record and a kind for the forty-six whose syntax is only the words and a name, with eleven pages that publish more keeping a record of their own. Sql2023Writer now refuses an unknown enum value in all three of its files rather than in one, and it keeps DROP PROC apart from DROP PROCEDURE. T-SQL's cursors and transactions follow: the words the extended DECLARE CURSOR writes after CURSOR are properties on CursorProperties — its scope, its kind, its concurrency, TYPE_WARNING, and FORWARD_ONLY kept as a spelling of NO SCROLL rather than a meaning of its own — DEALLOCATE, SET @c = CURSOR, BEGIN TRANSACTION and SAVE TRANSACTION are statements, and COMMIT and ROLLBACK gain the word that was written where the page makes it optional, as one nullable enum rather than a pair of flags that could say TRAN with no keyword, together with the transaction they may name and delayed durability. A ROLLBACK holding both a transaction name and TO SAVEPOINT has no text that keeps them both, so the writer refuses it rather than dropping one. The permission statements follow: DENY is a statement of its own beside GRANT and REVOKE, whose ON clause may now be left out; PrivilegeKind gains every permission SQL Server publishes, 160 members named for their words (ViewDefinition, AlterAnyDatabase) after the standard's ten, generated from the parser's own permission catalogue; a new SecurableClass is the class of ON SCHEMA::s, and PrivilegeObject is now a family of two, Named for the standard's forms and ON t, Classed for ON SCHEMA::s; ALL and EXEC are kept as Privilege.Abbreviated, spellings of ALL PRIVILEGES and EXECUTE; and NULL among the principals is Grantee.Null.

Every publication now has a third method, bool TryParseX(string input, out T value), beside ParseX and the Match<T> form. It answers only whether the text reads, says nothing about what was expected where it does not, and a refusal costs it about half, since nothing is read a second time to record the message.

SqlStandardParser reads the standard through a lexical split, which bounds two things the ISO grammar leaves unbounded: a comment holds others six deep, and a /* inside a comment always opens one. It now reads what it used to refuse — a datetime less a datetime in brackets before an interval qualifier, a JSON behaviour and its ON clause, and the JSON and period forms of a WHEN operand — and refuses what it used to take, where an operand would swallow a reading that fits the text better. Sql92Parser follows it where the two share a production.

The package ships its XML documentation now, though not for every type yet: the tree that is being replaced carries none, and each node of the one replacing it says what it is and which page of the specification it comes from. What each node is named after is also in docs/ast.md, and how to use the parsers is in the README and the SKILL beside it.

TransactSqlParser leaves a statement's label to that statement: HIDDEN, SORTED_DATA and a login's password words no longer take the label on the line after them. A native module's atomic block is now followed by the end of the batch, said as such, rather than by a refusal naming no statement.

It also refuses two things in GRANT, DENY and REVOKE that it used to read, both because SQL Server refuses them as syntax. A securable's class is one of the twenty-eight the engine takes, so `ON FOO::x` no longer reads, and neither do `ON TABLE::x`, `ON VIEW::x` or `ON PROCEDURE::x`, all of which are `ON OBJECT::x`. And a permission has to be one that class allows: `GRANT SELECT ON ENDPOINT::x` is refused, as the server refuses it, while `GRANT SELECT ON t` is read. Where no ON clause names a class nothing is checked, because the server does not check it while parsing either. The refusal is reported at the token after the securable rather than at the permission the server names. A principal is one part now wherever GRANT, DENY, REVOKE, a role's ADD/DROP MEMBER or WITH NAME, an ALTER AUTHORIZATION or a login's ADD/DROP CREDENTIAL name one, and every inline AUTHORIZATION clause besides — `TO a.b` and `TO dbo.guest` are refused, matching the engine, which reads only a bracketed or quoted one-part name there; a securable's own name, such as `OBJECT::dbo.t`, is unaffected and still reads dotted. Fixed, and present since 0.1.0: TransactSqlParser could throw IndexOutOfRangeException on a statement it refuses, such as a condition that is a value (SELECT * FROM t WHERE c = 1 AND dbo.f(1)), mostly on the first parse on a thread and occasionally on one that had read only smaller statements; and TransactSqlParser.Located threw NullReferenceException on such a statement (SELECT 1 WHERE 1 = 1 AND N) on any thread. Where nothing was thrown the statement was refused, as it should be. No accepted statement was found to reach it.

Fixed: SqlStandardParser and TransactSqlParser.Located could throw IndexOutOfRangeException or NullReferenceException, instead of refusing, on some input ending in a bracketed operand followed by a dangling operator or an incomplete clause — `SELECT (a) +` and an unfinished `CREATE ENDPOINT e AS TCP (LISTENER_PORT = 1,` among them; no accepted statement was found to reach it. A bare CAST, TRY_CAST, PARSE or TRY_PARSE — one SQL Server itself refuses as an ordinary function call — is now read only as its cast and no longer tried again as a call, which also made an unclosed nest of `CAST(` cost linear time instead of exponential; a qualified name (`dbo.PARSE (1)`) still reads as a call. A predicate's row — which a CASE expression is, at every level it nests — is now read once instead of being read again for IS [NOT] DISTINCT FROM, which made a nest of CASE expressions linear instead of exponential too, whether refused unclosed or accepted with IS DISTINCT FROM at every level.