Sure, PRs are most welcome !

As a starting point, you can take a look to the A section in the contributing.md file of pg-mem repo (nb: implementing the parser part does not require implementing the statement in pg-mem, dont worry)

The hard part is understanding Nearley, but it is not very hard.

For some inspiration, you can have a look at #74 by @janpaepke which implements a simple statement (same level of complexity as SET TRANSACTION)

If you have questions, feel free to ask !

I'll add this feature anyway when I have some time if you dont, but I cant say when :)

Did someone say ne..ne..nearley? 🤪

What would you expect the resulting AST to look like?

😄

My two cents: If implementing the whole documentation linked, there must be two statements.

The SET TRANSACTION SNAPSHOT one should be pretty straightfoward... something like this should do:

export interface SetTransactionSnapshot extends PGNode {
    type: 'set transaction snapshot';
    snapshotId: string;
}

As for the second one (which covers both SET TRANSACTION and SET SESSION CHARACTERISTICS AS TRANSACTION), something like that seems to cover all the cases and should not be too hard to fit to Nearley:

export interface SetTransactionMode extends PGNode {
    type: 'set transaction' | 'set session characteristics as transaction';
    mode: TransactionMode[];
}

export type TransactionMode = TransactionModeIsolationLevel  |  TransactionModeAccess | TransactionModeDeferability;

export interface TransactionModeIsolationLevel extends PGNode {
   type: 'isolation level';
   level: 'serializable' | 'repeatable read' | 'read committed' | 'read uncommitted';
}

export interface TransactionModeAccess extends PGNode {
   type: 'write mode';
   readWrite: boolean;
}

export interface TransactionModeDeferability extends PGNode {
   type: 'deferability';
   deferable: boolean;
}

nb: if you havent seen its usage elsewhere, to implement the 'serializable' | 'repeatable read' | 'read committed' | 'read uncommitted' part in Nearley, the toStr(matchedStatement).toLowerCase() utility should be quite useful to convert a big a | b | c nearley statement directly in the right string.