pgsql-deparser 13.5.0 → 13.6.1

package/module/deparser.js

@@ -2,18 +2,20 @@ import { format } from 'util';
 import { objtypeName, getConstraintFromConstrType } from 'pgsql-enums';
 let TAB_CHAR = '\t';
 let NEWLINE_CHAR = '\n';
+
 const isEmptyObject = obj => {
   return !obj || typeof obj === 'object' && !Object.keys(obj).length;
 };
+
 const dotty = require('dotty');
+
 const fail = (type, node) => {
   throw new Error(format('Unhandled %s node: %s', type, JSON.stringify(node)));
-};
+}; // select word from pg_get_keywords() where catcode = 'R';
 
-// select word from pg_get_keywords() where catcode = 'R';
-const RESERVED_WORDS = new Set(['all', 'analyse', 'analyze', 'and', 'any', 'array', 'as', 'asc', 'asymmetric', 'both', 'case', 'cast', 'check', 'collate', 'column', 'constraint', 'create', 'current_catalog', 'current_date', 'current_role', 'current_time', 'current_timestamp', 'current_user', 'default', 'deferrable', 'desc', 'distinct', 'do', 'else', 'end', 'except', 'false', 'fetch', 'for', 'foreign', 'from', 'grant', 'group', 'having', 'in', 'initially', 'intersect', 'into', 'lateral', 'leading', 'limit', 'localtime', 'localtimestamp', 'not', 'null', 'offset', 'on', 'only', 'or', 'order', 'placing', 'primary', 'references', 'returning', 'select', 'session_user', 'some', 'symmetric', 'table', 'then', 'to', 'trailing', 'true', 'union', 'unique', 'user', 'using', 'variadic', 'when', 'where', 'window', 'with']);
 
-// https://github.com/pganalyze/libpg_query/blob/b2790f8140721ff7f047167ecd7d44267b0a3880/src/postgres/include/storage/lockdefs.h
+const RESERVED_WORDS = new Set(['all', 'analyse', 'analyze', 'and', 'any', 'array', 'as', 'asc', 'asymmetric', 'both', 'case', 'cast', 'check', 'collate', 'column', 'constraint', 'create', 'current_catalog', 'current_date', 'current_role', 'current_time', 'current_timestamp', 'current_user', 'default', 'deferrable', 'desc', 'distinct', 'do', 'else', 'end', 'except', 'false', 'fetch', 'for', 'foreign', 'from', 'grant', 'group', 'having', 'in', 'initially', 'intersect', 'into', 'lateral', 'leading', 'limit', 'localtime', 'localtimestamp', 'not', 'null', 'offset', 'on', 'only', 'or', 'order', 'placing', 'primary', 'references', 'returning', 'select', 'session_user', 'some', 'symmetric', 'table', 'then', 'to', 'trailing', 'true', 'union', 'unique', 'user', 'using', 'variadic', 'when', 'where', 'window', 'with']); // https://github.com/pganalyze/libpg_query/blob/b2790f8140721ff7f047167ecd7d44267b0a3880/src/postgres/include/storage/lockdefs.h
+
 const LOCK_MODES = {
   1: 'ACCESS SHARE',
   2: 'ROW SHARE',
@@ -24,20 +26,23 @@ const LOCK_MODES = {
   7: 'EXCLUSIVE',
   8: 'ACCESS EXCLUSIVE'
 };
-const isReserved = value => RESERVED_WORDS.has(value.toLowerCase());
 
-// has uppercase and lowercase, or non word characters
-const needsQuotesRegex = /[a-z]+[\W\w]*[A-Z]+|[A-Z]+[\W\w]*[a-z]+|\W/;
+const isReserved = value => RESERVED_WORDS.has(value.toLowerCase()); // has uppercase and lowercase, or non word characters
+
 
-// usually the AST lowercases all the things, so if we
+const needsQuotesRegex = /[a-z]+[\W\w]*[A-Z]+|[A-Z]+[\W\w]*[a-z]+|\W/; // usually the AST lowercases all the things, so if we
 // have both, the author most likely used double quotes
+
 const needsQuotes = value => needsQuotesRegex.test(value) || isReserved(value);
+
 const compact = o => o.filter(e => {
   const isFalsy = !e;
   return !isFalsy && e.toString().length;
 });
+
 const flatten = o => {
   const flattened = [];
+
   for (let i = 0; i < o.length; i++) {
     if (Array.isArray(o[i])) {
       for (let j = 0; j < o[i].length; j++) {
@@ -47,208 +52,276 @@ const flatten = o => {
       flattened.push(o[i]);
     }
   }
+
   return flattened;
 };
+
 const inverted = o => {
   const objInverted = {};
   const keys = Object.keys(o);
+
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
     objInverted[o[key]] = key;
   }
+
   return objInverted;
 };
+
 const parens = string => {
   return '(' + string + ')';
 };
+
 const indent = (text, count = 1) => text;
+
 const unwrapList = obj => obj !== undefined && obj.List !== undefined ? obj.List.items : obj;
+
 export default class Deparser {
   static deparse(query, opts) {
     return new Deparser(query, opts).deparseQuery();
   }
+
   constructor(tree, opts = {}) {
     this.tree = tree;
+
     if (opts.hasOwnProperty('newline')) {
       NEWLINE_CHAR = opts.newline;
     }
+
     if (opts.hasOwnProperty('tab')) {
       TAB_CHAR = opts.tab;
     }
+
     if (!Array.isArray(this.tree)) this.tree = [this.tree];
   }
+
   deparseQuery() {
     return this.tree.map(node => this.deparse(node)).join(NEWLINE_CHAR + NEWLINE_CHAR);
   }
+
   deparseNodes(nodes, context) {
     return unwrapList(nodes).map(node => {
       const unwrapped = unwrapList(node);
       return Array.isArray(unwrapped) ? this.list(unwrapped, ', ', '', context) : this.deparse(node, context);
     });
   }
+
   deparseReturningList(list, context) {
     return unwrapList(list).map(returning => this.deparse(returning.ResTarget.val, context) + (returning.ResTarget.name ? ' AS ' + this.quote(returning.ResTarget.name) : '')).join(',');
   }
+
   list(nodes, separator = ', ', prefix = '', context) {
     if (!nodes) {
       return '';
     }
+
     return this.deparseNodes(nodes, context).map(l => `${prefix}${l}`).join(separator);
   }
+
   listQuotes(nodes, separator = ', ') {
     return this.list(unwrapList(nodes), separator).split(separator).map(a => this.quote(a.trim())).join(separator);
   }
+
   quote(value) {
     if (value == null) {
       return null;
     }
+
     const unwrapped = unwrapList(value);
+
     if (Array.isArray(unwrapped)) {
       return unwrapped.map(o => this.quote(o));
     }
+
     if (needsQuotes(value)) {
       return '"' + value + '"';
     }
+
     return value;
-  }
+  } // SELECT encode(E'''123\\000\\001', 'base64')
+
 
-  // SELECT encode(E'''123\\000\\001', 'base64')
   escape(literal) {
     return "'" + literal.replace(/'/g, "''") + "'";
   }
+
   getPgCatalogTypeName(typeName, size) {
     switch (typeName) {
       case 'bpchar':
         if (size != null) {
           return 'char';
-        }
-        // return `pg_catalog.bpchar` below so that the following is symmetric
+        } // return `pg_catalog.bpchar` below so that the following is symmetric
         // SELECT char 'c' = char 'c' AS true
+
+
         return 'pg_catalog.bpchar';
+
       case 'varchar':
         return 'varchar';
+
       case 'numeric':
         return 'numeric';
+
       case 'bool':
         return 'boolean';
+
       case 'int2':
         return 'smallint';
+
       case 'int4':
         return 'int';
+
       case 'int8':
         return 'bigint';
+
       case 'real':
         return 'pg_catalog.float4';
+
       case 'time':
         return 'time';
+
       case 'timestamp':
         return 'timestamp';
+
       case 'interval':
         return 'interval';
+
       case 'bit':
         return 'bit';
+
       default:
         return 'pg_catalog.' + typeName;
     }
   }
+
   type(names, args) {
     const catalogAndType = unwrapList(names).map(name => this.deparse(name));
     const catalog = catalogAndType[0];
     const type = catalogAndType[1];
+
     const mods = (name, size) => {
       if (size != null) {
         return name + '(' + size + ')';
       }
+
       return name;
-    };
+    }; // handle the special "char" (in quotes) type
+
 
-    // handle the special "char" (in quotes) type
     if (catalog === 'char' && !type) {
       return mods('"char"', args);
     }
+
     if (catalog === 'pg_catalog' && type === 'char') {
       return mods('pg_catalog."char"', args);
     }
+
     if (catalog !== 'pg_catalog') {
       return mods(this.listQuotes(names, '.'), args);
     }
+
     const res = this.getPgCatalogTypeName(type, args);
     return mods(res, args);
   }
+
   deparse(item, context) {
     if (item == null) {
       return null;
     }
+
     if (typeof item === 'number' || item instanceof Number) {
       return item;
     }
+
     const type = Object.keys(item)[0];
     const node = item[type];
+
     if (this[type] == null) {
       throw new Error(type + ' is not implemented: ' + JSON.stringify(node));
     }
+
     return this[type](node, context);
   }
+
   ['RawStmt'](node, context = {}) {
     if (node.stmt_len) {
       return this.deparse(node.stmt, context) + ';';
     }
+
     return this.deparse(node.stmt, context);
   }
+
   ['RuleStmt'](node, context = {}) {
     const output = [];
     output.push('CREATE');
     output.push('RULE');
+
     if (node.rulename === '_RETURN') {
       // special rules
       output.push('"_RETURN"');
     } else {
       output.push(node.rulename);
     }
+
     output.push('AS');
     output.push('ON');
+
     switch (node.event) {
       case 'CMD_SELECT':
         output.push('SELECT');
         break;
+
       case 'CMD_UPDATE':
         output.push('UPDATE');
         break;
+
       case 'CMD_INSERT':
         output.push('INSERT');
         break;
+
       case 'CMD_DELETE':
         output.push('DELETE');
         break;
+
       default:
         throw new Error('event type not yet implemented for RuleStmt');
     }
+
     output.push('TO');
     output.push(this.RangeVar(node.relation, context));
+
     if (node.whereClause) {
       output.push('WHERE');
       output.push(this.deparse(node.whereClause, context));
     }
+
     output.push('DO');
+
     if (node.instead) {
       output.push('INSTEAD');
     }
+
     const actions = unwrapList(node.actions);
+
     if (!actions || !actions.length) {
       output.push('NOTHING');
     } else {
       // TODO how do multiple actions happen?
       output.push(this.deparse(actions[0], context));
     }
+
     return output.join(' ');
   }
+
   ['A_Expr'](node, context = {}) {
     const output = [];
     const nodeName = unwrapList(node.name);
+
     switch (node.kind) {
       case 'AEXPR_OP':
         {
           let operator;
+
           if (node.lexpr) {
             // PARENS
             if (node.lexpr !== undefined && node.lexpr.A_Expr !== undefined) {
@@ -257,6 +330,7 @@ export default class Deparser {
               output.push(this.deparse(node.lexpr, context));
             }
           }
+
           if (nodeName.length > 1) {
             const schema = this.deparse(nodeName[0], context);
             operator = this.deparse(nodeName[1], context);
@@ -265,6 +339,7 @@ export default class Deparser {
             operator = this.deparse(nodeName[0], context);
             output.push(operator);
           }
+
           if (node.rexpr) {
             // PARENS
             if (node.rexpr !== undefined && node.rexpr.A_Expr !== undefined) {
@@ -273,66 +348,84 @@ export default class Deparser {
               output.push(this.deparse(node.rexpr, context));
             }
           }
+
           if (output.length === 2) {
             return output.join('');
           }
+
           if (['->', '->>'].includes(operator)) {
             return output.join('');
           }
+
           return output.join(' ');
         }
+
       case 'AEXPR_OP_ANY':
         /* scalar op ANY (array) */
         output.push(this.deparse(node.lexpr, context));
         output.push(format('ANY (%s)', this.deparse(node.rexpr, context)));
         return output.join(` ${this.deparse(nodeName[0], context)} `);
+
       case 'AEXPR_OP_ALL':
         /* scalar op ALL (array) */
         output.push(this.deparse(node.lexpr, context));
         output.push(format('ALL (%s)', this.deparse(node.rexpr, context)));
         return output.join(` ${this.deparse(nodeName[0], context)} `);
+
       case 'AEXPR_DISTINCT':
         /* IS DISTINCT FROM - name must be "=" */
         return format('%s IS DISTINCT FROM %s', this.deparse(node.lexpr, context), this.deparse(node.rexpr, context));
+
       case 'AEXPR_NOT_DISTINCT':
         /* IS NOT DISTINCT FROM - name must be "=" */
         return format('%s IS NOT DISTINCT FROM %s', this.deparse(node.lexpr, context), this.deparse(node.rexpr, context));
+
       case 'AEXPR_NULLIF':
         /* NULLIF - name must be "=" */
         return format('NULLIF(%s, %s)', this.deparse(node.lexpr, context), this.deparse(node.rexpr, context));
+
       case 'AEXPR_OF':
         {
           /* IS [NOT] OF - name must be "=" or "<>" */
           const op = nodeName[0].String.str === '=' ? 'IS OF' : 'IS NOT OF';
           return format('%s %s (%s)', this.deparse(node.lexpr, context), op, this.list(node.rexpr, ', ', '', context));
         }
+
       case 'AEXPR_IN':
         {
           /* [NOT] IN - name must be "=" or "<>" */
           const operator = nodeName[0].String.str === '=' ? 'IN' : 'NOT IN';
           return format('%s %s (%s)', this.deparse(node.lexpr, context), operator, this.list(node.rexpr, ', ', '', context));
         }
+
       case 'AEXPR_LIKE':
         /* [NOT] LIKE - name must be "~~" or "!~~" */
         output.push(this.deparse(node.lexpr, context));
+
         if (nodeName[0].String.str === '!~~') {
           output.push(format('NOT LIKE (%s)', this.deparse(node.rexpr, context)));
         } else {
           output.push(format('LIKE (%s)', this.deparse(node.rexpr, context)));
         }
+
         return output.join(' ');
+
       case 'AEXPR_ILIKE':
         /* [NOT] ILIKE - name must be "~~*" or "!~~*" */
         output.push(this.deparse(node.lexpr, context));
+
         if (nodeName[0].String.str === '!~~*') {
           output.push(format('NOT ILIKE (%s)', this.deparse(node.rexpr, context)));
         } else {
           output.push(format('ILIKE (%s)', this.deparse(node.rexpr, context)));
         }
+
         return output.join(' ');
+
       case 'AEXPR_SIMILAR':
         // SIMILAR TO emits a similar_escape FuncCall node with the first argument
         output.push(this.deparse(node.lexpr, context));
+
         if (nodeName[0].String.str === '~') {
           if (unwrapList(node.rexpr.FuncCall.args).length > 1) {
             output.push(format('SIMILAR TO %s ESCAPE %s', this.deparse(unwrapList(node.rexpr.FuncCall.args)[0], context), this.deparse(unwrapList(node.rexpr.FuncCall.args)[1], context)));
@@ -346,24 +439,28 @@ export default class Deparser {
             output.push(format('NOT SIMILAR TO %s', this.deparse(unwrapList(node.rexpr.FuncCall.args)[0], context)));
           }
         }
+
         return output.join(' ');
+
       case 'AEXPR_BETWEEN':
         output.push(this.deparse(node.lexpr, context));
         output.push(format('BETWEEN %s AND %s', this.deparse(unwrapList(node.rexpr)[0], context), this.deparse(unwrapList(node.rexpr)[1], context)));
         return output.join(' ');
+
       case 'AEXPR_NOT_BETWEEN':
         output.push(this.deparse(node.lexpr, context));
         output.push(format('NOT BETWEEN %s AND %s', this.deparse(unwrapList(node.rexpr)[0], context), this.deparse(unwrapList(node.rexpr)[1], context)));
         return output.join(' ');
+
       case 'AEXPR_BETWEEN_SYM':
         output.push(this.deparse(node.lexpr, context));
         output.push(format('BETWEEN SYMMETRIC %s AND %s', this.deparse(unwrapList(node.rexpr)[0], context), this.deparse(unwrapList(node.rexpr)[1], context)));
         return output.join(' ');
+
       case 'AEXPR_NOT_BETWEEN_SYM':
         output.push(this.deparse(node.lexpr, context));
         output.push(format('NOT BETWEEN SYMMETRIC %s AND %s', this.deparse(unwrapList(node.rexpr)[0], context), this.deparse(unwrapList(node.rexpr)[1], context)));
         return output.join(' ');
-
       // case 15:
       // AEXPR_PAREN
 
@@ -371,35 +468,42 @@ export default class Deparser {
         return fail('A_Expr', node);
     }
   }
+
   ['Alias'](node, context = {}) {
     const name = node.aliasname;
     const output = ['AS'];
+
     if (node.colnames) {
       output.push(this.quote(name) + parens(this.listQuotes(node.colnames)));
     } else {
       output.push(this.quote(name));
     }
+
     return output.join(' ');
   }
+
   ['A_ArrayExpr'](node) {
     return format('ARRAY[%s]', this.list(node.elements));
   }
+
   ['A_Const'](node, context = {}) {
     if (node.val.String) {
       return this.escape(this.deparse(node.val, context));
     }
+
     return this.deparse(node.val, context);
   }
+
   ['A_Indices'](node, context = {}) {
     if (node.lidx) {
       return format('[%s:%s]', this.deparse(node.lidx, context), this.deparse(node.uidx, context));
     }
+
     return format('[%s]', this.deparse(node.uidx, context));
   }
-  ['A_Indirection'](node, context = {}) {
-    const output = [`(${this.deparse(node.arg, context)})`];
 
-    // TODO(zhm) figure out the actual rules for when a '.' is needed
+  ['A_Indirection'](node, context = {}) {
+    const output = [`(${this.deparse(node.arg, context)})`]; // TODO(zhm) figure out the actual rules for when a '.' is needed
     //
     // select a.b[0] from a;
     // select (select row(1)).*
@@ -407,8 +511,10 @@ export default class Deparser {
     // select c2.a[2].f2[1].f3[0].a1 from comptable
 
     const indirection = unwrapList(node.indirection);
+
     for (let i = 0; i < indirection.length; i++) {
       const subnode = indirection[i];
+
       if (subnode.String || subnode.A_Star) {
         const value = subnode.A_Star ? '*' : this.quote(subnode.String.str);
         output.push(`.${value}`);
@@ -416,90 +522,121 @@ export default class Deparser {
         output.push(this.deparse(subnode, context));
       }
     }
+
     return output.join('');
   }
+
   ['A_Star'](node) {
     return '*';
   }
+
   ['BitString'](node) {
     const prefix = node.str[0];
     return `${prefix}'${node.str.substring(1)}'`;
   }
+
   ['BoolExpr'](node, context = {}) {
     let fmt_str = '%s';
+
     if (context.bool) {
       fmt_str = '(%s)';
     }
+
     const ctx = Object.assign({}, context);
     ctx.bool = true;
+
     switch (node.boolop) {
       case 'AND_EXPR':
         return format(fmt_str, this.list(node.args, ' AND ', '', ctx));
+
       case 'OR_EXPR':
         return format(fmt_str, this.list(node.args, ' OR ', '', ctx));
+
       case 'NOT_EXPR':
         return format('NOT (%s)', this.deparse(unwrapList(node.args)[0], context));
+
       default:
         return fail('BoolExpr', node);
     }
   }
+
   ['BooleanTest'](node, context = {}) {
     const output = [];
     const ctx = Object.assign({}, context);
     ctx.bool = true;
     output.push(this.deparse(node.arg, ctx));
+
     switch (node.booltesttype) {
       case 'IS_TRUE':
         output.push('IS TRUE');
         break;
+
       case 'IS_NOT_TRUE':
         output.push('IS NOT TRUE');
         break;
+
       case 'IS_FALSE':
         output.push('IS FALSE');
         break;
+
       case 'IS_NOT_FALSE':
         output.push('IS NOT FALSE');
         break;
+
       case 'IS_UNKNOWN':
         output.push('IS UNKNOWN');
         break;
+
       case 'IS_NOT_UNKNOWN':
         output.push('IS NOT UNKNOWN');
         break;
     }
+
     return output.join(' ');
   }
+
   ['CaseExpr'](node, context = {}) {
     const output = ['CASE'];
+
     if (node.arg) {
       output.push(this.deparse(node.arg, context));
     }
+
     const args = unwrapList(node.args);
+
     for (let i = 0; i < args.length; i++) {
       output.push(this.deparse(args[i], context));
     }
+
     if (node.defresult) {
       output.push('ELSE');
       output.push(this.deparse(node.defresult, context));
     }
+
     output.push('END');
     return output.join(' ');
   }
+
   ['CoalesceExpr'](node, context = {}) {
     return format('COALESCE(%s)', this.list(node.args, ', ', '', context));
   }
+
   ['CollateClause'](node, context = {}) {
     const output = [];
+
     if (node.arg) {
       output.push(this.deparse(node.arg, context));
     }
+
     output.push('COLLATE');
+
     if (node.collname) {
       output.push(this.quote(this.deparseNodes(node.collname, context)));
     }
+
     return output.join(' ');
   }
+
   ['CompositeTypeStmt'](node, context = {}) {
     const output = [];
     output.push('CREATE TYPE');
@@ -510,14 +647,18 @@ export default class Deparser {
     output.push(')');
     return output.join(' ');
   }
+
   ['RenameStmt'](node, context = {}) {
     const output = [];
+
     if (node.renameType === 'OBJECT_FUNCTION' || node.renameType === 'OBJECT_FOREIGN_TABLE' || node.renameType === 'OBJECT_FDW' || node.renameType === 'OBJECT_FOREIGN_SERVER') {
       output.push('ALTER');
       output.push(objtypeName(node.renameType));
+
       if (node.missing_ok) {
         output.push('IF EXISTS');
       }
+
       output.push(this.deparse(node.object, context));
       output.push('RENAME');
       output.push('TO');
@@ -525,9 +666,11 @@ export default class Deparser {
     } else if (node.renameType === 'OBJECT_ATTRIBUTE') {
       output.push('ALTER');
       output.push(objtypeName(node.relationType));
+
       if (node.missing_ok) {
         output.push('IF EXISTS');
       }
+
       output.push(this.RangeVar(node.relation, context));
       output.push('RENAME');
       output.push(objtypeName(node.renameType));
@@ -537,9 +680,11 @@ export default class Deparser {
     } else if (node.renameType === 'OBJECT_DOMAIN' || node.renameType === 'OBJECT_TYPE') {
       output.push('ALTER');
       output.push(objtypeName(node.renameType));
+
       if (node.missing_ok) {
         output.push('IF EXISTS');
       }
+
       const typObj = {
         TypeName: {
           names: node.object
@@ -552,9 +697,11 @@ export default class Deparser {
     } else if (node.renameType === 'OBJECT_SCHEMA') {
       output.push('ALTER');
       output.push(objtypeName(node.renameType));
+
       if (node.missing_ok) {
         output.push('IF EXISTS');
       }
+
       output.push(this.quote(node.subname));
       output.push('RENAME');
       output.push('TO');
@@ -562,9 +709,11 @@ export default class Deparser {
     } else if (node.renameType === 'OBJECT_DOMCONSTRAINT') {
       output.push('ALTER');
       output.push('DOMAIN');
+
       if (node.missing_ok) {
         output.push('IF EXISTS');
       }
+
       const typObj = {
         TypeName: {
           names: node.object
@@ -578,114 +727,146 @@ export default class Deparser {
     } else {
       output.push('ALTER');
       output.push('TABLE');
+
       if (node.missing_ok) {
         output.push('IF EXISTS');
       }
+
       output.push(this.RangeVar(node.relation, context));
       output.push('RENAME');
       output.push(this.quote(node.subname));
       output.push('TO');
       output.push(this.quote(node.newname));
     }
+
     if (node.behavior === 'DROP_CASCADE') {
       output.push('CASCADE');
     }
+
     return output.join(' ');
   }
+
   ['AlterOwnerStmt'](node, context = {}) {
     const output = [];
     output.push('ALTER');
     output.push(objtypeName(node.objectType));
     const unwrapped = unwrapList(node.object);
+
     if (Array.isArray(unwrapped)) {
       output.push(this.listQuotes(unwrapped, '.'));
     } else {
       output.push(this.deparse(node.object, context));
     }
+
     output.push('OWNER TO');
     output.push(this.RoleSpec(node.newowner, context));
     return output.join(' ');
   }
+
   ['AlterObjectSchemaStmt'](node, context = {}) {
     const output = [];
+
     if (node.objectType === 'OBJECT_TABLE') {
       output.push('ALTER');
       output.push(objtypeName(node.objectType));
+
       if (node.missing_ok) {
         output.push('IF EXISTS');
       }
+
       output.push(this.RangeVar(node.relation, context));
       output.push('SET SCHEMA');
       output.push(this.quote(node.newschema));
     } else {
       output.push('ALTER');
       output.push(objtypeName(node.objectType));
+
       if (node.missing_ok) {
         output.push('IF EXISTS');
       }
+
       const unwrapped = unwrapList(node.object);
+
       if (Array.isArray(unwrapped)) {
         output.push(this.listQuotes(unwrapped, '.'));
       } else {
         output.push(this.deparse(node.object, context));
       }
+
       output.push('SET SCHEMA');
       output.push(this.quote(node.newschema));
     }
+
     return output.join(' ');
   }
+
   ['ColumnDef'](node, context = {}) {
     const output = [this.quote(node.colname)];
     output.push(this.TypeName(node.typeName, context));
+
     if (node.raw_default) {
       output.push('USING');
       output.push(this.deparse(node.raw_default, context));
     }
+
     if (node.constraints) {
       output.push(this.list(node.constraints, ' ', '', context));
     }
+
     if (node.collClause) {
       output.push('COLLATE');
       const str = unwrapList(node.collClause.collname)[0].String.str;
       output.push(this.quote(str));
     }
+
     return compact(output).join(' ');
   }
+
   ['SQLValueFunction'](node) {
     if (node.op === 'SVFOP_CURRENT_DATE') {
       return 'CURRENT_DATE';
     }
+
     if (node.op === 'SVFOP_CURRENT_TIMESTAMP') {
       return 'CURRENT_TIMESTAMP';
     }
+
     if (node.op === 'SVFOP_CURRENT_USER') {
       return 'CURRENT_USER';
     }
+
     if (node.op === 'SVFOP_SESSION_USER') {
       return 'SESSION_USER';
     }
+
     throw new Error(`op=${node.op} SQLValueFunction not implemented`);
   }
+
   ['ColumnRef'](node, context = {}) {
     const KEYWORDS = ['old', 'new'];
     const fields = unwrapList(node.fields).map(field => {
       if (field.String) {
         const value = this.deparse(field, context);
+
         if (context === 'trigger' && KEYWORDS.includes(value.toLowerCase())) {
           return value.toUpperCase();
         }
+
         return this.quote(value);
       }
+
       return this.deparse(field, context);
     });
     return fields.join('.');
   }
+
   ['CommentStmt'](node, context = {}) {
     const output = [];
     output.push('COMMENT');
     output.push('ON');
     output.push(objtypeName(node.objtype));
     const object = unwrapList(node.object);
+
     if (node.objtype === 'OBJECT_CAST') {
       output.push('(');
       output.push(this.deparse(object[0], context));
@@ -740,16 +921,20 @@ export default class Deparser {
       } else {
         output.push(this.deparse(object, context));
       }
+
       if (node.objargs) {
         output.push('(');
         output.push(this.list(node.objargs, ', ', '', context));
         output.push(')');
       }
     }
+
     output.push('IS');
+
     const escapeComment = str => {
       return str.replace(/\\/g, '\\');
     };
+
     if (node.comment) {
       if (/[^a-zA-Z0-9]/.test(node.comment)) {
         // special chars we care about...
@@ -761,70 +946,91 @@ export default class Deparser {
     } else {
       output.push('NULL');
     }
+
     return output.join(' ');
   }
+
   ['CommonTableExpr'](node, context = {}) {
     const output = [];
     output.push(node.ctename);
+
     if (node.aliascolnames) {
       const colnames = this.quote(this.deparseNodes(node.aliascolnames, context));
       output.push(`(${colnames.join(', ')})`);
     }
+
     output.push('AS');
+
     if (node.ctematerialized === 'CTEMaterializeAlways') {
       output.push('MATERIALIZED');
     } else if (node.ctematerialized === 'CTEMaterializeNever') {
       output.push('NOT MATERIALIZED');
     }
+
     output.push(format('(%s)', this.deparse(node.ctequery)));
     return output.join(' ');
   }
+
   ['DefineStmt'](node, context = {}) {
     const output = [];
     output.push('CREATE');
+
     if (node.replace) {
       output.push('OR REPLACE');
     }
+
     switch (node.kind) {
       case 'OBJECT_AGGREGATE':
         output.push('AGGREGATE');
         break;
+
       case 'OBJECT_OPERATOR':
         output.push('OPERATOR');
         break;
+
       case 'OBJECT_TYPE':
         output.push('TYPE');
         break;
+
       case 'OBJECT_TSPARSER':
         output.push('TEXT SEARCH PARSER');
         break;
+
       case 'OBJECT_TSDICTIONARY':
         output.push('TEXT SEARCH DICTIONARY');
         break;
+
       case 'OBJECT_TSTEMPLATE':
         output.push('TEXT SEARCH TEMPLATE');
         break;
+
       case 'OBJECT_TSCONFIGURATION':
         output.push('TEXT SEARCH CONFIGURATION');
         break;
+
       case 'OBJECT_COLLATION':
         output.push('COLLATION');
         break;
+
       default:
         throw new Error('DefineStmt not recognized');
     }
+
     if (node.if_not_exists) {
       output.push('IF NOT EXISTS');
     }
+
     switch (node.kind) {
       case 'OBJECT_AGGREGATE':
         // output.push(this.deparse(node.defnames));
         output.push(this.list(node.defnames, '.', '', context));
         break;
+
       case 'OBJECT_OPERATOR':
-        output.push(this.list(node.defnames, '.', '', context));
-        // output.push(this.deparse(node.defnames));
+        output.push(this.list(node.defnames, '.', '', context)); // output.push(this.deparse(node.defnames));
+
         break;
+
       case 'OBJECT_TYPE':
       case 'OBJECT_TSPARSER':
       case 'OBJECT_TSDICTIONARY':
@@ -833,49 +1039,65 @@ export default class Deparser {
       case 'OBJECT_COLLATION':
         output.push(this.deparse(node.defnames));
         break;
+
       default:
         throw new Error('DefineStmt not recognized');
     }
+
     if (!node.oldstyle && node.kind == 'OBJECT_AGGREGATE') {
       output.push('(');
       output.push(`${this.listQuotes(node.args[0], ',')}`);
       output.push(')');
     }
+
     const definition = unwrapList(node.definition);
+
     if (definition.length > 0) {
       output.push('(');
+
       for (let n = 0; n < definition.length; n++) {
         const defElement = definition[n].DefElem;
         output.push(defElement.defname);
+
         if (defElement.arg) {
           output.push('=');
           output.push(this.deparse(defElement.arg));
         }
+
         if (n !== definition.length - 1) {
           output.push(',');
         }
       }
+
       output.push(')');
     }
+
     return output.join(' ');
   }
+
   ['DefElem'](node, context = {}) {
     if (node.defname === 'transaction_isolation') {
       return format('ISOLATION LEVEL %s', node.arg.A_Const.val.String.str.toUpperCase());
     }
+
     if (node.defname === 'transaction_read_only') {
       return node.arg.A_Const.val.Integer.ival === 0 ? 'READ WRITE' : 'READ ONLY';
     }
+
     if (node.defname === 'transaction_deferrable') {
       return node.arg.A_Const.val.Integer.ival === 0 ? 'NOT DEFERRABLE' : 'DEFERRABLE';
     }
+
     if (node.defname === 'set') {
       return this.deparse(node.arg, context);
     }
+
     let name = node.defname;
+
     if (node.defnamespace) {
       name = `${node.defnamespace}.${node.defname}`;
     }
+
     if (context === 'generated' || context === 'sequence') {
       switch (name) {
         case 'start':
@@ -883,35 +1105,43 @@ export default class Deparser {
             const start = this.deparse(node.arg, context);
             return `START WITH ${start}`;
           }
+
         case 'increment':
           {
             const inc = this.deparse(node.arg, context);
+
             if (context === 'sequence') {
               // we need 'simple' so it doesn't wrap negative numbers in parens
               return `${name} ${this.deparse(node.arg, 'simple')}`;
             }
+
             return `INCREMENT BY ${inc}`;
           }
+
         case 'sequence_name':
           {
             return `SEQUENCE NAME ${this.listQuotes(node.arg, '.')}`;
           }
+
         case 'cycle':
           {
             const on = this.deparse(node.arg, context) + '' === '1';
             return on ? 'CYCLE' : 'NO CYCLE';
           }
+
         case 'minvalue':
           {
             const off = !node.hasOwnProperty('arg');
             return off ? 'NO MINVALUE' : `${name} ${this.deparse(node.arg, 'simple')}`;
           }
+
         case 'maxvalue':
           {
             const off = !node.hasOwnProperty('arg');
             return off ? 'NO MAXVALUE' : `${name} ${this.deparse(node.arg, 'simple')}`;
           }
         // alter
+
         case 'owned_by':
           {
             const output = [];
@@ -921,18 +1151,22 @@ export default class Deparser {
             return `OWNED BY ${output.join('.')}`;
           }
         // alter
+
         case 'restart':
           {
             if (node.arg) {
               return `RESTART WITH ${this.deparse(node.arg, context)}`;
             }
+
             return `RESTART`;
           }
+
         default:
           if (node.arg) {
             // we need 'simple' so it doesn't wrap negative numbers in parens
             return `${name} ${this.deparse(node.arg, 'simple')}`;
           }
+
       }
     } else if (context === 'explain') {
       if (node.arg) {
@@ -941,162 +1175,211 @@ export default class Deparser {
     } else if (node.arg) {
       return `${name} = ${this.deparse(node.arg, context)}`;
     }
+
     return name;
   }
+
   ['DoStmt'](node) {
     return `DO $$${NEWLINE_CHAR}  ${dotty.get(node, 'args.0.DefElem.arg.String.str').trim()} $$`;
   }
+
   ['Float'](node) {
     // wrap negative numbers in parens, SELECT (-2147483648)::int4 * (-1)::int4
     if (node.str[0] === '-') {
       return `(${node.str})`;
     }
+
     return node.str;
   }
+
   ['FuncCall'](node, context = {}) {
     const output = [];
     let params = [];
+
     if (node.args) {
       params = unwrapList(node.args).map(item => {
         return this.deparse(item, context);
       });
-    }
+    } // COUNT(*)
+
 
-    // COUNT(*)
     if (node.agg_star) {
       params.push('*');
     }
+
     const name = this.list(node.funcname, '.', '', context);
     const order = [];
     const withinGroup = node.agg_within_group;
+
     if (node.agg_order) {
       order.push('ORDER BY');
       order.push(this.list(node.agg_order, ', ', '', context));
     }
+
     const call = [];
     call.push(name + '(');
+
     if (node.agg_distinct) {
       call.push('DISTINCT ');
-    }
-
-    // prepend variadic before the last parameter
+    } // prepend variadic before the last parameter
     // SELECT CONCAT('|', VARIADIC ARRAY['1','2','3'])
+
+
     if (node.func_variadic) {
       params[params.length - 1] = 'VARIADIC ' + params[params.length - 1];
     }
+
     call.push(params.join(', '));
+
     if (order.length && !withinGroup) {
       call.push(' ');
       call.push(order.join(' '));
     }
+
     call.push(')');
     output.push(compact(call).join(''));
+
     if (order.length && withinGroup) {
       output.push('WITHIN GROUP');
       output.push(parens(order.join(' ')));
     }
+
     if (node.agg_filter != null) {
       output.push(format('FILTER (WHERE %s)', this.deparse(node.agg_filter, context)));
     }
+
     if (node.over != null) {
       output.push(format('OVER %s', this.WindowDef(node.over, context)));
     }
+
     return output.join(' ');
   }
+
   ['GroupingFunc'](node, context = {}) {
     return 'GROUPING(' + this.list(node.args, ', ', '', context) + ')';
   }
+
   ['GroupingSet'](node, context = {}) {
     switch (node.kind) {
       case 'GROUPING_SET_EMPTY':
         return '()';
+
       case 'GROUPING_SET_SIMPLE':
         return fail('GroupingSet', node);
+
       case 'GROUPING_SET_ROLLUP':
         return 'ROLLUP (' + this.list(node.content, ', ', '', context) + ')';
+
       case 'GROUPING_SET_CUBE':
         return 'CUBE (' + this.list(node.content, ', ', '', context) + ')';
+
       case 'GROUPING_SET_SETS':
         return 'GROUPING SETS (' + this.list(node.content, ', ', '', context) + ')';
+
       default:
         return fail('GroupingSet', node);
     }
   }
+
   ['IndexStmt'](node, context = {}) {
     const output = [];
     output.push('CREATE');
+
     if (node.unique) {
       output.push('UNIQUE');
     }
+
     output.push('INDEX');
+
     if (node.concurrent) {
       output.push('CONCURRENTLY');
     }
+
     if (node.idxname) {
       output.push(node.idxname);
     }
+
     output.push('ON');
     output.push(this.RangeVar(node.relation, context));
+
     if (node.accessMethod) {
       const accessMethod = node.accessMethod.toUpperCase();
+
       if (accessMethod !== 'BTREE') {
         output.push('USING');
         output.push(accessMethod);
       }
     }
+
     if (node.indexParams) {
       output.push('(');
       output.push(this.list(node.indexParams, ', ', '', context));
       output.push(')');
     }
+
     if (node.indexIncludingParams) {
       output.push('INCLUDE (');
       output.push(this.list(node.indexIncludingParams, ', ', '', context));
       output.push(')');
     }
+
     if (node.whereClause) {
       output.push('WHERE');
       output.push(this.deparse(node.whereClause, context));
     }
+
     return output.join(' ');
   }
+
   ['IndexElem'](node, context = {}) {
     const output = [];
+
     if (node.name) {
       output.push(node.name);
+
       if (node.ordering === 'SORTBY_DESC') {
         output.push('DESC');
       } else if (node.ordering === 'SORTBY_ASC') {
         output.push('ASC');
       }
+
       return output.join(' ');
     }
+
     if (node.expr) {
       return this.deparse(node.expr, context);
     }
+
     return fail('IndexElem', node);
   }
+
   ['InsertStmt'](node, context = {}) {
     const output = [];
+
     if (node.withClause) {
       output.push(this.WithClause(node.withClause, context));
     }
+
     output.push('INSERT INTO');
     output.push(this.RangeVar(node.relation, context));
     const cols = unwrapList(node.cols);
+
     if (cols && cols.length) {
       output.push('(');
       output.push(this.list(cols, ', ', '', context));
       output.push(')');
     }
+
     if (node.selectStmt) {
       output.push(this.deparse(node.selectStmt, context));
     } else {
       output.push('DEFAULT VALUES');
     }
+
     if (node.onConflictClause) {
       const clause = node.onConflictClause;
       output.push('ON CONFLICT');
+
       if (clause.infer.indexElems) {
         output.push('(');
         output.push(this.list(clause.infer.indexElems, ', ', '', context));
@@ -1105,66 +1388,86 @@ export default class Deparser {
         output.push('ON CONSTRAINT');
         output.push(clause.infer.conname);
       }
+
       switch (clause.action) {
         case 'ONCONFLICT_NOTHING':
           output.push('DO NOTHING');
           break;
+
         case 'ONCONFLICT_UPDATE':
           output.push('DO');
           output.push(this.UpdateStmt(clause, context));
           break;
+
         default:
           throw new Error('unhandled CONFLICT CLAUSE');
       }
     }
+
     if (node.returningList) {
       output.push('RETURNING');
       output.push(this.deparseReturningList(node.returningList, context));
     }
+
     return output.join(' ');
   }
+
   ['SetToDefault'](node) {
     return 'DEFAULT';
   }
+
   ['MultiAssignRef'](node, context = {}) {
     const output = [];
     output.push(this.deparse(node.source, context));
     return output.join(' ');
   }
+
   ['DeleteStmt'](node, context = {}) {
     const output = [''];
+
     if (node.withClause) {
       output.push(this.WithClause(node.withClause, context));
     }
+
     output.push('DELETE');
     output.push('FROM');
     output.push(this.RangeVar(node.relation, context));
+
     if (node.usingClause) {
       output.push('USING');
       output.push(this.list(node.usingClause, ', ', '', context));
     }
+
     if (node.whereClause) {
       output.push('WHERE');
       output.push(this.deparse(node.whereClause, context));
     }
+
     if (node.returningList) {
       output.push('RETURNING');
       output.push(this.deparseReturningList(node.returningList, context));
     }
+
     return output.join(' ');
   }
+
   ['UpdateStmt'](node, context = {}) {
     const output = [];
+
     if (node.withClause) {
       output.push(this.WithClause(node.withClause, context));
     }
+
     output.push('UPDATE');
+
     if (node.relation) {
       // onConflictClause no relation..
       output.push(this.RangeVar(node.relation, context));
     }
+
     output.push('SET');
     const targetList = unwrapList(node.targetList);
+
     if (targetList && targetList.length) {
       if (targetList[0].ResTarget && targetList[0].ResTarget.val && targetList[0].ResTarget.val.MultiAssignRef) {
         output.push('(');
@@ -1176,60 +1479,79 @@ export default class Deparser {
         output.push(targetList.map(target => this.deparse(target, 'update')).join(','));
       }
     }
+
     if (node.fromClause) {
       output.push('FROM');
       output.push(this.list(node.fromClause, ', ', '', context));
     }
+
     if (node.whereClause) {
       output.push('WHERE');
       output.push(this.deparse(node.whereClause, context));
     }
+
     if (node.returningList) {
       output.push('RETURNING');
       output.push(this.deparseReturningList(node.returningList, context));
     }
+
     return output.join(' ');
   }
+
   ['Integer'](node, context = {}) {
     if (node.ival < 0 && context !== 'simple') {
       return `(${node.ival})`;
     }
+
     return node.ival.toString();
   }
+
   ['IntoClause'](node, context = {}) {
     return this.RangeVar(node.rel, context);
   }
+
   ['JoinExpr'](node, context = {}) {
     const output = [];
     output.push(this.deparse(node.larg, context));
+
     if (node.isNatural) {
       output.push('NATURAL');
     }
+
     let join = null;
+
     switch (true) {
       case node.jointype === 'JOIN_INNER' && node.quals != null:
         join = 'INNER JOIN';
         break;
+
       case node.jointype === 'JOIN_INNER' && !node.isNatural && !(node.quals != null) && !(node.usingClause != null):
         join = 'CROSS JOIN';
         break;
+
       case node.jointype === 'JOIN_INNER':
         join = 'JOIN';
         break;
+
       case node.jointype === 'JOIN_LEFT':
         join = 'LEFT OUTER JOIN';
         break;
+
       case node.jointype === 'JOIN_FULL':
         join = 'FULL OUTER JOIN';
         break;
+
       case node.jointype === 'JOIN_RIGHT':
         join = 'RIGHT OUTER JOIN';
         break;
+
       default:
         fail('JoinExpr', node);
         break;
     }
+
     output.push(join);
+
     if (node.rarg) {
       // wrap nested join expressions in parens to make the following symmetric:
       // select * from int8_tbl x cross join (int4_tbl x cross join lateral (select x.f1) ss)
@@ -1239,46 +1561,61 @@ export default class Deparser {
         output.push(this.deparse(node.rarg, context));
       }
     }
+
     if (node.quals) {
       output.push(`ON ${this.deparse(node.quals, context)}`);
     }
+
     if (node.usingClause) {
       const using = this.quote(this.deparseNodes(node.usingClause, context)).join(', ');
       output.push(`USING (${using})`);
     }
+
     const wrapped = node.rarg.JoinExpr != null || node.alias ? '(' + output.join(' ') + ')' : output.join(' ');
+
     if (node.alias) {
       return wrapped + ' ' + this.Alias(node.alias, context);
     }
+
     return wrapped;
   }
+
   ['LockingClause'](node, context = {}) {
     const output = [];
+
     switch (node.strength) {
       case 'LCS_NONE':
         output.push('NONE');
         break;
+
       case 'LCS_FORKEYSHARE':
         output.push('FOR KEY SHARE');
         break;
+
       case 'LCS_FORSHARE':
         output.push('FOR SHARE');
         break;
+
       case 'LCS_FORNOKEYUPDATE':
         output.push('FOR NO KEY UPDATE');
         break;
+
       case 'LCS_FORUPDATE':
         output.push('FOR UPDATE');
         break;
+
       default:
         return fail('LockingClause', node);
     }
+
     if (node.lockedRels) {
       output.push('OF');
       output.push(this.list(node.lockedRels, ', ', '', context));
     }
+
     return output.join(' ');
   }
+
   ['LockStmt'](node, context = {}) {
     const output = ['LOCK'];
     output.push(this.list(node.relations, ', ', '', {
@@ -1287,21 +1624,27 @@ export default class Deparser {
     output.push('IN');
     output.push(LOCK_MODES[node.mode]);
     output.push('MODE');
+
     if (node.nowait) {
       output.push('NOWAIT');
     }
+
     return output.join(' ');
   }
+
   ['MinMaxExpr'](node, context = {}) {
     const output = [];
+
     if (node.op === 'IS_GREATEST') {
       output.push('GREATEST');
     } else {
       output.push('LEAST');
     }
+
     output.push(parens(this.list(node.args, ', ', '', context)));
     return output.join('');
   }
+
   ['NamedArgExpr'](node, context = {}) {
     const output = [];
     output.push(node.name);
@@ -1309,110 +1652,147 @@ export default class Deparser {
     output.push(this.deparse(node.arg, context));
     return output.join(' ');
   }
+
   ['Null'](node) {
     return 'NULL';
   }
+
   ['NullTest'](node, context = {}) {
     const output = [this.deparse(node.arg, context)];
+
     if (node.nulltesttype === 'IS_NULL') {
       output.push('IS NULL');
     } else if (node.nulltesttype === 'IS_NOT_NULL') {
       output.push('IS NOT NULL');
     }
+
     return output.join(' ');
   }
+
   ['ParamRef'](node) {
     if (node.number >= 0) {
       return ['$', node.number].join('');
     }
+
     return '?';
   }
+
   ['RangeFunction'](node, context = {}) {
     const output = [];
+
     if (node.lateral) {
       output.push('LATERAL');
     }
+
     const funcs = [];
     const functions = unwrapList(node.functions);
+
     for (let i = 0; i < functions.length; i++) {
       const funcCall = unwrapList(functions[i]);
       const call = [this.deparse(funcCall[0], context)];
       const secondFuncCall = unwrapList(funcCall[1]);
+
       if (secondFuncCall && secondFuncCall.length) {
         call.push(format('AS (%s)', this.list(secondFuncCall, ', ', '', context)));
       }
+
       funcs.push(call.join(' '));
     }
+
     const calls = funcs.join(', ');
+
     if (node.is_rowsfrom) {
       output.push(`ROWS FROM (${calls})`);
     } else {
       output.push(calls);
     }
+
     if (node.ordinality) {
       output.push('WITH ORDINALITY');
     }
+
     if (node.alias) {
       output.push(this.Alias(node.alias, context));
     }
+
     if (node.coldeflist) {
       const defList = this.list(node.coldeflist, ', ', '', context);
+
       if (!node.alias) {
         output.push(` AS (${defList})`);
       } else {
         output.push(`(${defList})`);
       }
     }
+
     return output.join(' ');
   }
+
   ['RangeSubselect'](node, context = {}) {
     let output = '';
+
     if (node.lateral) {
       output += 'LATERAL ';
     }
+
     output += parens(this.deparse(node.subquery, context));
+
     if (node.alias) {
       return output + ' ' + this.Alias(node.alias, context);
     }
+
     return output;
   }
+
   ['RangeTableSample'](node, context = {}) {
     const output = [];
     output.push(this.deparse(node.relation, context));
     output.push('TABLESAMPLE');
     output.push(this.deparse(unwrapList(node.method)[0], context));
+
     if (node.args) {
       output.push(parens(this.list(node.args, ', ', '', context)));
     }
+
     if (node.repeatable) {
       output.push('REPEATABLE(' + this.deparse(node.repeatable, context) + ')');
     }
+
     return output.join(' ');
   }
+
   ['RangeVar'](node, context = {}) {
     const output = [];
+
     if (node.inhOpt === 0) {
       output.push('ONLY');
     }
+
     if (!node.inh && (context.lock || context === 'truncate')) {
       output.push('ONLY');
     }
+
     if (node.relpersistence === 'u') {
       output.push('UNLOGGED');
     }
+
     if (node.relpersistence === 't' && context !== 'view') {
       output.push('TEMPORARY TABLE');
     }
+
     if (node.schemaname != null) {
       output.push(`${this.quote(node.schemaname)}.${this.quote(node.relname)}`);
     } else {
       output.push(this.quote(node.relname));
     }
+
     if (node.alias) {
       output.push(this.Alias(node.alias, context));
     }
+
     return output.join(' ');
   }
+
   ['ResTarget'](node, context = {}) {
     if (context === 'select') {
       return compact([this.deparse(node.val, context), this.quote(node.name)]).join(' AS ');
@@ -1421,30 +1801,39 @@ export default class Deparser {
     } else if (!(node.val != null)) {
       return this.quote(node.name);
     }
+
     return fail('ResTarget', node);
   }
+
   ['RowExpr'](node, context = {}) {
     if (node.row_format === 'COERCE_IMPLICIT_CAST') {
       return parens(this.list(node.args, ', ', '', context));
     }
+
     return format('ROW(%s)', this.list(node.args, ', ', '', context));
   }
+
   ['ExplainStmt'](node, context = {}) {
     const output = [];
     output.push('EXPLAIN');
+
     if (node.options) {
       output.push('(');
       output.push(this.list(node.options, ', ', '', 'explain'));
       output.push(')');
     }
+
     output.push(this.deparse(node.query, context));
     return output.join(' ');
   }
+
   ['SelectStmt'](node, context = {}) {
     const output = [];
+
     if (node.withClause) {
       output.push(this.WithClause(node.withClause, context));
     }
+
     if (node.op === 'SETOP_NONE') {
       // VALUES select's don't get SELECT
       if (node.valuesLists == null) {
@@ -1452,54 +1841,67 @@ export default class Deparser {
       }
     } else {
       output.push(parens(this.SelectStmt(node.larg, context)));
+
       switch (node.op) {
         case 'SETOP_NONE':
           output.push('NONE');
           break;
+
         case 'SETOP_UNION':
           output.push('UNION');
           break;
+
         case 'SETOP_INTERSECT':
           output.push('INTERSECT');
           break;
+
         case 'SETOP_EXCEPT':
           output.push('EXCEPT');
           break;
+
         default:
           throw new Error('bad SelectStmt op');
       }
+
       if (node.all) {
         output.push('ALL');
       }
+
       output.push(parens(this.SelectStmt(node.rarg, context)));
     }
+
     if (node.distinctClause) {
       const distinctClause = unwrapList(node.distinctClause);
-      if (!isEmptyObject(distinctClause[0])
-      // new change distinctClause can be {}
+
+      if (!isEmptyObject(distinctClause[0]) // new change distinctClause can be {}
       ) {
-        output.push('DISTINCT ON');
-        const clause = distinctClause.map(e => this.deparse(e, 'select')).join(`,${NEWLINE_CHAR}`);
-        output.push(`(${clause})`);
-      } else {
+          output.push('DISTINCT ON');
+          const clause = distinctClause.map(e => this.deparse(e, 'select')).join(`,${NEWLINE_CHAR}`);
+          output.push(`(${clause})`);
+        } else {
         output.push('DISTINCT');
       }
     }
+
     if (node.targetList) {
       output.push(indent(unwrapList(node.targetList).map(e => this.deparse(e, 'select')).join(`,${NEWLINE_CHAR}`)));
     }
+
     if (node.intoClause) {
       output.push('INTO');
       output.push(indent(this.IntoClause(node.intoClause, context)));
     }
+
     if (node.fromClause) {
       output.push('FROM');
       output.push(indent(unwrapList(node.fromClause).map(e => this.deparse(e, 'from')).join(`,${NEWLINE_CHAR}`)));
     }
+
     if (node.whereClause) {
       output.push('WHERE');
       output.push(indent(this.deparse(node.whereClause, context)));
     }
+
     if (node.valuesLists) {
       output.push('VALUES');
       const lists = unwrapList(node.valuesLists).map(list => {
@@ -1507,87 +1909,112 @@ export default class Deparser {
       });
       output.push(lists.join(', '));
     }
+
     if (node.groupClause) {
       output.push('GROUP BY');
       output.push(indent(unwrapList(node.groupClause).map(e => this.deparse(e, 'group')).join(`,${NEWLINE_CHAR}`)));
     }
+
     if (node.havingClause) {
       output.push('HAVING');
       output.push(indent(this.deparse(node.havingClause, context)));
     }
+
     if (node.windowClause) {
       output.push('WINDOW');
       const windows = [];
       const windowClause = unwrapList(node.windowClause);
+
       for (let i = 0; i < windowClause.length; i++) {
         const w = windowClause[i];
         const window = [];
+
         if (w.WindowDef.name) {
           window.push(this.quote(w.WindowDef.name) + ' AS');
         }
+
         window.push(parens(this.deparse(w, 'window')));
         windows.push(window.join(' '));
       }
+
       output.push(windows.join(', '));
     }
+
     if (node.sortClause) {
       output.push('ORDER BY');
       output.push(indent(unwrapList(node.sortClause).map(e => this.deparse(e, 'sort')).join(`,${NEWLINE_CHAR}`)));
     }
+
     if (node.limitCount) {
       output.push('LIMIT');
       output.push(indent(this.deparse(node.limitCount, context)));
     }
+
     if (node.limitOffset) {
       output.push('OFFSET');
       output.push(indent(this.deparse(node.limitOffset, context)));
     }
+
     if (node.lockingClause) {
       node.lockingClause.forEach(item => {
         return output.push(this.deparse(item, context));
       });
     }
+
     return output.join(' ');
   }
+
   ['TruncateStmt'](node, context = {}) {
     const output = ['TRUNCATE TABLE'];
     output.push(this.list(node.relations, ', ', '', 'truncate'));
+
     if (node.restart_seqs) {
       output.push('RESTART IDENTITY');
     }
+
     if (node.behavior === 'DROP_CASCADE') {
       output.push('CASCADE');
     }
+
     return output.join(' ');
   }
+
   ['AlterDefaultPrivilegesStmt'](node, context = {}) {
     const output = [];
     output.push('ALTER DEFAULT PRIVILEGES');
     const options = unwrapList(dotty.get(node, 'options'));
+
     if (options) {
       const elem = options.find(el => el.hasOwnProperty('DefElem'));
       const elemDefElemArg = unwrapList(elem.DefElem.arg);
+
       if (elem.DefElem.defname === 'schemas') {
         output.push('IN SCHEMA');
         output.push(elemDefElemArg[0].String.str);
       }
+
       if (elem.DefElem.defname === 'roles') {
         output.push('FOR ROLE');
         const roleSpec = elemDefElemArg[0];
         output.push(this.deparse(roleSpec, context));
       }
+
       output.push(NEWLINE_CHAR);
     }
+
     output.push(this.GrantStmt(node.action, context));
     return output.join(' ');
   }
+
   ['AlterTableStmt'](node, context = {}) {
     const output = [];
     const ctx = Object.assign({}, context);
     output.push('ALTER');
+
     if (node.relkind === 'OBJECT_TABLE') {
       output.push('TABLE');
       const inh = dotty.get(node, 'relation.inh');
+
       if (!inh) {
         output.push('ONLY');
       }
@@ -1596,32 +2023,40 @@ export default class Deparser {
     } else {
       fail('AlterTableStmt', node);
     }
+
     if (node.missing_ok) {
       output.push('IF EXISTS');
     }
+
     ctx.alterType = node.relkind;
     output.push(this.RangeVar(node.relation, ctx));
     output.push(this.list(node.cmds, ', ', '', ctx));
     return output.join(' ');
   }
+
   ['AlterTableCmd'](node, context = {}) {
     const output = [];
     let subType = 'COLUMN';
+
     if (context && context.alterType === 'OBJECT_TYPE') {
       subType = 'ATTRIBUTE';
     }
+
     if (node.subtype === 'AT_AddColumn') {
       output.push('ADD');
       output.push(subType);
+
       if (node.missing_ok) {
         output.push('IF NOT EXISTS');
       }
+
       output.push(this.quote(node.name));
       output.push(this.deparse(node.def, context));
     } else if (node.subtype === 'AT_ColumnDefault') {
       output.push('ALTER');
       output.push(subType);
       output.push(this.quote(node.name));
+
       if (node.def) {
         output.push('SET DEFAULT');
         output.push(this.deparse(node.def, context));
@@ -1655,6 +2090,7 @@ export default class Deparser {
       output.push('ALTER');
       output.push(this.quote(node.name));
       output.push('SET STORAGE');
+
       if (node.def) {
         output.push(this.deparse(node.def, context));
       } else {
@@ -1663,9 +2099,11 @@ export default class Deparser {
     } else if (node.subtype === 'AT_DropColumn') {
       output.push('DROP');
       output.push(subType);
+
       if (node.missing_ok) {
         output.push('IF EXISTS');
       }
+
       output.push(this.quote(node.name));
     } else if (node.subtype === 'AT_AddConstraint') {
       // output.push('ADD CONSTRAINT');
@@ -1676,9 +2114,11 @@ export default class Deparser {
       output.push(this.quote(node.name, context));
     } else if (node.subtype === 'AT_DropConstraint') {
       output.push('DROP CONSTRAINT');
+
       if (node.missing_ok) {
         output.push('IF EXISTS');
       }
+
       output.push(this.quote(node.name));
     } else if (node.subtype === 'AT_AlterColumnType') {
       output.push('ALTER');
@@ -1724,8 +2164,7 @@ export default class Deparser {
       output.push('OF');
       output.push(this.deparse(node.def, context));
     } else if (node.subtype === 'AT_DropOf') {
-      output.push('NOT OF');
-      //output.push(this.deparse(node.def));
+      output.push('NOT OF'); //output.push(this.deparse(node.def));
     } else if (node.subtype === 'AT_EnableRowSecurity') {
       output.push('ENABLE ROW LEVEL SECURITY');
     } else if (node.subtype === 'AT_DisableRowSecurity') {
@@ -1735,11 +2174,14 @@ export default class Deparser {
     } else if (node.subtype === 'AT_NoForceRowSecurity') {
       output.push('NO FORCE ROW SECURITY');
     }
+
     if (node.behavior === 'DROP_CASCADE') {
       output.push('CASCADE');
     }
+
     return output.join(' ');
   }
+
   ['CreateEnumStmt'](node, context = {}) {
     const output = [];
     output.push('CREATE TYPE');
@@ -1757,6 +2199,7 @@ export default class Deparser {
     output.push(`${NEWLINE_CHAR})`);
     return output.join(' ');
   }
+
   ['AlterEnumStmt'](node, context = {}) {
     const output = [];
     output.push('ALTER TYPE');
@@ -1766,25 +2209,31 @@ export default class Deparser {
       }
     };
     output.push(this.deparse(typObj, context));
+
     if (node.newVal) {
       output.push('ADD VALUE');
       const result = node.newVal.replace(/'/g, "''");
       output.push(`'${result}'`);
     }
+
     if (node.newValNeighbor) {
       if (node.newValIsAfter) {
         output.push('AFTER');
       } else {
         output.push('BEFORE');
       }
+
       const result = node.newValNeighbor.replace(/'/g, "''");
       output.push(`'${result}'`);
     }
+
     if (node.behavior === 'DROP_CASCADE') {
       output.push('CASCADE');
     }
+
     return output.join(' ');
   }
+
   ['AlterDomainStmt'](node, context = {}) {
     const output = [];
     output.push('ALTER DOMAIN');
@@ -1794,6 +2243,7 @@ export default class Deparser {
       }
     };
     output.push(this.deparse(typObj, context));
+
     if (node.subtype === 'C') {
       output.push('ADD');
       output.push(this.deparse(node.def, context));
@@ -1806,43 +2256,56 @@ export default class Deparser {
       output.push('CONSTRAINT');
       output.push(this.quote(node.name));
     }
+
     if (node.behavior === 'DROP_CASCADE') {
       output.push('CASCADE');
     }
+
     return output.join(' ');
   }
+
   ['CreateExtensionStmt'](node) {
     const output = [];
     output.push('CREATE EXTENSION');
+
     if (node.if_not_exists) {
       output.push('IF NOT EXISTS');
     }
+
     output.push(this.quote(node.extname));
+
     if (node.options) {
       node.options.forEach(opt => {
         if (opt.DefElem.defname === 'cascade' && opt.DefElem.arg.Integer.ival === 1) {
           output.push('CASCADE');
         }
+
         if (opt.DefElem.defname === 'schema') {
           output.push('WITH SCHEMA');
           output.push(this.quote(this.deparse(opt.DefElem.arg)));
         }
       });
     }
+
     return output.join(' ');
   }
+
   ['DropStmt'](node, context = {}) {
     const output = [];
     output.push('DROP');
     output.push(objtypeName(node.removeType));
+
     if (node.missing_ok) {
       output.push('IF EXISTS');
     }
+
     const stmts = [];
     const objects = unwrapList(node.objects);
+
     for (let s = 0; s < objects.length; s++) {
       const children = unwrapList(objects[s]);
       const stmt = [];
+
       if (node.removeType === 'OBJECT_TABLE' || node.removeType === 'OBJECT_CONVERSION' || node.removeType === 'OBJECT_COLLATION' || node.removeType === 'OBJECT_MATVIEW' || node.removeType === 'OBJECT_INDEX' || node.removeType === 'OBJECT_FOREIGN_TABLE') {
         if (children.length === 1) {
           stmt.push(this.quote(this.deparse(children[0])));
@@ -1898,15 +2361,14 @@ export default class Deparser {
           stmt.push(this.listQuotes(children, '.'));
         } else {
           throw new Error('bad drop value stmt: ' + JSON.stringify(node, null, 2));
-        }
-        // } else if (node.removeType === 'OBJECT_OPERATOR') {
+        } // } else if (node.removeType === 'OBJECT_OPERATOR') {
+
       } else if (node.removeType === 'OBJECT_CAST') {
         stmt.push('(');
         stmt.push(this.deparse(children[0], context));
         stmt.push('AS');
         stmt.push(this.deparse(children[1], context));
-        stmt.push(')');
-        // } else if (node.removeType === 'OBJECT_OPERATOR') {
+        stmt.push(')'); // } else if (node.removeType === 'OBJECT_OPERATOR') {
         //   stmt.push(this.deparse(children, 'noquotes')); // in this case children is not an array
       } else if (node.removeType === 'OBJECT_AGGREGATE') {
         stmt.push(this.deparse(children, context)); // in this case children is not an array
@@ -1925,146 +2387,181 @@ export default class Deparser {
       } else {
         throw new Error('bad drop stmt: ' + JSON.stringify(node, null, 2));
       }
+
       stmts.push(stmt.join(' '));
     }
+
     output.push(stmts.join(','));
+
     if (node.behavior === 'DROP_CASCADE') {
       output.push('CASCADE');
     }
+
     return output.join(' ');
   }
+
   ['CreatePolicyStmt'](node, context = {}) {
     const output = [];
     output.push('CREATE POLICY');
     output.push(this.quote(node.policy_name));
+
     if (node.table) {
       output.push('ON');
       output.push(this.RangeVar(node.table, context));
     }
-    if (node.permissive) {
-      // permissive is the default!
+
+    if (node.permissive) {// permissive is the default!
     } else {
       output.push('AS');
       output.push('RESTRICTIVE');
     }
+
     if (node.cmd_name) {
       output.push('FOR');
       output.push(node.cmd_name.toUpperCase());
     }
+
     output.push('TO');
     output.push(this.list(node.roles));
+
     if (node.qual) {
       output.push('USING');
       output.push('(');
       output.push(this.deparse(node.qual, context));
       output.push(')');
     }
+
     if (node.with_check) {
       output.push('WITH CHECK');
       output.push('(');
       output.push(this.deparse(node.with_check, context));
       output.push(')');
     }
+
     return output.join(' ');
   }
+
   ['AlterPolicyStmt'](node, context = {}) {
     const output = [];
     output.push('ALTER POLICY');
     output.push(this.quote(node.policy_name));
+
     if (node.table) {
       output.push('ON');
       output.push(this.RangeVar(node.table, context));
     }
+
     output.push('TO');
     output.push(this.list(node.roles));
+
     if (node.qual) {
       output.push('USING');
       output.push('(');
       output.push(this.deparse(node.qual, context));
       output.push(')');
     }
+
     if (node.with_check) {
       output.push('WITH CHECK');
       output.push('(');
       output.push(this.deparse(node.with_check, context));
       output.push(')');
     }
+
     return output.join(' ');
   }
+
   ['ViewStmt'](node, context = {}) {
     const output = [];
     output.push('CREATE');
     if (node.replace) output.push('OR REPLACE');
+
     if (node.view.relpersistence === 't') {
       output.push('TEMPORARY');
     }
+
     output.push('VIEW');
     output.push(this.RangeVar(node.view, 'view'));
+
     if (node.aliases) {
       output.push('(');
       output.push(this.list(node.aliases, ', ', '', context));
       output.push(')');
     }
+
     output.push('AS');
     output.push(this.deparse(node.query, context));
+
     if (node.withCheckOption === 'LOCAL_CHECK_OPTION') {
       output.push('WITH LOCAL CHECK OPTION');
     } else if (node.withCheckOption === 'CASCADED_CHECK_OPTION') {
       output.push('WITH CASCADED CHECK OPTION');
     }
+
     return output.join(' ');
   }
+
   ['CreateSeqStmt'](node, context = {}) {
     const output = [];
     output.push('CREATE SEQUENCE');
     output.push(this.RangeVar(node.sequence, context));
     const options = unwrapList(node.options);
+
     if (options && options.length) {
       options.forEach(opt => {
         output.push(this.deparse(opt, 'sequence'));
       });
     }
+
     return output.join(' ');
   }
+
   ['AlterSeqStmt'](node, context = {}) {
     const output = [];
     output.push('ALTER SEQUENCE');
     output.push(this.RangeVar(node.sequence, context));
     const options = unwrapList(node.options);
+
     if (options && options.length) {
       options.forEach(opt => {
         output.push(this.deparse(opt, 'sequence'));
       });
     }
+
     return output.join(' ');
   }
+
   ['CreateTableAsStmt'](node, context = {}) {
     const output = ['CREATE'];
     const relpersistence = dotty.get(node, 'into.rel.relpersistence');
+
     if (node.relkind === 'OBJECT_MATVIEW') {
       output.push('MATERIALIZED VIEW');
     } else if (relpersistence !== 't') {
       output.push('TABLE');
+
       if (node.if_not_exists) {
         output.push('IF NOT EXISTS');
       }
     }
+
     output.push(this.IntoClause(node.into, context));
     output.push('AS');
     output.push(this.deparse(node.query, context));
     return output.join(' ');
   }
+
   ['CreateTrigStmt'](node, context = {}) {
     const output = [];
     output.push('CREATE');
+
     if (node.isconstraint) {
       output.push('CONSTRAINT');
     }
+
     output.push('TRIGGER');
     output.push(this.quote(node.trigname));
-    output.push(NEWLINE_CHAR);
-
-    // int16 timing;  BEFORE, AFTER, or INSTEAD
+    output.push(NEWLINE_CHAR); // int16 timing;  BEFORE, AFTER, or INSTEAD
 
     if (node.timing === 64) {
       output.push('INSTEAD OF');
@@ -2072,15 +2569,13 @@ export default class Deparser {
       output.push('BEFORE');
     } else {
       output.push('AFTER');
-    }
-
-    // int16 events;  "OR" of INSERT/UPDATE/DELETE/TRUNCATE
-
+    } // int16 events;  "OR" of INSERT/UPDATE/DELETE/TRUNCATE
     //  4 = 0b000100 (insert)
     //  8 = 0b001000 (delete)
     // 16 = 0b010000 (update)
     // 32 = 0b100000 (TRUNCATE)
 
+
     const TRIGGER_EVENTS = {
       INSERT: 4,
       DELETE: 8,
@@ -2088,32 +2583,36 @@ export default class Deparser {
       TRUNCATE: 32
     };
     const events = [];
+
     if ((TRIGGER_EVENTS.INSERT & node.events) === TRIGGER_EVENTS.INSERT) {
       events.push('INSERT');
     }
+
     if ((TRIGGER_EVENTS.UPDATE & node.events) === TRIGGER_EVENTS.UPDATE) {
       events.push('UPDATE');
     }
+
     if ((TRIGGER_EVENTS.DELETE & node.events) === TRIGGER_EVENTS.DELETE) {
       events.push('DELETE');
     }
+
     if ((TRIGGER_EVENTS.TRUNCATE & node.events) === TRIGGER_EVENTS.TRUNCATE) {
       events.push('TRUNCATE');
-    }
+    } // events
 
-    // events
-    output.push(events.join(' OR '));
 
-    // columns
+    output.push(events.join(' OR ')); // columns
+
     if (node.columns) {
       output.push('OF');
       output.push(this.list(node.columns, ', ', '', context));
-    }
+    } // ON
+
 
-    // ON
     output.push('ON');
     output.push(this.RangeVar(node.relation, context));
     output.push(NEWLINE_CHAR);
+
     if (node.transitionRels) {
       output.push('REFERENCING');
       node.transitionRels.forEach(({
@@ -2125,23 +2624,27 @@ export default class Deparser {
           output.push(`OLD TABLE AS ${TriggerTransition.name}`);
         }
       });
-    }
+    } // opts
+
 
-    // opts
     if (node.deferrable || node.initdeferred) {
       if (node.deferrable) {
         output.push('DEFERRABLE');
       }
+
       if (node.deferrable) {
         output.push('INITIALLY DEFERRED');
       }
+
       output.push(NEWLINE_CHAR);
     }
+
     if (node.row) {
       output.push(`FOR EACH ROW${NEWLINE_CHAR}`);
     } else {
       output.push(`FOR EACH STATEMENT${NEWLINE_CHAR}`);
     }
+
     if (node.whenClause) {
       output.push('WHEN');
       output.push('(');
@@ -2149,56 +2652,69 @@ export default class Deparser {
       output.push(')');
       output.push(NEWLINE_CHAR);
     }
+
     output.push('EXECUTE PROCEDURE');
     output.push(this.listQuotes(node.funcname).split(',').join('.'));
     output.push('(');
     let args = [];
+
     if (node.args) {
       args = unwrapList(node.args);
-    }
-    // seems that it's only parsing strings?
+    } // seems that it's only parsing strings?
+
+
     args = args.map(arg => {
       if (arg.String !== undefined && arg.String.str !== undefined) {
         return `'${arg.String.str}'`;
       }
+
       return this.deparse(arg, context);
     }).filter(a => a);
     output.push(args.join(','));
     output.push(')');
     return output.join(' ');
   }
+
   ['CreateDomainStmt'](node, context = {}) {
     const output = [];
     output.push('CREATE DOMAIN');
     output.push(this.list(node.domainname, '.', '', context));
     output.push('AS');
     output.push(this.TypeName(node.typeName, context));
+
     if (node.constraints) {
       output.push(this.list(node.constraints, ', ', '', context));
     }
+
     return output.join(' ');
   }
+
   ['CreateStmt'](node, context = {}) {
     const output = [];
     const relpersistence = dotty.get(node, 'relation.relpersistence');
+
     if (relpersistence === 't') {
       output.push('CREATE');
     } else {
       output.push('CREATE TABLE');
+
       if (node.if_not_exists) {
         output.push('IF NOT EXISTS');
       }
     }
+
     output.push(this.RangeVar(node.relation, context));
     output.push(`(${NEWLINE_CHAR}`);
     output.push(this.list(node.tableElts, `,${NEWLINE_CHAR}`, TAB_CHAR, context));
     output.push(`${NEWLINE_CHAR})`);
+
     if (node.hasOwnProperty('inhRelations')) {
       output.push('INHERITS');
       output.push('(');
       output.push(this.list(node.inhRelations, ', ', '', context));
       output.push(')');
     }
+
     if (node.options) {
       // TODO was this deprecated?
       node.options.forEach(opt => {
@@ -2211,27 +2727,34 @@ export default class Deparser {
         }
       });
     }
+
     return output.join(' ');
   }
+
   ['ConstraintStmt'](node) {
     const output = [];
     const constraint = getConstraintFromConstrType(node.contype);
+
     if (node.conname) {
       output.push('CONSTRAINT');
       output.push(node.conname);
+
       if (!node.pktable) {
         output.push(constraint);
       }
     } else if (node.contype === 'CONSTR_IDENTITY') {
       // IDENTITY
       output.push('GENERATED');
+
       if (node.generated_when == 'a') {
         output.push('ALWAYS AS');
       } else {
         output.push('BY DEFAULT AS');
       }
+
       output.push('IDENTITY');
       const options = unwrapList(node.options);
+
       if (options && options.length) {
         output.push('(');
         output.push(this.list(options, ' ', '', 'generated'));
@@ -2239,21 +2762,26 @@ export default class Deparser {
       }
     } else if (node.contype === 'CONSTR_GENERATED') {
       output.push('GENERATED');
+
       if (node.generated_when == 'a') {
         output.push('ALWAYS AS');
       }
     } else {
       output.push(constraint);
     }
+
     return output.join(' ');
   }
+
   ['ReferenceConstraint'](node, context = {}) {
     const output = [];
+
     if (node.pk_attrs && node.fk_attrs) {
       if (node.conname) {
         output.push('CONSTRAINT');
         output.push(node.conname);
       }
+
       output.push('FOREIGN KEY');
       output.push('(');
       output.push(this.listQuotes(node.fk_attrs));
@@ -2274,6 +2802,7 @@ export default class Deparser {
         output.push('CONSTRAINT');
         output.push(node.conname);
       }
+
       output.push('FOREIGN KEY');
       output.push('(');
       output.push(this.listQuotes(node.fk_attrs));
@@ -2284,23 +2813,29 @@ export default class Deparser {
       output.push(this.ConstraintStmt(node, context));
       output.push(this.RangeVar(node.pktable, context));
     }
+
     return output.join(' ');
   }
+
   ['ExclusionConstraint'](node, context = {}) {
     const output = [];
+
     function getExclusionGroup(nde) {
       const exclusions = unwrapList(nde.exclusions);
       const a = exclusions.map(excl => {
         const firstExcl = unwrapList(excl)[0];
+
         if (firstExcl.IndexElem.name) {
           return firstExcl.IndexElem.name;
         }
+
         return firstExcl.IndexElem.expr ? this.deparse(firstExcl.IndexElem.expr, context) : null;
       });
       const b = exclusions.map(excl => this.deparse(unwrapList(unwrapList(excl)[1])[0], context));
       const stmts = a.map((_v, i) => `${a[i]} WITH ${b[i]}`);
       return stmts.join(', ');
     }
+
     if (node.exclusions && node.access_method) {
       output.push('USING');
       output.push(node.access_method);
@@ -2308,107 +2843,139 @@ export default class Deparser {
       output.push(getExclusionGroup.call(this, node));
       output.push(')');
     }
+
     return output.join(' ');
   }
+
   ['Constraint'](node, context = {}) {
     const output = [];
+
     if (node.contype === 'CONSTR_FOREIGN') {
       output.push(this.ReferenceConstraint(node, context));
     } else {
       output.push(this.ConstraintStmt(node, context));
     }
+
     if (node.keys) {
       output.push('(');
       output.push(this.listQuotes(node.keys));
       output.push(')');
     }
+
     if (node.raw_expr) {
       output.push('(');
       output.push(this.deparse(node.raw_expr, context));
       output.push(')');
+
       if (node.contype == 'CONSTR_GENERATED') {
         output.push('STORED');
       }
     }
+
     if (node.fk_del_action) {
       switch (node.fk_del_action) {
         case 'r':
           output.push('ON DELETE RESTRICT');
           break;
+
         case 'c':
           output.push('ON DELETE CASCADE');
           break;
+
         case 'n':
           output.push('ON DELETE SET NULL');
           break;
+
         case 'd':
           output.push('ON DELETE SET DEFAULT');
           break;
+
         case 'a':
           // output.push('ON DELETE NO ACTION');
           break;
+
         default:
       }
     }
+
     if (node.fk_upd_action) {
       switch (node.fk_upd_action) {
         case 'r':
           output.push('ON UPDATE RESTRICT');
           break;
+
         case 'c':
           output.push('ON UPDATE CASCADE');
           break;
+
         case 'n':
           output.push('ON UPDATE SET NULL');
           break;
+
         case 'd':
           output.push('ON UPDATE SET DEFAULT');
           break;
+
         case 'a':
           // output.push('ON UPDATE NO ACTION');
           break;
+
         default:
       }
     }
+
     if (node.fk_matchtype === 'f') {
       output.push('MATCH FULL');
     }
+
     if (node.is_no_inherit === true) {
       output.push('NO INHERIT');
     }
+
     if (node.skip_validation === true) {
       output.push('NOT VALID');
     }
+
     if (node.contype === 'CONSTR_EXCLUSION') {
       output.push(this.ExclusionConstraint(node, context));
     }
+
     if (node.deferrable) {
       output.push('deferrable');
     }
+
     return output.join(' ');
   }
+
   ['AccessPriv'](node) {
     const output = [];
+
     if (node.priv_name) {
       output.push(node.priv_name.toUpperCase());
     } else {
       output.push('ALL');
     }
+
     if (node.cols) {
       output.push('(');
       output.push(this.listQuotes(node.cols));
       output.push(')');
     }
+
     return output.join(' ');
   }
+
   ['VariableSetStmt'](node) {
     switch (node.kind) {
       case 'VAR_SET_VALUE':
         return format('SET %s%s = %s', node.is_local ? 'LOCAL ' : '', node.name, this.deparseNodes(node.args, 'simple').join(', '));
+
       case 'VAR_SET_DEFAULT':
         return format('SET %s TO DEFAULT', node.name);
+
       case 'VAR_SET_CURRENT':
         return format('SET %s FROM CURRENT', node.name);
+
       case 'VAR_SET_MULTI':
         {
           const name = {
@@ -2417,17 +2984,22 @@ export default class Deparser {
           }[node.name];
           return format('SET %s %s', name, this.deparseNodes(node.args, 'simple').join(', '));
         }
+
       case 'VAR_RESET':
         return format('RESET %s', node.name);
+
       case 'VAR_RESET_ALL':
         return 'RESET ALL';
+
       default:
         return fail('VariableSetKind', node);
     }
   }
+
   ['VariableShowStmt'](node) {
     return format('SHOW %s', node.name);
   }
+
   ['FuncWithArgs'](node, context = {}) {
     const output = [];
     output.push(this.deparse(unwrapList(node.funcname)[0], context));
@@ -2436,38 +3008,50 @@ export default class Deparser {
     output.push(')');
     return output.join(' ');
   }
+
   ['FunctionParameter'](node, context = {}) {
     const output = [];
+
     if (node.mode === 'FUNC_PARAM_VARIADIC') {
       output.push('VARIADIC');
     }
+
     if (node.mode === 'FUNC_PARAM_OUT') {
       output.push('OUT');
     }
+
     if (node.mode === 'FUNC_PARAM_INOUT') {
       output.push('INOUT');
     }
+
     output.push(node.name);
     output.push(this.TypeName(node.argType, context));
+
     if (node.defexpr) {
       output.push('DEFAULT');
       output.push(this.deparse(node.defexpr, context));
     }
+
     return output.join(' ');
   }
+
   ['CreateFunctionStmt'](node, context = {}) {
     const output = [];
     output.push('CREATE');
+
     if (node.replace) {
       output.push('OR REPLACE');
     }
+
     output.push('FUNCTION');
     output.push(unwrapList(node.funcname).map(name => this.deparse(name, context)).join('.'));
     output.push('(');
     let parameters = [];
+
     if (node.parameters) {
       parameters = unwrapList(node.parameters);
     }
+
     const parametersList = parameters.filter(({
       FunctionParameter
     }) => FunctionParameter.mode === 'FUNC_PARAM_VARIADIC' || FunctionParameter.mode === 'FUNC_PARAM_OUT' || FunctionParameter.mode === 'FUNC_PARAM_INOUT' || FunctionParameter.mode === 'FUNC_PARAM_IN');
@@ -2476,6 +3060,7 @@ export default class Deparser {
     const returns = parameters.filter(({
       FunctionParameter
     }) => FunctionParameter.mode === 'FUNC_PARAM_TABLE');
+
     if (returns.length > 0) {
       output.push('RETURNS');
       output.push('TABLE');
@@ -2486,151 +3071,204 @@ export default class Deparser {
       output.push('RETURNS');
       output.push(this.TypeName(node.returnType, context));
     }
+
     node.options.forEach((option, i) => {
       if (option && option.DefElem) {
         let value = '';
+
         switch (option.DefElem.defname) {
           case 'as':
             value = this.deparse(unwrapList(option.DefElem.arg)[0], context);
             output.push(`AS $EOFCODE$${value}$EOFCODE$`);
             break;
+
           case 'language':
             value = this.deparse(option.DefElem.arg, context);
             output.push('LANGUAGE');
             output.push(value);
             break;
+
           case 'security':
             output.push('SECURITY');
             value = Number(option.DefElem.arg.Integer.ival);
+
             if (value > 0) {
               output.push('DEFINER');
             } else {
               output.push('INVOKER');
             }
+
             break;
+
           case 'leakproof':
             value = Number(option.DefElem.arg.Integer.ival);
+
             if (value > 0) {
               output.push('LEAKPROOF');
             }
+
             break;
+
           case 'window':
             value = Number(option.DefElem.arg.Integer.ival);
+
             if (value > 0) {
               output.push('WINDOW');
             }
+
             break;
+
           case 'strict':
             value = Number(option.DefElem.arg.Integer.ival);
+
             if (value > 0) {
               output.push('STRICT');
             } else {
               output.push('CALLED ON NULL INPUT');
             }
+
             break;
+
           case 'set':
             output.push(this.deparse(option, context));
             break;
+
           case 'volatility':
             value = this.deparse(option.DefElem.arg, context);
             output.push(value.toUpperCase());
             break;
+
           default:
         }
       }
     });
     return output.join(' ');
   }
+
   ['CreateSchemaStmt'](node) {
     const output = [];
     output.push('CREATE');
+
     if (node.replace) {
       output.push('OR REPLACE');
     }
+
     output.push('SCHEMA');
+
     if (node.if_not_exists) {
       output.push('IF NOT EXISTS');
     }
+
     output.push(node.schemaname);
     return output.join(' ');
   }
+
   ['RoleSpec'](node) {
     switch (node.roletype) {
       case 'ROLESPEC_CSTRING':
         return this.quote(node.rolename);
+
       case 'ROLESPEC_CURRENT_USER':
         return 'CURRENT_USER';
+
       case 'ROLESPEC_SESSION_USER':
         return 'SESSION_USER';
+
       case 'ROLESPEC_PUBLIC':
         return 'PUBLIC';
+
       default:
         return fail('RoleSpec', node);
     }
   }
+
   ['GrantStmt'](node) {
     const output = [];
+
     const getTypeFromNode = nodeObj => {
       switch (nodeObj.objtype) {
         case 'OBJECT_TABLE':
           if (nodeObj.targtype === 'ACL_TARGET_ALL_IN_SCHEMA') {
             return 'ALL TABLES IN SCHEMA';
           }
+
           if (nodeObj.targtype === 'ACL_TARGET_DEFAULTS') {
             return 'TABLES';
-          }
-          // todo could be view
+          } // todo could be view
+
+
           return 'TABLE';
+
         case 'OBJECT_SEQUENCE':
           if (nodeObj.targtype === 'ACL_TARGET_ALL_IN_SCHEMA') {
             return 'ALL SEQUENCES IN SCHEMA';
           }
+
           if (nodeObj.targtype === 'ACL_TARGET_DEFAULTS') {
             return 'SEQUENCES';
           }
+
           return 'SEQUENCE';
+
         case 'OBJECT_DATABASE':
           return 'DATABASE';
+
         case 'OBJECT_DOMAIN':
           return 'DOMAIN';
+
         case 'OBJECT_FDW':
           return 'FOREIGN DATA WRAPPER';
+
         case 'OBJECT_FOREIGN_SERVER':
           return 'FOREIGN SERVER';
+
         case 'OBJECT_FUNCTION':
           if (nodeObj.targtype === 'ACL_TARGET_ALL_IN_SCHEMA') {
             return 'ALL FUNCTIONS IN SCHEMA';
           }
+
           if (nodeObj.targtype === 'ACL_TARGET_DEFAULTS') {
             return 'FUNCTIONS';
           }
+
           return 'FUNCTION';
+
         case 'OBJECT_LANGUAGE':
           return 'LANGUAGE';
+
         case 'OBJECT_LARGEOBJECT':
           return 'LARGE OBJECT';
+
         case 'OBJECT_SCHEMA':
           return 'SCHEMA';
+
         case 'OBJECT_TABLESPACE':
           return 'TABLESPACE';
+
         case 'OBJECT_TYPE':
           return 'TYPE';
+
         default:
       }
+
       return fail('GrantStmt', node);
     };
+
     if (node.objtype !== 'OBJECT_COLUMN') {
       if (!node.is_grant) {
         output.push('REVOKE');
+
         if (node.grant_option) {
           output.push('GRANT OPTION');
           output.push('FOR');
         }
+
         if (node.privileges) {
           output.push(this.list(node.privileges));
         } else {
           output.push('ALL');
         }
+
         output.push('ON');
         output.push(getTypeFromNode(node));
         output.push(this.list(node.objects));
@@ -2638,28 +3276,35 @@ export default class Deparser {
         output.push(this.list(node.grantees));
       } else {
         output.push('GRANT');
+
         if (node.privileges) {
           output.push(this.list(node.privileges));
         } else {
           output.push('ALL');
         }
+
         output.push('ON');
         output.push(getTypeFromNode(node));
         output.push(this.list(node.objects));
         output.push('TO');
         output.push(this.list(node.grantees));
+
         if (node.grant_option) {
           output.push('WITH GRANT OPTION');
         }
       }
+
       if (node.behavior === 'DROP_CASCADE') {
         output.push('CASCADE');
       }
     }
+
     return output.join(' ');
   }
+
   ['GrantRoleStmt'](node, context = {}) {
     const output = [];
+
     if (!node.is_grant) {
       output.push('REVOKE');
       output.push(this.list(node.granted_roles, ', ', '', context));
@@ -2671,291 +3316,385 @@ export default class Deparser {
       output.push('TO');
       output.push(this.list(node.grantee_roles, ', ', '', context));
     }
+
     if (node.admin_opt) {
       output.push('WITH ADMIN OPTION');
     }
+
     return output.join(' ');
   }
+
   ['CreateRoleStmt'](node, context = {}) {
     const output = [];
+
     const roleOption = (nodeObj, i, val1, val2) => {
       const val = Number(dotty.get(unwrapList(nodeObj.options), `${i}.DefElem.arg.Integer.ival`));
+
       if (val > 0) {
         output.push(val1);
       } else {
         output.push(val2);
       }
     };
+
     output.push('CREATE');
+
     switch (node.stmt_type) {
       case 'ROLESTMT_USER':
         output.push('USER');
         break;
+
       case 'ROLESTMT_GROUP':
         output.push('GROUP');
         break;
+
       default:
         output.push('ROLE');
     }
+
     output.push(`"${node.role}"`);
+
     if (node.options) {
       const options = unwrapList(node.options);
       const opts = dotty.search(options, '*.DefElem.defname');
-      if (opts.length === 1 && opts[0] === 'addroleto') {
-        // only one case
+
+      if (opts.length === 1 && opts[0] === 'addroleto') {// only one case
       } else {
         output.push('WITH');
       }
+
       opts.forEach((option, i) => {
         let value = '';
+
         switch (option) {
           case 'canlogin':
             roleOption(node, i, 'LOGIN', 'NOLOGIN');
             break;
+
           case 'addroleto':
             output.push('IN ROLE');
             output.push(dotty.search(flatten(dotty.search(options, `${i}.DefElem.arg`).map(unwrapList)), '*.RoleSpec.rolename').join(','));
             break;
+
           case 'password':
             output.push('PASSWORD');
             value = dotty.get(options, `${i}.DefElem.arg.String.str`);
             output.push(`'${value}'`);
             break;
+
           case 'adminmembers':
             output.push('ADMIN');
             output.push(this.list(options[i].DefElem.arg, ', ', '', context));
             break;
+
           case 'rolemembers':
             output.push('USER');
             output.push(this.list(options[i].DefElem.arg, ', ', '', context));
             break;
+
           case 'createdb':
             roleOption(node, i, 'CREATEDB', 'NOCREATEDB');
             break;
+
           case 'isreplication':
             roleOption(node, i, 'REPLICATION', 'NOREPLICATION');
             break;
+
           case 'bypassrls':
             roleOption(node, i, 'BYPASSRLS', 'NOBYPASSRLS');
             break;
+
           case 'inherit':
             roleOption(node, i, 'INHERIT', 'NOINHERIT');
             break;
+
           case 'superuser':
             roleOption(node, i, 'SUPERUSER', 'NOSUPERUSER');
             break;
+
           case 'createrole':
             roleOption(node, i, 'CREATEROLE', 'NOCREATEROLE');
             break;
+
           case 'validUntil':
             output.push('VALID UNTIL');
             value = dotty.get(options[i], `DefElem.arg.String.str`);
             output.push(`'${value}'`);
             break;
+
           default:
         }
       });
     }
+
     return output.join(' ');
   }
+
   ['TransactionStmt'](node, context = {}) {
     const output = [];
+
     const begin = nodeOpts => {
       const options = unwrapList(nodeOpts.options);
       const opts = options ? dotty.search(options, '*.DefElem.defname') : [];
+
       if (opts.includes('transaction_read_only')) {
         const index = opts.indexOf('transaction_read_only');
         const obj = options[index];
         let set = false;
         const flag = Number(this.deparse(dotty.get(obj, 'DefElem.arg'), context));
+
         if (flag > 0) {
           set = true;
         }
+
         if (set) {
           return 'BEGIN TRANSACTION READ ONLY';
         }
+
         return 'BEGIN TRANSACTION READ WRITE';
       }
+
       if (opts.includes('transaction_isolation')) {
         const index = opts.indexOf('transaction_isolation');
         const obj = options[index];
         const lopts = this.deparse(dotty.get(obj, 'DefElem.arg'), context).replace(/['"]+/g, '');
         return `BEGIN TRANSACTION ISOLATION LEVEL ${lopts.toUpperCase()}`;
       }
+
       return 'BEGIN';
     };
+
     const start = nodeOpts => {
       const options = unwrapList(nodeOpts.options);
       const opts = options ? dotty.search(options, '*.DefElem.defname') : [];
+
       if (opts.includes('transaction_read_only')) {
         const index = opts.indexOf('transaction_read_only');
         const obj = options[index];
         let set = false;
         const flag = Number(this.deparse(dotty.get(obj, 'DefElem.arg'), context));
+
         if (flag > 0) {
           set = true;
         }
+
         if (set) {
           return 'START TRANSACTION READ ONLY';
         }
+
         return 'START TRANSACTION READ WRITE';
       }
+
       return 'START TRANSACTION';
     };
+
     const nodeOptions = unwrapList(node.options);
+
     switch (node.kind) {
       case 'TRANS_STMT_BEGIN':
         return begin(node);
+
       case 'TRANS_STMT_START':
         return start(node);
+
       case 'TRANS_STMT_COMMIT':
         return 'COMMIT';
+
       case 'TRANS_STMT_ROLLBACK':
         return 'ROLLBACK';
+
       case 'TRANS_STMT_SAVEPOINT':
         output.push('SAVEPOINT');
         output.push(this.deparse(nodeOptions[0].DefElem.arg, context));
         break;
+
       case 'TRANS_STMT_RELEASE':
         output.push('RELEASE SAVEPOINT');
         output.push(this.deparse(nodeOptions[0].DefElem.arg, context));
         break;
+
       case 'TRANS_STMT_ROLLBACK_TO':
         output.push('ROLLBACK TO');
         output.push(this.deparse(nodeOptions[0].DefElem.arg, context));
         break;
+
       case 'TRANS_STMT_PREPARE':
         output.push('PREPARE TRANSACTION');
         output.push(`'${node.gid}'`);
         break;
+
       case 'TRANS_STMT_COMMIT_PREPARED':
         output.push('COMMIT PREPARED');
         output.push(`'${node.gid}'`);
         break;
+
       case 'TRANS_STMT_ROLLBACK_PREPARED':
         output.push('ROLLBACK PREPARED');
         output.push(`'${node.gid}'`);
         break;
+
       default:
     }
+
     return output.join(' ');
   }
+
   ['SortBy'](node, context = {}) {
     const output = [];
     output.push(this.deparse(node.node, context));
+
     switch (node.sortby_dir) {
       case 'SORTBY_ASC':
         output.push('ASC');
         break;
+
       case 'SORTBY_DESC':
         output.push('DESC');
         break;
+
       case 'SORTBY_USING':
         output.push(`USING ${this.deparseNodes(node.useOp, context)}`);
         break;
+
       case 'SORTBY_DEFAULT':
         break;
+
       default:
         return fail('SortBy', node);
     }
+
     if (node.sortby_nulls === 'SORTBY_NULLS_FIRST') {
       output.push('NULLS FIRST');
     }
+
     if (node.sortby_nulls === 'SORTBY_NULLS_LAST') {
       output.push('NULLS LAST');
     }
+
     return output.join(' ');
   }
+
   ['ObjectWithArgs'](node, context = {}) {
     const output = [];
+
     if (context === 'noquotes') {
       output.push(this.list(node.objname, ', ', '', context));
     } else {
       output.push(this.listQuotes(node.objname, '.'));
     }
+
     const objargs = unwrapList(node.objargs);
+
     if (objargs && objargs.length) {
       output.push('(');
       output.push(objargs.map(arg => {
         if (isEmptyObject(arg)) {
           return 'NONE';
         }
+
         return this.deparse(arg, context);
       }).join(','));
       output.push(')');
     } else if (!node.args_unspecified) {
       output.push('()');
     }
+
     return output.join(' ');
   }
+
   ['String'](node) {
     return node.str;
   }
+
   ['SubLink'](node, context = {}) {
     switch (true) {
       case node.subLinkType === 'EXISTS_SUBLINK':
         return format('EXISTS (%s)', this.deparse(node.subselect, context));
+
       case node.subLinkType === 'ALL_SUBLINK':
         return format('%s %s ALL (%s)', this.deparse(node.testexpr, context), this.deparse(node.operName[0], context), this.deparse(node.subselect, context));
+
       case node.subLinkType === 'ANY_SUBLINK' && !(node.operName != null):
         return format('%s IN (%s)', this.deparse(node.testexpr, context), this.deparse(node.subselect, context));
+
       case node.subLinkType === 'ANY_SUBLINK':
         return format('%s %s ANY (%s)', this.deparse(node.testexpr, context), this.deparse(node.operName[0], context), this.deparse(node.subselect, context));
+
       case node.subLinkType === 'ROWCOMPARE_SUBLINK':
         return format('%s %s (%s)', this.deparse(node.testexpr, context), this.deparse(node.operName[0], context), this.deparse(node.subselect, context));
+
       case node.subLinkType === 'EXPR_SUBLINK':
         return format('(%s)', this.deparse(node.subselect, context));
+
       case node.subLinkType === 'MULTIEXPR_SUBLINK':
         // TODO(zhm) what is this?
         return fail('SubLink', node);
       // MULTIEXPR_SUBLINK
       // format('(%s)', @deparse(node.subselect))
+
       case node.subLinkType === 'ARRAY_SUBLINK':
         return format('ARRAY (%s)', this.deparse(node.subselect, context));
+
       default:
         return fail('SubLink', node);
     }
   }
+
   ['TypeCast'](node, context = {}) {
     const type = this.TypeName(node.typeName, context);
     let arg = this.deparse(node.arg, context);
+
     if (node.arg !== undefined && node.arg.A_Expr !== undefined) {
       arg = format('(%s)', arg);
     }
+
     if (type === 'boolean') {
       const value = dotty.get(node, 'arg.A_Const.val.String.str');
+
       if (value === 'f') {
         return 'FALSE';
       }
+
       if (value === 't') {
         return 'TRUE';
       }
     }
+
     return format('%s::%s', arg, type);
   }
+
   ['TypeName'](node, context = {}) {
     const names = unwrapList(node.names);
+
     if (names[names.length - 1].String.str === 'interval') {
       return this.deparseInterval(node);
     }
+
     const output = [];
+
     if (node.setof) {
       output.push('SETOF');
     }
+
     let args = null;
+
     if (node.typmods != null) {
       args = unwrapList(node.typmods).map(item => {
         return this.deparse(item, context);
       });
     }
+
     const type = [];
     type.push(this.type(names, args && args.join(', ')));
+
     if (node.arrayBounds != null) {
       type.push('[]');
     }
+
     output.push(type.join(''));
     return output.join(' ');
   }
+
   ['CaseWhen'](node, context = {}) {
     const output = ['WHEN'];
     output.push(this.deparse(node.expr, context));
@@ -2963,20 +3702,26 @@ export default class Deparser {
     output.push(this.deparse(node.result, context));
     return output.join(' ');
   }
+
   ['WindowDef'](node, context = {}) {
     const output = [];
+
     if (context !== 'window') {
       if (node.name) {
         output.push(node.name);
       }
     }
+
     const empty = !(node.partitionClause != null) && !(node.orderClause != null);
     const frameOptions = this.deparseFrameOptions(node.frameOptions, node.refname, node.startOffset, node.endOffset);
+
     if (empty && context !== 'window' && !(node.name != null) && frameOptions.length === 0) {
       return '()';
     }
+
     const windowParts = [];
     let useParens = false;
+
     if (node.partitionClause) {
       const partition = ['PARTITION BY'];
       const clause = unwrapList(node.partitionClause).map(item => this.deparse(item, context));
@@ -2984,6 +3729,7 @@ export default class Deparser {
       windowParts.push(partition.join(' '));
       useParens = true;
     }
+
     if (node.orderClause) {
       windowParts.push('ORDER BY');
       const orders = unwrapList(node.orderClause).map(item => {
@@ -2992,38 +3738,49 @@ export default class Deparser {
       windowParts.push(orders.join(', '));
       useParens = true;
     }
+
     if (frameOptions.length) {
       useParens = true;
       windowParts.push(frameOptions);
     }
+
     if (useParens && context !== 'window') {
       return output.join(' ') + ' (' + windowParts.join(' ') + ')';
     }
+
     return output.join(' ') + windowParts.join(' ');
   }
+
   ['WithClause'](node, context = {}) {
     const output = ['WITH'];
+
     if (node.recursive) {
       output.push('RECURSIVE');
     }
+
     output.push(this.list(node.ctes, ', ', '', context));
     return output.join(' ');
   }
+
   ['CopyStmt'](node, context = {}) {
     const output = ['COPY'];
     output.push('(' + this.deparse(node.query, context) + ')');
     output.push('TO');
     output.push(`'${node.filename}'`);
     const options = unwrapList(node.options);
+
     if (options?.length > 0 && options[0].DefElem.defname === 'format') {
       output.push(`(FORMAT '${this.deparse(options[0].DefElem.arg)}')`);
     }
+
     return output.join(' ');
   }
+
   ['CallStmt'](node, context = {}) {
     const output = ['CALL'];
     output.push(this.deparse(unwrapList(node.funccall.funcname)[0]));
     const funccallArgs = unwrapList(node.funccall.args);
+
     if (funccallArgs && funccallArgs.length) {
       // we have arguments
       output.push('(' + this.list(funccallArgs, ', ', '', context) + ')');
@@ -3031,29 +3788,65 @@ export default class Deparser {
       // just close parens
       output.push('()');
     }
+
     return output.join(' ');
   }
+
   deparseFrameOptions(options, refName, startOffset, endOffset) {
     // https://github.com/pganalyze/libpg_query/blob/442b1748d06364ecd3779bc558899176c02efaf0/src/postgres/include/nodes/parsenodes.h#L505-L522
-    const FRAMEOPTION_NONDEFAULT = 0x00001; /* any specified? */
-    const FRAMEOPTION_RANGE = 0x00002; /* RANGE behavior */
-    const FRAMEOPTION_ROWS = 0x00004; /* ROWS behavior */
-    const FRAMEOPTION_GROUPS = 0x00008; /* GROUPS behavior */
-    const FRAMEOPTION_BETWEEN = 0x00010; /* BETWEEN given? */
-    const FRAMEOPTION_START_UNBOUNDED_PRECEDING = 0x00020; /* start is U. P. */
-    const FRAMEOPTION_END_UNBOUNDED_PRECEDING = 0x00040; /* (disallowed) */
-    const FRAMEOPTION_START_UNBOUNDED_FOLLOWING = 0x00080; /* (disallowed) */
-    const FRAMEOPTION_END_UNBOUNDED_FOLLOWING = 0x00100; /* end is U. F. */
-    const FRAMEOPTION_START_CURRENT_ROW = 0x00200; /* start is C. R. */
-    const FRAMEOPTION_END_CURRENT_ROW = 0x00400; /* end is C. R. */
-    const FRAMEOPTION_START_OFFSET_PRECEDING = 0x00800; /* start is O. P. */
-    const FRAMEOPTION_END_OFFSET_PRECEDING = 0x01000; /* end is O. P. */
-    const FRAMEOPTION_START_OFFSET_FOLLOWING = 0x02000; /* start is O. F. */
-    const FRAMEOPTION_END_OFFSET_FOLLOWING = 0x04000; /* end is O. F. */
-    const FRAMEOPTION_EXCLUDE_CURRENT_ROW = 0x08000; /* omit C.R. */
-    const FRAMEOPTION_EXCLUDE_GROUP = 0x10000; /* omit C.R. & peers */
-    const FRAMEOPTION_EXCLUDE_TIES = 0x20000; /* omit C.R.'s peers */
+    const FRAMEOPTION_NONDEFAULT = 0x00001;
+    /* any specified? */
+
+    const FRAMEOPTION_RANGE = 0x00002;
+    /* RANGE behavior */
+
+    const FRAMEOPTION_ROWS = 0x00004;
+    /* ROWS behavior */
+
+    const FRAMEOPTION_GROUPS = 0x00008;
+    /* GROUPS behavior */
+
+    const FRAMEOPTION_BETWEEN = 0x00010;
+    /* BETWEEN given? */
+
+    const FRAMEOPTION_START_UNBOUNDED_PRECEDING = 0x00020;
+    /* start is U. P. */
 
+    const FRAMEOPTION_END_UNBOUNDED_PRECEDING = 0x00040;
+    /* (disallowed) */
+
+    const FRAMEOPTION_START_UNBOUNDED_FOLLOWING = 0x00080;
+    /* (disallowed) */
+
+    const FRAMEOPTION_END_UNBOUNDED_FOLLOWING = 0x00100;
+    /* end is U. F. */
+
+    const FRAMEOPTION_START_CURRENT_ROW = 0x00200;
+    /* start is C. R. */
+
+    const FRAMEOPTION_END_CURRENT_ROW = 0x00400;
+    /* end is C. R. */
+
+    const FRAMEOPTION_START_OFFSET_PRECEDING = 0x00800;
+    /* start is O. P. */
+
+    const FRAMEOPTION_END_OFFSET_PRECEDING = 0x01000;
+    /* end is O. P. */
+
+    const FRAMEOPTION_START_OFFSET_FOLLOWING = 0x02000;
+    /* start is O. F. */
+
+    const FRAMEOPTION_END_OFFSET_FOLLOWING = 0x04000;
+    /* end is O. F. */
+
+    const FRAMEOPTION_EXCLUDE_CURRENT_ROW = 0x08000;
+    /* omit C.R. */
+
+    const FRAMEOPTION_EXCLUDE_GROUP = 0x10000;
+    /* omit C.R. & peers */
+
+    const FRAMEOPTION_EXCLUDE_TIES = 0x20000;
+    /* omit C.R.'s peers */
     // const FRAMEOPTION_START_OFFSET =
     //   FRAMEOPTION_START_OFFSET_PRECEDING | FRAMEOPTION_START_OFFSET_FOLLOWING;
     // const FRAMEOPTION_END_OFFSET =
@@ -3062,7 +3855,6 @@ export default class Deparser {
     //   FRAMEOPTION_EXCLUDE_CURRENT_ROW |
     //   FRAMEOPTION_EXCLUDE_GROUP |
     //   FRAMEOPTION_EXCLUDE_TIES;
-
     // const FRAMEOPTION_DEFAULTS =
     //   FRAMEOPTION_RANGE |
     //   FRAMEOPTION_START_UNBOUNDED_PRECEDING |
@@ -3071,66 +3863,86 @@ export default class Deparser {
     if (!(options & FRAMEOPTION_NONDEFAULT)) {
       return '';
     }
+
     const output = [];
+
     if (refName != null) {
       output.push(refName);
     }
+
     if (options & FRAMEOPTION_RANGE) {
       output.push('RANGE');
     }
+
     if (options & FRAMEOPTION_ROWS) {
       output.push('ROWS');
     }
+
     const between = options & FRAMEOPTION_BETWEEN;
+
     if (between) {
       output.push('BETWEEN');
     }
+
     if (options & FRAMEOPTION_START_UNBOUNDED_PRECEDING) {
       output.push('UNBOUNDED PRECEDING');
     }
+
     if (options & FRAMEOPTION_START_UNBOUNDED_FOLLOWING) {
       output.push('UNBOUNDED FOLLOWING');
     }
+
     if (options & FRAMEOPTION_START_CURRENT_ROW) {
       output.push('CURRENT ROW');
     }
+
     if (options & FRAMEOPTION_START_OFFSET_PRECEDING) {
       output.push(this.deparse(startOffset) + ' PRECEDING');
     }
+
     if (options & FRAMEOPTION_START_OFFSET_FOLLOWING) {
       output.push(this.deparse(startOffset) + ' FOLLOWING');
     }
+
     if (between) {
       output.push('AND');
+
       if (options & FRAMEOPTION_END_UNBOUNDED_PRECEDING) {
         output.push('UNBOUNDED PRECEDING');
       }
+
       if (options & FRAMEOPTION_END_UNBOUNDED_FOLLOWING) {
         output.push('UNBOUNDED FOLLOWING');
       }
+
       if (options & FRAMEOPTION_END_CURRENT_ROW) {
         output.push('CURRENT ROW');
       }
+
       if (options & FRAMEOPTION_END_OFFSET_PRECEDING) {
         output.push(this.deparse(endOffset) + ' PRECEDING');
       }
+
       if (options & FRAMEOPTION_END_OFFSET_FOLLOWING) {
         output.push(this.deparse(endOffset) + ' FOLLOWING');
       }
     }
+
     return output.join(' ');
   }
+
   deparseInterval(node) {
     const type = ['interval'];
+
     if (node.arrayBounds != null) {
       type.push('[]');
     }
+
     if (node.typmods) {
       const nodeTypmods = unwrapList(node.typmods);
       const typmods = nodeTypmods.map(item => this.deparse(item));
-      let intervals = this.interval(typmods[0]);
+      let intervals = this.interval(typmods[0]); // SELECT interval(0) '1 day 01:23:45.6789'
 
-      // SELECT interval(0) '1 day 01:23:45.6789'
       if (nodeTypmods[0] && nodeTypmods[0].A_Const && nodeTypmods[0].A_Const.val.Integer.ival === 32767 && nodeTypmods[1] && nodeTypmods[1].A_Const != null) {
         intervals = [`(${nodeTypmods[1].A_Const.val.Integer.ival})`];
       } else {
@@ -3138,13 +3950,17 @@ export default class Deparser {
           if (part === 'second' && typmods.length === 2) {
             return 'second(' + typmods[typmods.length - 1] + ')';
           }
+
           return part;
         });
       }
+
       type.push(intervals.join(' to '));
     }
+
     return type.join(' ');
   }
+
   interval(mask) {
     // ported from https://github.com/lfittl/pg_query/blob/master/lib/pg_query/deparse/interval.rb
     if (this.MASKS == null) {
@@ -3180,9 +3996,11 @@ export default class Deparser {
         28: 'DTZMOD'
       };
     }
+
     if (this.BITS == null) {
       this.BITS = inverted(this.MASKS);
     }
+
     if (this.INTERVALS == null) {
       this.INTERVALS = {};
       this.INTERVALS[1 << this.BITS.YEAR] = ['year'];
@@ -3197,12 +4015,13 @@ export default class Deparser {
       this.INTERVALS[1 << this.BITS.DAY | 1 << this.BITS.HOUR | 1 << this.BITS.MINUTE | 1 << this.BITS.SECOND] = ['day', 'second'];
       this.INTERVALS[1 << this.BITS.HOUR | 1 << this.BITS.MINUTE] = ['hour', 'minute'];
       this.INTERVALS[1 << this.BITS.HOUR | 1 << this.BITS.MINUTE | 1 << this.BITS.SECOND] = ['hour', 'second'];
-      this.INTERVALS[1 << this.BITS.MINUTE | 1 << this.BITS.SECOND] = ['minute', 'second'];
-
-      // utils/timestamp.h
+      this.INTERVALS[1 << this.BITS.MINUTE | 1 << this.BITS.SECOND] = ['minute', 'second']; // utils/timestamp.h
       // #define INTERVAL_FULL_RANGE (0x7FFF)
+
       this.INTERVALS[this.INTERVAL_FULL_RANGE = '32767'] = [];
     }
+
     return this.INTERVALS[mask.toString()];
   }
+
 }