Merge pull request taozhi8833998#362 from taozhi8833998/feature-pg-mysql

Feature pg mysql

Author: taozhi8833998

package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-sql-parser",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "description": "simple node sql parser",
   "main": "index.js",
   "types": "index.d.ts",

pegjs/mysql.pegjs

@@ -76,7 +76,7 @@
     'THEN': true,
     'TRUE': true,
     'TRUNCATE': true,
-    'TYPE': true,   // reserved (MySQL)
+    // 'TYPE': true,   // reserved (MySQL)
 
     'UNION': true,
     'UPDATE': true,

pegjs/postgresql.pegjs

@@ -1155,7 +1155,15 @@ join_op
   / (KW_INNER __)? KW_JOIN { return 'INNER JOIN'; }
 
 table_name
-  = dt:ident __ DOT __ STAR {
+  = dt:ident schema:(__ DOT __ ident) tail:(__ DOT __ ident) {
+      const obj = { db: null, table: dt };
+      if (tail !== null) {
+        obj.db = `${dt}.${schema[3]}`;
+        obj.table = tail[3];
+      }
+      return obj;
+    }
+  / dt:ident __ DOT __ STAR {
       tableList.add(`select::${dt}::(.*)`);
       return {
         db: dt,
@@ -1695,7 +1703,7 @@ ident_name
 
 ident_start = [A-Za-z_]
 
-ident_part  = [A-Za-z0-9_]
+ident_part  = [A-Za-z0-9_\-]
 
 // to support column name like `cf1:name` in hbase
 column_part  = [A-Za-z0-9_]
@@ -1761,7 +1769,7 @@ extract_filed
     return f
   }
 extract_func
-  = kw:KW_EXTRACT __ LPAREN __ f:extract_filed __ KW_FROM __ t:(KW_TIMESTAMP / KW_INTERVAL / KW_TIME)? __ s:literal_string __ RPAREN {
+  = kw:KW_EXTRACT __ LPAREN __ f:extract_filed __ KW_FROM __ t:(KW_TIMESTAMP / KW_INTERVAL / KW_TIME)? __ s:expr __ RPAREN {
     return {
         type: kw.toLowerCase(),
         args: {

src/expr.js

@@ -1,11 +1,11 @@
-import { literalToSQL, toUpper, connector, extractFunToSQL } from './util'
+import { literalToSQL, toUpper, connector } from './util'
 import { alterExprToSQL } from './alter'
 import { aggrToSQL } from './aggregation'
 import { assignToSQL } from './assign'
 import { binaryToSQL } from './binary'
 import { caseToSQL } from './case'
 import { columnRefToSQL } from './column'
-import { castToSQL, funcToSQL } from './func'
+import { castToSQL, extractFunToSQL, funcToSQL } from './func'
 import { intervalToSQL } from './interval'
 import { selectToSQL } from './select'
 import { arrayStructExprToSQL } from './array-struct'

src/func.js

@@ -1,5 +1,5 @@
 import { exprToSQL } from './expr'
-import { hasVal } from './util'
+import { hasVal, toUpper } from './util'
 import { overToSQL } from './over'
 
 function castToSQL(expr) {
@@ -21,6 +21,13 @@ function castToSQL(expr) {
   return `${prefix}${symbolChar}${dataType}${str}${suffix}`
 }
 
+function extractFunToSQL(stmt) {
+  const { args, type } = stmt
+  const { field, cast_type: castType, source } = args
+  const result = [`${toUpper(type)}(${toUpper(field)}`, 'FROM', toUpper(castType), exprToSQL(source)]
+  return `${result.filter(hasVal).join(' ')})`
+}
+
 function funcToSQL(expr) {
   const { args, name } = expr
   if (!args) return name
@@ -32,5 +39,6 @@ function funcToSQL(expr) {
 
 export {
   castToSQL,
+  extractFunToSQL,
   funcToSQL,
 }

src/util.js

@@ -264,13 +264,6 @@ function commonKeywordArgsToSQL(kwArgs) {
   return [toUpper(kwArgs.keyword), toUpper(kwArgs.args)]
 }
 
-function extractFunToSQL(stmt) {
-  const { args, type } = stmt
-  const { field, cast_type: castType, source } = args
-  const result = [`${toUpper(type)}(${toUpper(field)}`, 'FROM', toUpper(castType), literalToSQL(source)]
-  return `${result.filter(hasVal).join(' ')})`
-}
-
 function autoIncreatementToSQL(autoIncreatement) {
   if (!autoIncreatement || typeof autoIncreatement === 'string') return toUpper(autoIncreatement)
   const { keyword, seed, increment, parentheses } = autoIncreatement
@@ -290,5 +283,5 @@ export {
   connector, commonTypeValue,commentToSQL, createBinaryExpr,
   createValueExpr, DEFAULT_OPT, escape, literalToSQL,
   identifierToSql, onPartitionsToSQL, replaceParams, returningToSQL,
-  hasVal, setParserOpt, toUpper, topToSQL, triggerEventToSQL,extractFunToSQL,
+  hasVal, setParserOpt, toUpper, topToSQL, triggerEventToSQL,
 }

test/select.spec.js

@@ -211,6 +211,12 @@ describe('select', () => {
         expect(parser.sqlify(ast, opt)).to.eql("SELECT EXTRACT(MICROSECONDS FROM TIME '17:12:28.5')");
         expect(parser.sqlify(parser.astify("SELECT EXTRACT(MILLISECONDS FROM TIMESTAMP '2016-12-31 13:30:15')", opt), opt)).to.eql("SELECT EXTRACT(MILLISECONDS FROM TIMESTAMP '2016-12-31 13:30:15')");
         expect(parser.sqlify(parser.astify("SELECT EXTRACT(MILLISECONDS FROM '2016-12-31 13:30:15')", opt), opt)).to.eql("SELECT EXTRACT(MILLISECONDS FROM '2016-12-31 13:30:15')");
+        expect(parser.sqlify(parser.astify(`WITH tss AS
+        (SELECT CURRENT_TIMESTAMP AS ts)
+      SELECT
+        EXTRACT(EPOCH FROM ts)
+      FROM
+        tss`, opt), opt)).to.eql('WITH tss AS (SELECT CURRENT_TIMESTAMP AS "ts") SELECT EXTRACT(EPOCH FROM "ts") FROM "tss"');
       });
 
       it('should parse function expression', () => {
@@ -332,6 +338,13 @@ describe('select', () => {
       expect(backSQL).to.equal('SELECT `user0__`.`user_id` AS `userId` FROM `user` AS `user0__`')
     })
 
+    it('should support select from db.xxx.table', () => {
+      const sql = 'select id from db-name.public.table-name'
+      const opt = { database: 'postgresql' }
+      const ast = parser.astify(sql, opt)
+      const backSQL = parser.sqlify(ast,opt )
+      expect(backSQL).to.equal('SELECT "id" FROM "db-name.public"."table-name"')
+    })
 
     it('should parse subselect', () => {
       const ast = parser.astify('SELECT * FROM (SELECT id FROM t1) someAlias');
@@ -1012,9 +1025,9 @@ describe('select', () => {
         expect(fun).to.throw(`authority = 'select::null::b' is required in table whiteList to execute SQL = '${sql}'`)
       })
       it('should fail for as column reserved word check', () => {
-        const sql = 'SELECT id as type FROM b'
+        const sql = 'SELECT id as delete FROM b'
         const fun = parser.astify.bind(parser, sql)
-        expect(fun).to.throw('Error: "type" is a reserved word, can not as alias clause')
+        expect(fun).to.throw('Error: "delete" is a reserved word, can not as alias clause')
       })
       it('should fail for as table reserved word check', () => {
         const sql = 'SELECT id as bc FROM b as table'