oushu/lava-oushudb-dt-sql-parser
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: add ErrorStrategy(#230)

Browse Source 
* refactor: rename errorHandler to errorListener

* feat: add ErrorStrategy to mark context exceptions

* test: errorStrategy unit tests
This commit is contained in:
Hayden
2023-12-11 17:34:49 +08:00
committed by GitHub
parent 61a00d7bb8
commit ee8b468778
12 changed files with 548 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
test/common/basicParser.test.ts
View File

@ -1,5 +1,5 @@
import { CommonTokenStream } from 'antlr4ts';
import { ErrorHandler, FlinkSQL } from '../../src';
import { ErrorListener, FlinkSQL } from '../../src';
import { FlinkSqlLexer } from '../../src/lib/flinksql/FlinkSqlLexer';
describe('BasicParser unit tests', () => {
@ -12,13 +12,13 @@ describe('BasicParser unit tests', () => {
expect(lexer).not.toBeNull();
});
test('Create lexer with errorHandler', () => {
test('Create lexer with errorListener', () => {
const sql = '袋鼠云数栈UED团队';
const errors: any[] = [];
const errorHandler: ErrorHandler<any> = (err) => {
const errorListener: ErrorListener<any> = (err) => {
errors.push(err);
};
const lexer = flinkParser.createLexer(sql, errorHandler);
const lexer = flinkParser.createLexer(sql, errorListener);
const tokenStream = new CommonTokenStream(lexer);
tokenStream.fill();
expect(errors.length).not.toBe(0);
@ -32,24 +32,24 @@ describe('BasicParser unit tests', () => {
expect(parser).not.toBeNull();
});
test('Create parser with errorHandler (lexer error)', () => {
test('Create parser with errorListener (lexer error)', () => {
const sql = '袋鼠云数栈UED团队';
const errors: any[] = [];
const errorHandler: ErrorHandler<any> = (err) => {
const errorListener: ErrorListener<any> = (err) => {
errors.push(err);
};
const parser = flinkParser.createParser(sql, errorHandler);
const parser = flinkParser.createParser(sql, errorListener);
parser.program();
expect(errors.length).not.toBe(0);
});
test('Create parser with errorHandler (parse error)', () => {
test('Create parser with errorListener (parse error)', () => {
const sql = 'SHOW TA';
const errors: any[] = [];
const errorHandler: ErrorHandler<any> = (err) => {
const errorListener: ErrorListener<any> = (err) => {
errors.push(err);
};
const parser = flinkParser.createParser(sql, errorHandler);
const parser = flinkParser.createParser(sql, errorListener);
parser.program();
expect(errors.length).not.toBe(0);
});
@ -57,10 +57,10 @@ describe('BasicParser unit tests', () => {
test('Parse right input', () => {
const sql = 'SELECT * FROM tb1';
const errors: any[] = [];
const errorHandler: ErrorHandler<any> = (err) => {
const errorListener: ErrorListener<any> = (err) => {
errors.push(err);
};
const parseTree = flinkParser.parse(sql, errorHandler);
const parseTree = flinkParser.parse(sql, errorListener);
expect(parseTree).not.toBeUndefined();
expect(parseTree).not.toBeNull();
@ -70,10 +70,10 @@ describe('BasicParser unit tests', () => {
test('Parse wrong input', () => {
const sql = '袋鼠云数栈UED团队';
const errors: any[] = [];
const errorHandler: ErrorHandler<any> = (err) => {
const errorListener: ErrorListener<any> = (err) => {
errors.push(err);
};
const parseTree = flinkParser.parse(sql, errorHandler);
const parseTree = flinkParser.parse(sql, errorListener);
expect(parseTree).not.toBeUndefined();
expect(parseTree).not.toBeNull();

62
test/parser/flinksql/errorStrategy.test.ts Normal file
View File

@ -0,0 +1,62 @@
import FlinkSQL from '../../../src/parser/flinksql';
import { FlinkSqlSplitListener } from '../../../src/parser/flinksql';
import { FlinkSqlParserListener } from '../../../src/lib/flinksql/FlinkSqlParserListener';
const validSQL1 = `INSERT INTO country_page_view
VALUES ('Chinese', 'mumiao', 18),
('Amercian', 'georage', 22);`;
const validSQL2 = 'SELECT * FROM tb;';
const inValidSQL = 'CREATE TABLE VALUES;';
describe('FlinkSQL ErrorStrategy test', () => {
const flinkSQL = new FlinkSQL();
test('begin inValid', () => {
const sql = [inValidSQL, validSQL1, validSQL2].join('\n');
// parse with empty errorListener
const parseTree = flinkSQL.parse(sql, () => {});
const splitListener = new FlinkSqlSplitListener();
flinkSQL.listen(splitListener as FlinkSqlParserListener, parseTree);
const statementCount = splitListener.statementsContext.length;
splitListener.statementsContext.map((item, index) => {
if (index !== statementCount - 1 && index !== statementCount - 2) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
test('middle inValid', () => {
const sql = [validSQL1, inValidSQL, validSQL2].join('\n');
// parse with empty errorListener
const parseTree = flinkSQL.parse(sql, () => {});
const splitListener = new FlinkSqlSplitListener();
flinkSQL.listen(splitListener as FlinkSqlParserListener, parseTree);
const statementCount = splitListener.statementsContext.length;
splitListener.statementsContext.map((item, index) => {
if (index !== statementCount - 1 && index !== 0) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
test('end inValid', () => {
const sql = [validSQL1, validSQL2, inValidSQL].join('\n');
// parse with empty errorListener
const parseTree = flinkSQL.parse(sql, () => {});
const splitListener = new FlinkSqlSplitListener();
flinkSQL.listen(splitListener as FlinkSqlParserListener, parseTree);
splitListener.statementsContext.map((item, index) => {
if (index !== 0 && index !== 1) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
});

62
test/parser/hive/errorStrategy.test.ts Normal file
View File

@ -0,0 +1,62 @@
import HiveSQL from '../../../src/parser/hive';
import { HiveSqlSplitListener } from '../../../src/parser/hive';
import { HiveSqlParserListener } from '../../../src/lib/hive/HiveSqlParserListener';
const validSQL1 = `INSERT INTO country_page_view
VALUES ('Chinese', 'mumiao', 18),
('Amercian', 'georage', 22);`;
const validSQL2 = 'SELECT * FROM tb;';
const inValidSQL = 'CREATE TABLE VALUES;';
describe('HiveSQL ErrorStrategy test', () => {
const hiveSQL = new HiveSQL();
test('begin inValid', () => {
const sql = [inValidSQL, validSQL1, validSQL2].join('\n');
// parse with empty errorListener
const parseTree = hiveSQL.parse(sql, () => {});
const splitListener = new HiveSqlSplitListener();
hiveSQL.listen(splitListener as HiveSqlParserListener, parseTree);
const statementCount = splitListener.statementsContext.length;
splitListener.statementsContext.map((item, index) => {
if (index !== statementCount - 1 && index !== statementCount - 2) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
test('middle inValid', () => {
const sql = [validSQL1, inValidSQL, validSQL2].join('\n');
// parse with empty errorListener
const parseTree = hiveSQL.parse(sql, () => {});
const splitListener = new HiveSqlSplitListener();
hiveSQL.listen(splitListener as HiveSqlParserListener, parseTree);
const statementCount = splitListener.statementsContext.length;
splitListener.statementsContext.map((item, index) => {
if (index !== statementCount - 1 && index !== 0) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
test('end inValid', () => {
const sql = [validSQL1, validSQL2, inValidSQL].join('\n');
// parse with empty errorListener
const parseTree = hiveSQL.parse(sql, () => {});
const splitListener = new HiveSqlSplitListener();
hiveSQL.listen(splitListener as HiveSqlParserListener, parseTree);
splitListener.statementsContext.map((item, index) => {
if (index !== 0 && index !== 1) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
});

62
test/parser/impala/errorStrategy.test.ts Normal file
View File

@ -0,0 +1,62 @@
import ImpalaSQL from '../../../src/parser/impala';
import { ImpalaSqlSplitListener } from '../../../src/parser/impala';
import { ImpalaSqlParserListener } from '../../../src/lib/impala/ImpalaSqlParserListener';
const validSQL1 = `INSERT INTO country_page_view
VALUES ('Chinese', 'mumiao', 18),
('Amercian', 'georage', 22);`;
const validSQL2 = 'SELECT * FROM tb;';
const inValidSQL = 'CREATE TABLE VALUES;';
describe('ImpalaSQL ErrorStrategy test', () => {
const impalaSQL = new ImpalaSQL();
test('begin inValid', () => {
const sql = [inValidSQL, validSQL1, validSQL2].join('\n');
// parse with empty errorListener
const parseTree = impalaSQL.parse(sql, () => {});
const splitListener = new ImpalaSqlSplitListener();
impalaSQL.listen(splitListener as ImpalaSqlParserListener, parseTree);
const statementCount = splitListener.statementsContext.length;
splitListener.statementsContext.map((item, index) => {
if (index !== statementCount - 1 && index !== statementCount - 2) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
test('middle inValid', () => {
const sql = [validSQL1, inValidSQL, validSQL2].join('\n');
// parse with empty errorListener
const parseTree = impalaSQL.parse(sql, () => {});
const splitListener = new ImpalaSqlSplitListener();
impalaSQL.listen(splitListener as ImpalaSqlParserListener, parseTree);
const statementCount = splitListener.statementsContext.length;
splitListener.statementsContext.map((item, index) => {
if (index !== statementCount - 1 && index !== 0) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
test('end inValid', () => {
const sql = [validSQL1, validSQL2, inValidSQL].join('\n');
// parse with empty errorListener
const parseTree = impalaSQL.parse(sql, () => {});
const splitListener = new ImpalaSqlSplitListener();
impalaSQL.listen(splitListener as ImpalaSqlParserListener, parseTree);
splitListener.statementsContext.map((item, index) => {
if (index !== 0 && index !== 1) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
});

62
test/parser/mysql/errorStrategy.test.ts Normal file
View File

@ -0,0 +1,62 @@
import MySQL from '../../../src/parser/mysql';
import { MysqlSplitListener } from '../../../src/parser/mysql';
import { MySqlParserListener } from '../../../src/lib/mysql/MySqlParserListener';
const validSQL1 = `INSERT INTO country_page_view
VALUES ('Chinese', 'mumiao', 18),
('Amercian', 'georage', 22);`;
const validSQL2 = 'SELECT * FROM tb;';
const inValidSQL = 'CREATE TABLE VALUES;';
describe('MySQL ErrorStrategy test', () => {
const mysql = new MySQL();
test('begin inValid', () => {
const sql = [inValidSQL, validSQL1, validSQL2].join('\n');
// parse with empty errorListener
const parseTree = mysql.parse(sql, () => {});
const splitListener = new MysqlSplitListener();
mysql.listen(splitListener as MySqlParserListener, parseTree);
const statementCount = splitListener.statementsContext.length;
splitListener.statementsContext.map((item, index) => {
if (index !== statementCount - 1 && index !== statementCount - 2) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
test('middle inValid', () => {
const sql = [validSQL1, inValidSQL, validSQL2].join('\n');
// parse with empty errorListener
const parseTree = mysql.parse(sql, () => {});
const splitListener = new MysqlSplitListener();
mysql.listen(splitListener as MySqlParserListener, parseTree);
const statementCount = splitListener.statementsContext.length;
splitListener.statementsContext.map((item, index) => {
if (index !== statementCount - 1 && index !== 0) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
test('end inValid', () => {
const sql = [validSQL1, validSQL2, inValidSQL].join('\n');
// parse with empty errorListener
const parseTree = mysql.parse(sql, () => {});
const splitListener = new MysqlSplitListener();
mysql.listen(splitListener as MySqlParserListener, parseTree);
splitListener.statementsContext.map((item, index) => {
if (index !== 0 && index !== 1) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
});

64
test/parser/pgsql/errorStrategy.test.ts Normal file
View File

@ -0,0 +1,64 @@
import PgSQL from '../../../src/parser/pgsql';
import { PgSqlSplitListener } from '../../../src/parser/pgsql';
import { PostgreSQLParserListener } from '../../../src/lib/pgsql/PostgreSQLParserListener';
const validSQL1 = `INSERT INTO country_page_view
VALUES ('Chinese', 'mumiao', 18),
('Amercian', 'georage', 22);`;
const validSQL2 = 'SELECT * FROM tb;';
const inValidSQL = 'CREATE TABLE';
describe('PgSQL ErrorStrategy test', () => {
const pgSQL = new PgSQL();
// TODO: handle unexpected case
// test('begin inValid', () => {
// const sql = [inValidSQL, validSQL1, validSQL2].join('\n');
// // parse with empty errorListener
// const parseTree = pgSQL.parse(sql, () => {});
// const splitListener = new PgSqlSplitListener();
// pgSQL.listen(splitListener as PostgreSQLParserListener, parseTree);
// const statementCount = splitListener.statementsContext.length;
// splitListener.statementsContext.map((item, index) => {
// if(index !== statementCount-1 && index !== statementCount - 2) {
// expect(item.exception).not.toBe(undefined);
// } else {
// expect(item.exception).toBe(undefined);
// }
// })
// });
test('middle inValid', () => {
const sql = [validSQL1, inValidSQL, validSQL2].join('\n');
// parse with empty errorListener
const parseTree = pgSQL.parse(sql, () => {});
const splitListener = new PgSqlSplitListener();
pgSQL.listen(splitListener as PostgreSQLParserListener, parseTree);
const statementCount = splitListener.statementsContext.length;
splitListener.statementsContext.map((item, index) => {
if (index !== statementCount - 1 && index !== 0) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
test('end inValid', () => {
const sql = [validSQL1, validSQL2, inValidSQL].join('\n');
// parse with empty errorListener
const parseTree = pgSQL.parse(sql, () => {});
const splitListener = new PgSqlSplitListener();
pgSQL.listen(splitListener as PostgreSQLParserListener, parseTree);
splitListener.statementsContext.map((item, index) => {
if (index !== 0 && index !== 1) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
});

65
test/parser/spark/errorStrategy.test.ts Normal file
View File

@ -0,0 +1,65 @@
import SparkSQL from '../../../src/parser/spark';
import { SparkSqlSplitListener } from '../../../src/parser/spark';
import { SparkSqlParserListener } from '../../../src/lib/spark/SparkSqlParserListener';
const validSQL1 = `INSERT INTO country_page_view
VALUES ('Chinese', 'mumiao', 18),
('Amercian', 'georage', 22);`;
const validSQL2 = 'SELECT * FROM tb;';
const inValidSQL = 'CREATE TABLE;';
describe('SparkSQL ErrorStrategy test', () => {
const sparkSQL = new SparkSQL();
// TODO: handle unexpected case
// test('begin inValid', () => {
// const sql = [inValidSQL, validSQL1, validSQL2].join('\n');
// // parse with empty errorListener
// const parseTree = sparkSQL.parse(sql, () => {});
// const splitListener = new SparkSqlSplitListener();
// sparkSQL.listen(splitListener as SparkSqlParserListener, parseTree);
// const statementCount = splitListener.statementsContext.length;
// splitListener.statementsContext.map((item, index) => {
// if(index !== statementCount-1 && index !== statementCount - 2) {
// expect(item.exception).not.toBe(undefined);
// } else {
// expect(item.exception).toBe(undefined);
// }
// })
// });
// TODO: handle unexpected case
// test('middle inValid', () => {
// const sql = [validSQL1, inValidSQL, validSQL2].join('\n');
// // parse with empty errorListener
// const parseTree = sparkSQL.parse(sql, () => {});
// const splitListener = new SparkSqlSplitListener();
// sparkSQL.listen(splitListener as SparkSqlParserListener, parseTree);
// const statementCount = splitListener.statementsContext.length;
// splitListener.statementsContext.map((item, index) => {
// if(index !== statementCount-1 && index !== 0) {
// expect(item.exception).not.toBe(undefined);
// } else {
// expect(item.exception).toBe(undefined);
// }
// })
// });
test('end inValid', () => {
const sql = [validSQL1, validSQL2, inValidSQL].join('\n');
// parse with empty errorListener
const parseTree = sparkSQL.parse(sql, () => {});
const splitListener = new SparkSqlSplitListener();
sparkSQL.listen(splitListener as SparkSqlParserListener, parseTree);
splitListener.statementsContext.map((item, index) => {
if (index !== 0 && index !== 1) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
});

62
test/parser/trinosql/errorStrategy.test.ts Normal file
View File

@ -0,0 +1,62 @@
import TrinoSQL from '../../../src/parser/trinosql';
import { TrinoSqlSplitListener } from '../../../src/parser/trinosql';
import { TrinoSqlListener } from '../../../src/lib/trinosql/TrinoSqlListener';
const validSQL1 = `INSERT INTO country_page_view
VALUES ('Chinese', 'mumiao', 18),
('Amercian', 'georage', 22);`;
const validSQL2 = 'SELECT * FROM tb;';
const inValidSQL = 'CREATE TABLE VALUES;';
describe('TrinoSQL ErrorStrategy test', () => {
const trinoSQL = new TrinoSQL();
test('begin inValid', () => {
const sql = [inValidSQL, validSQL1, validSQL2].join('\n');
// parse with empty errorListener
const parseTree = trinoSQL.parse(sql, () => {});
const splitListener = new TrinoSqlSplitListener();
trinoSQL.listen(splitListener as TrinoSqlListener, parseTree);
const statementCount = splitListener.statementsContext.length;
splitListener.statementsContext.map((item, index) => {
if (index !== statementCount - 1 && index !== statementCount - 2) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
test('middle inValid', () => {
const sql = [validSQL1, inValidSQL, validSQL2].join('\n');
// parse with empty errorListener
const parseTree = trinoSQL.parse(sql, () => {});
const splitListener = new TrinoSqlSplitListener();
trinoSQL.listen(splitListener as TrinoSqlListener, parseTree);
const statementCount = splitListener.statementsContext.length;
splitListener.statementsContext.map((item, index) => {
if (index !== statementCount - 1 && index !== 0) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
test('end inValid', () => {
const sql = [validSQL1, validSQL2, inValidSQL].join('\n');
// parse with empty errorListener
const parseTree = trinoSQL.parse(sql, () => {});
const splitListener = new TrinoSqlSplitListener();
trinoSQL.listen(splitListener as TrinoSqlListener, parseTree);
splitListener.statementsContext.map((item, index) => {
if (index !== 0 && index !== 1) {
expect(item.exception).not.toBe(undefined);
} else {
expect(item.exception).toBe(undefined);
}
});
});
});