-[](https://travis-ci.org/JSQLParser/JSqlParser) [](https://coveralls.io/r/JSQLParser/JSqlParser?branch=master)
-[](https://www.codacy.com/app/wumpz/JSqlParser?utm_source=github.com&utm_medium=referral&utm_content=JSQLParser/JSqlParser&utm_campaign=Badge_Grade)
-[](http://maven-badges.herokuapp.com/maven-central/com.github.jsqlparser/jsqlparser)
-[](https://www.javadoc.io/doc/com.github.jsqlparser/jsqlparser)
+[](https://github.com/JSQLParser/JSqlParser/actions/workflows/ci.yml)
+[](https://coveralls.io/r/JSQLParser/JSqlParser?branch=master)
+[](https://www.codacy.com/gh/JSQLParser/JSqlParser/dashboard?utm_source=github.com&utm_medium=referral&utm_content=JSQLParser/JSqlParser&utm_campaign=Badge_Grade)
+[](https://central.sonatype.com/artifact/com.github.jsqlparser/jsqlparser) [](https://www.javadoc.io/doc/com.github.jsqlparser/jsqlparser)
+[](https://gitter.im/JSQLParser/JSqlParser?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
-[](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=64CCN9JJANZXA "Help this JSqlParser version using Paypal")
+A huge thank you to our sponsor, [Starlake.ai](https://starlake.ai/) who simplifies data ingestion, transformation, and orchestration, enabling faster delivery of high-quality data. Starlake has been instrumental in providing Piped SQL and numerous test cases for BigQuery, Redshift, DataBricks, and DuckDB. Show your support for ongoing development by visiting Starlake.ai and giving us a star!
-[](https://gitter.im/JSQLParser/JSqlParser?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+## Summary
-Look here for more information and examples: https://github.com/JSQLParser/JSqlParser/wiki.
+Please visit our [WebSite](https://jsqlparser.github.io/JSqlParser) for detailed information. **JSqlParser** is a RDBMS agnostic SQL statement parser. It translates SQL statements into a traversable hierarchy of Java classes (see [Samples](https://jsqlparser.github.io/JSqlParser/usage.html#parse-a-sql-statements)):
-## License
+```sql
+SELECT 1 FROM dual WHERE a = b
-JSqlParser is dual licensed under **LGPL V2.1** and **Apache Software License, Version 2.0**.
+/* produces the following AST
+SQL Text
+ └─Statements: statement.select.PlainSelect
+ ├─selectItems: statement.select.SelectItem
+ │ └─LongValue: 1
+ ├─Table: dual
+ └─where: expression.operators.relational.EqualsTo
+ ├─Column: a
+ └─Column: b
+*/
+```
-## News
-* Changed behaviour of dotted multipart names for user variables, tables and columns to accept e.g. ORM class names. To achieve this some behaviour of name parsing had to be changed. Before this the parser would fail missing databasenames for SqlServer queries (server..schema.table). But this is allowed for the schema (server.database..table). Now the parser accepts missing inner names per se to avoid some very complicated parsing rules.
-* Released version **1.2** of JSqlParser
-* breaking **API** change: merge of *within group* and *over* (window expressions)
-* Released version **1.1** of JSqlParser.
-* JSqlParser has now a build in checkstyle configuration to introduce source code conventions.
-* Released first major version **1.0** of JSqlParser.
+```java
+String sqlStr = "select 1 from dual where a=b";
+
+PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse(sqlStr);
-More news can be found here: https://github.com/JSQLParser/JSqlParser/wiki/News.
+SelectItem selectItem =
+ select.getSelectItems().get(0);
+Assertions.assertEquals(
+ new LongValue(1)
+ , selectItem.getExpression());
-## JSqlParser
+Table table = (Table) select.getFromItem();
+Assertions.assertEquals("dual", table.getName());
-JSqlParser is a SQL statement parser. It translates SQLs in a traversable hierarchy of Java classes. JSqlParser is not limited to one database but provides support for a lot of specials of Oracle, SqlServer, MySQL, PostgreSQL ... To name some, it has support for Oracles join syntax using (+), PostgreSQLs cast syntax using ::, relational operators like != and so on.
+EqualsTo equalsTo = (EqualsTo) select.getWhere();
+Column a = (Column) equalsTo.getLeftExpression();
+Column b = (Column) equalsTo.getRightExpression();
+Assertions.assertEquals("a", a.getColumnName());
+Assertions.assertEquals("b", b.getColumnName());
+```
+## Support for `Piped SQL`
+
+Work is progressing for parsing `Piped SQL`, a much saner and more logical way to write queries in its semantic order.
+```sql
+FROM Produce
+|> WHERE
+ item != 'bananas'
+ AND category IN ('fruit', 'nut')
+|> AGGREGATE COUNT(*) AS num_items, SUM(sales) AS total_sales
+ GROUP BY item
+|> ORDER BY item DESC;
+```
-## Support
-If you need help using JSqlParser feel free to file an issue or contact me.
+For details, please see https://storage.googleapis.com/gweb-research2023-media/pubtools/1004848.pdf, https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax and https://duckdb.org/docs/sql/query_syntax/from.html#from-first-syntax
-## Contributions
-To help JSqlParsers development you are encouraged to provide
-* feedback
-* bugreports
-* pull requests for new features
-* improvement requests
-* fund new features
-* a little donation
+## Java Version
-**Please write in english, since it's the language most of the dev team knows.**
+JSQLParser-4.9 was the last JDK8 compatible version. JSQLParser-5.0 and later depend on JDK11 and introduce API breaking changes to the AST Visitors. Please see the Migration Guide for the details.
-Also I would like to know about needed examples or documentation stuff.
+Building JSQLParser-5.1 and newer with Gradle will depend on a JDK17 toolchain due to the used plugins.
-## Extensions in the latest SNAPSHOT version 1.3
+JSQLParser-5.4 Snapshot and later use JavaCC-8 Snapshots for generating the parser.
-* support for additional raw string and byte prefixes (issue #659)
-* support for special oracle type syntax **varchar2(255 BYTE)** (issue #273)
-* introduced dotted multipart names for uservariables (issue #608)
-* changed behaviour of dotted multipart names for tables and columns to accept ORM class names (issue #163)
-** the parser allows now empty inner names, to still accept missing schema names for SQLServer (db..col)
-** methods like **getDatabase** will still work but have no sense using it for classnames
-* named parameter for **OFFSET** (issue #612)
-* corrected ISNULL regression (issue #610)
-* refactored statement test classes to the class corresponding packages
-* allowed nested postgresql casts (e.g. col::bigint::int)
+## Performance
+Unfortunately the released JSQLParser-5.2 shows a performance deterioration caused by commit [30cf5d7](https://github.com/JSQLParser/JSqlParser/commit/30cf5d7b930ae0a076f49deb5cc841d39e62b3dc) related to `FunctionAllColumns()`.
+This has been resolved in JSQLParser 5.3-SNAPSHOT and JMH benchmarks have been added to avoid such regressions in the future. Further all `LOOKAHEAD` have been revised one by one, and we have gained back a very good performance of the Parser.
-## Extensions of JSqlParser releases
+As per March-2026, the productions `Condition()`, `RegularCondition()` and `AndExpression()` have been refactored successfully. Furthermore, we have overhauled Token definition and handling of Reserved Keywords. This resulted in a massive performance boost and seem to have solved most of the performance issues.
-* [Release Notes](https://github.com/JSQLParser/JSqlParser/releases)
-* Modifications before GitHubs release tagging are listed in the [Older Releases](https://github.com/JSQLParser/JSqlParser/wiki/Older-Releases) page.
+```text
+Benchmark (version) Mode Cnt Score Error Units
+JSQLParserBenchmark.parseSQLStatements latest avgt 15 7.602 ± 0.135 ms/op <-- March/26
+JSQLParserBenchmark.parseSQLStatements 5.3 avgt 15 84.687 ± 3.321 ms/op
+JSQLParserBenchmark.parseSQLStatements 5.1 avgt 15 86.592 ± 5.781 ms/op
+```
+## [Supported Grammar and Syntax](https://jsqlparser.github.io/JSqlParser/syntax.html)
-## Building from the sources
+**JSqlParser** aims to support the SQL standard as well as all major RDBMS. Any missing syntax or features can be added on demand.
-As the project is a Maven project, building is rather simple by running:
+| RDBMS | Statements |
+|-----------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------|
+| BigQuery+ * A marker interface for jsqlparser-model-classes. + *
+ *+ * The datastructure where the sql syntax is represented by a tree consists of {@link Model}'s + *
+ */ +public interface Model extends Serializable { + +} diff --git a/src/main/java/net/sf/jsqlparser/expression/Alias.java b/src/main/java/net/sf/jsqlparser/expression/Alias.java index 6de501342..ffc599680 100644 --- a/src/main/java/net/sf/jsqlparser/expression/Alias.java +++ b/src/main/java/net/sf/jsqlparser/expression/Alias.java @@ -1,34 +1,39 @@ -/* +/*- * #%L * JSQLParser library * %% - * Copyright (C) 2004 - 2014 JSQLParser + * Copyright (C) 2004 - 2019 JSQLParser * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 2.1 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - *
+ * Syntax:
*
- * Syntax:
+ *
+ *
* CASE
* WHEN condition THEN expression
* [WHEN condition THEN expression]...
* [ELSE expression]
* END
- *
- * or
- *
+ *
+ * or
+ *
*
- *
+ *
+ *
* CASE expression
* WHEN condition THEN expression
* [WHEN condition THEN expression]...
* [ELSE expression]
* END
- * T visitExpressions(ExpressionList expressions, S context) {
+ if (expressions != null) {
+ expressions.forEach(expression -> expression.accept(this, context));
+ }
+ return null;
+ };
+
+ default T visitExpression(Expression expression, S context) {
+ if (expression != null) {
+ expression.accept(this, context);
+ }
+ return null;
+ }
+
+ default T visitOrderBy(List T visitLimit(Limit limit, S context) {
+ if (limit != null && !limit.isLimitNull() && !limit.isLimitAll()) {
+ if (limit.getOffset() != null) {
+ limit.getOffset().accept(this, context);
+ }
+ if (limit.getRowCount() != null) {
+ limit.getRowCount().accept(this, context);
+ }
+ if (limit.getByExpressions() != null) {
+ limit.getByExpressions().accept(this, context);
+ }
+ }
+ return null;
+ }
+
+ default T visitPreferringClause(PreferringClause preferringClause, S context) {
+ if (preferringClause != null) {
+ if (preferringClause.getPreferring() != null) {
+ preferringClause.getPreferring().accept(this, context);
+ }
+ if (preferringClause.getPartitionBy() != null) {
+ for (Expression expression : preferringClause.getPartitionBy()) {
+ expression.accept(this, context);
+ }
+ }
+ }
+ return null;
+ }
+
+ default T visitUpdateSets(List T visit(GroupByElement groupBy, S context) {
+ if (groupBy != null) {
+ for (Expression expression : groupBy.getGroupByExpressionList()) {
+ expression.accept(this, context);
+ }
+ if (!groupBy.getGroupingSets().isEmpty()) {
+ for (ExpressionList expressionList : groupBy.getGroupingSets()) {
+ expressionList.accept(this, context);
+ }
+ }
+ }
+ return null;
+ }
+
+ T visit(BitwiseRightShift bitwiseRightShift, S context);
+
+ default void visit(BitwiseRightShift bitwiseRightShift) {
+ this.visit(bitwiseRightShift, null);
+ }
+
+ T visit(BitwiseLeftShift bitwiseLeftShift, S context);
+
+ default void visit(BitwiseLeftShift bitwiseLeftShift) {
+ this.visit(bitwiseLeftShift, null);
+ }
+
+ T visit(NullValue nullValue, S context);
+
+ default void visit(NullValue nullValue) {
+ this.visit(nullValue, null);
+ }
+
+ T visit(Function function, S context);
+
+ default void visit(Function function) {
+ this.visit(function, null);
+ }
+
+ T visit(SignedExpression signedExpression, S context);
+
+ default void visit(SignedExpression signedExpression) {
+ this.visit(signedExpression, null);
+ }
+
+ T visit(JdbcParameter jdbcParameter, S context);
+
+ default void visit(JdbcParameter jdbcParameter) {
+ this.visit(jdbcParameter, null);
+ }
+
+ T visit(JdbcNamedParameter jdbcNamedParameter, S context);
+
+ default void visit(JdbcNamedParameter jdbcNamedParameter) {
+ this.visit(jdbcNamedParameter, null);
+ }
+
+ T visit(DoubleValue doubleValue, S context);
+
+ default void visit(DoubleValue doubleValue) {
+ this.visit(doubleValue, null);
+ }
+
+ T visit(LongValue longValue, S context);
+
+ default void visit(LongValue longValue) {
+ this.visit(longValue, null);
+ }
+
+ T visit(HexValue hexValue, S context);
+
+ default void visit(HexValue hexValue) {
+ this.visit(hexValue, null);
+ }
+
+ T visit(DateValue dateValue, S context);
+
+ default void visit(DateValue dateValue) {
+ this.visit(dateValue, null);
+ }
+
+ T visit(TimeValue timeValue, S context);
+
+ default void visit(TimeValue timeValue) {
+ this.visit(timeValue, null);
+ }
+
+ T visit(TimestampValue timestampValue, S context);
+
+ default void visit(TimestampValue timestampValue) {
+ this.visit(timestampValue, null);
+ }
+
+ T visit(StringValue stringValue, S context);
+
+ default void visit(StringValue stringValue) {
+ this.visit(stringValue, null);
+ }
+
+ T visit(BooleanValue booleanValue, S context);
+
+ default void visit(BooleanValue booleanValue) {
+ this.visit(booleanValue, null);
+ }
+
+ T visit(Addition addition, S context);
+
+ default void visit(Addition addition) {
+ this.visit(addition, null);
+ }
+
+ T visit(Division division, S context);
+
+ default void visit(Division division) {
+ this.visit(division, null);
+ }
+
+ T visit(IntegerDivision integerDivision, S context);
+
+ default void visit(IntegerDivision integerDivision) {
+ this.visit(integerDivision, null);
+ }
+
+ T visit(Multiplication multiplication, S context);
+
+ default void visit(Multiplication multiplication) {
+ this.visit(multiplication, null);
+ }
+
+ T visit(Subtraction subtraction, S context);
+
+ default void visit(Subtraction subtraction) {
+ this.visit(subtraction, null);
+ }
+
+ T visit(AndExpression andExpression, S context);
+
+ default void visit(AndExpression andExpression) {
+ this.visit(andExpression, null);
+ }
+
+ T visit(OrExpression orExpression, S context);
+
+ default void visit(OrExpression orExpression) {
+ this.visit(orExpression, null);
+ }
+
+ T visit(XorExpression xorExpression, S context);
+
+ default void visit(XorExpression xorExpression) {
+ this.visit(xorExpression, null);
+ }
+
+ T visit(Between between, S context);
+
+ default void visit(Between between) {
+ this.visit(between, null);
+ }
+
+ T visit(OverlapsCondition overlapsCondition, S context);
+
+ default void visit(OverlapsCondition overlapsCondition) {
+ this.visit(overlapsCondition, null);
+ }
+
+ T visit(EqualsTo equalsTo, S context);
+
+ default void visit(EqualsTo equalsTo) {
+ this.visit(equalsTo, null);
+ }
+
+ T visit(GreaterThan greaterThan, S context);
+
+ default void visit(GreaterThan greaterThan) {
+ this.visit(greaterThan, null);
+ }
+
+ T visit(GreaterThanEquals greaterThanEquals, S context);
+
+ default void visit(GreaterThanEquals greaterThanEquals) {
+ this.visit(greaterThanEquals, null);
+ }
+
+ T visit(InExpression inExpression, S context);
+
+ default void visit(InExpression inExpression) {
+ this.visit(inExpression, null);
+ }
+
+ T visit(IncludesExpression includesExpression, S context);
+
+ default void visit(IncludesExpression includesExpression) {
+ this.visit(includesExpression, null);
+ }
+
+ T visit(ExcludesExpression excludesExpression, S context);
+
+ default void visit(ExcludesExpression excludesExpression) {
+ this.visit(excludesExpression, null);
+ }
+
+ T visit(FullTextSearch fullTextSearch, S context);
+
+ default void visit(FullTextSearch fullTextSearch) {
+ this.visit(fullTextSearch, null);
+ }
+
+ T visit(IsNullExpression isNullExpression, S context);
+
+ default void visit(IsNullExpression isNullExpression) {
+ this.visit(isNullExpression, null);
+ }
+
+ T visit(IsBooleanExpression isBooleanExpression, S context);
+
+ default void visit(IsBooleanExpression isBooleanExpression) {
+ this.visit(isBooleanExpression, null);
+ }
+
+ T visit(IsUnknownExpression isUnknownExpression, S context);
+
+ default void visit(IsUnknownExpression isUnknownExpression) {
+ this.visit(isUnknownExpression, null);
+ }
+
+ T visit(LikeExpression likeExpression, S context);
+
+ default void visit(LikeExpression likeExpression) {
+ this.visit(likeExpression, null);
+ }
+
+ T visit(MinorThan minorThan, S context);
+
+ default void visit(MinorThan minorThan) {
+ this.visit(minorThan, null);
+ }
+
+ T visit(MinorThanEquals minorThanEquals, S context);
+
+ default void visit(MinorThanEquals minorThanEquals) {
+ this.visit(minorThanEquals, null);
+ }
+
+ T visit(NotEqualsTo notEqualsTo, S context);
+
+ default void visit(NotEqualsTo notEqualsTo) {
+ this.visit(notEqualsTo, null);
+ }
+
+ T visit(DoubleAnd doubleAnd, S context);
+
+ default void visit(DoubleAnd doubleAnd) {
+ this.visit(doubleAnd, null);
+ }
+
+ T visit(Contains contains, S context);
+
+ default void visit(Contains contains) {
+ this.visit(contains, null);
+ }
+
+ T visit(ContainedBy containedBy, S context);
+
+ default void visit(ContainedBy containedBy) {
+ this.visit(containedBy, null);
+ }
+
+ T visit(ParenthesedSelect select, S context);
+
+ T visit(Column column, S context);
+
+ default void visit(Column column) {
+ this.visit(column, null);
+ }
+
+ T visit(CaseExpression caseExpression, S context);
+
+ default void visit(CaseExpression caseExpression) {
+ this.visit(caseExpression, null);
+ }
+
+ T visit(WhenClause whenClause, S context);
+
+ default void visit(WhenClause whenClause) {
+ this.visit(whenClause, null);
+ }
+
+ T visit(ExistsExpression existsExpression, S context);
+
+ default void visit(ExistsExpression existsExpression) {
+ this.visit(existsExpression, null);
+ }
+
+ T visit(MemberOfExpression memberOfExpression, S context);
+
+ default void visit(MemberOfExpression memberOfExpression) {
+ this.visit(memberOfExpression, null);
+ }
+
+ T visit(AnyComparisonExpression anyComparisonExpression, S context);
+
+ default void visit(AnyComparisonExpression anyComparisonExpression) {
+ this.visit(anyComparisonExpression, null);
+ }
+
+ T visit(Concat concat, S context);
+
+ default void visit(Concat concat) {
+ this.visit(concat, null);
+ }
+
+ T visit(Matches matches, S context);
+
+ default void visit(Matches matches) {
+ this.visit(matches, null);
+ }
+
+ T visit(BitwiseAnd bitwiseAnd, S context);
+
+ default void visit(BitwiseAnd bitwiseAnd) {
+ this.visit(bitwiseAnd, null);
+ }
+
+ T visit(BitwiseOr bitwiseOr, S context);
+
+ default void visit(BitwiseOr bitwiseOr) {
+ this.visit(bitwiseOr, null);
+ }
+
+ T visit(BitwiseXor bitwiseXor, S context);
+
+ default void visit(BitwiseXor bitwiseXor) {
+ this.visit(bitwiseXor, null);
+ }
+
+ T visit(CastExpression castExpression, S context);
+
+ default void visit(CastExpression castExpression) {
+ this.visit(castExpression, null);
+ }
+
+ T visit(Modulo modulo, S context);
+
+ default void visit(Modulo modulo) {
+ this.visit(modulo, null);
+ }
+
+ T visit(AnalyticExpression analyticExpression, S context);
+
+ default void visit(AnalyticExpression analyticExpression) {
+ this.visit(analyticExpression, null);
+ }
+
+ T visit(ExtractExpression extractExpression, S context);
+
+ default void visit(ExtractExpression extractExpression) {
+ this.visit(extractExpression, null);
+ }
+
+ T visit(IntervalExpression intervalExpression, S context);
+
+ default void visit(IntervalExpression intervalExpression) {
+ this.visit(intervalExpression, null);
+ }
+
+ T visit(OracleHierarchicalExpression hierarchicalExpression, S context);
+
+ default void visit(OracleHierarchicalExpression hierarchicalExpression) {
+ this.visit(hierarchicalExpression, null);
+ }
+
+ T visit(RegExpMatchOperator regExpMatchOperator, S context);
+
+ default void visit(RegExpMatchOperator regExpMatchOperator) {
+ this.visit(regExpMatchOperator, null);
+ }
+
+ T visit(JsonExpression jsonExpression, S context);
+
+ default void visit(JsonExpression jsonExpression) {
+ this.visit(jsonExpression, null);
+ }
+
+ T visit(JsonOperator jsonOperator, S context);
+
+ default void visit(JsonOperator jsonOperator) {
+ this.visit(jsonOperator, null);
+ }
+
+ T visit(UserVariable userVariable, S context);
+
+ default void visit(UserVariable userVariable) {
+ this.visit(userVariable, null);
+ }
+
+ T visit(NumericBind numericBind, S context);
+
+ default void visit(NumericBind numericBind) {
+ this.visit(numericBind, null);
+ }
+
+ T visit(KeepExpression keepExpression, S context);
+
+ default void visit(KeepExpression keepExpression) {
+ this.visit(keepExpression, null);
+ }
+
+ T visit(MySQLGroupConcat groupConcat, S context);
+
+ default void visit(MySQLGroupConcat groupConcat) {
+ this.visit(groupConcat, null);
+ }
+
+ T visit(ExpressionList expressionList, S context);
+
+ default void visit(ExpressionList expressionList) {
+ this.visit(expressionList, null);
+ }
+
+ T visit(RowConstructor rowConstructor, S context);
+
+ default void visit(RowConstructor rowConstructor) {
+ this.visit(rowConstructor, null);
+ }
+
+ T visit(RowGetExpression rowGetExpression, S context);
+
+ default void visit(RowGetExpression rowGetExpression) {
+ this.visit(rowGetExpression, null);
+ }
+
+ T visit(OracleHint hint, S context);
+
+ default void visit(OracleHint hint) {
+ this.visit(hint, null);
+ }
+
+ T visit(TimeKeyExpression timeKeyExpression, S context);
+
+ default void visit(TimeKeyExpression timeKeyExpression) {
+ this.visit(timeKeyExpression, null);
+ }
+
+ T visit(DateTimeLiteralExpression dateTimeLiteralExpression, S context);
+
+ default void visit(DateTimeLiteralExpression dateTimeLiteralExpression) {
+ this.visit(dateTimeLiteralExpression, null);
+ }
+
+ T visit(NotExpression notExpression, S context);
+
+ default void visit(NotExpression notExpression) {
+ this.visit(notExpression, null);
+ }
+
+ T visit(NextValExpression nextValExpression, S context);
+
+ default void visit(NextValExpression nextValExpression) {
+ this.visit(nextValExpression, null);
+ }
+
+ T visit(CollateExpression collateExpression, S context);
+
+ default void visit(CollateExpression collateExpression) {
+ this.visit(collateExpression, null);
+ }
+
+ T visit(SimilarToExpression similarToExpression, S context);
+
+ default void visit(SimilarToExpression similarToExpression) {
+ this.visit(similarToExpression, null);
+ }
+
+ T visit(ArrayExpression arrayExpression, S context);
-public interface ExpressionVisitor {
+ default void visit(ArrayExpression arrayExpression) {
+ this.visit(arrayExpression, null);
+ }
- public void visit(BitwiseRightShift aThis);
+ T visit(ArrayConstructor arrayConstructor, S context);
- public void visit(BitwiseLeftShift aThis);
+ default void visit(ArrayConstructor arrayConstructor) {
+ this.visit(arrayConstructor, null);
+ }
- void visit(NullValue nullValue);
+ T visit(VariableAssignment variableAssignment, S context);
- void visit(Function function);
+ default void visit(VariableAssignment variableAssignment) {
+ this.visit(variableAssignment, null);
+ }
- void visit(SignedExpression signedExpression);
+ T visit(XMLSerializeExpr xmlSerializeExpr, S context);
- void visit(JdbcParameter jdbcParameter);
+ default void visit(XMLSerializeExpr xmlSerializeExpr) {
+ this.visit(xmlSerializeExpr, null);
+ }
- void visit(JdbcNamedParameter jdbcNamedParameter);
+ T visit(TimezoneExpression timezoneExpression, S context);
- void visit(DoubleValue doubleValue);
+ default void visit(TimezoneExpression timezoneExpression) {
+ this.visit(timezoneExpression, null);
+ }
- void visit(LongValue longValue);
+ T visit(JsonAggregateFunction jsonAggregateFunction, S context);
- void visit(HexValue hexValue);
+ default void visit(JsonAggregateFunction jsonAggregateFunction) {
+ this.visit(jsonAggregateFunction, null);
+ }
- void visit(DateValue dateValue);
+ T visit(JsonFunction jsonFunction, S context);
- void visit(TimeValue timeValue);
+ default void visit(JsonFunction jsonFunction) {
+ this.visit(jsonFunction, null);
+ }
- void visit(TimestampValue timestampValue);
+ default T visit(JsonTableFunction jsonTableFunction, S context) {
+ return visit((Function) jsonTableFunction, context);
+ }
- void visit(Parenthesis parenthesis);
+ default void visit(JsonTableFunction jsonTableFunction) {
+ this.visit(jsonTableFunction, null);
+ }
- void visit(StringValue stringValue);
+ T visit(ConnectByRootOperator connectByRootOperator, S context);
- void visit(Addition addition);
+ default void visit(ConnectByRootOperator connectByRootOperator) {
+ this.visit(connectByRootOperator, null);
+ }
- void visit(Division division);
+ T visit(ConnectByPriorOperator connectByPriorOperator, S context);
- void visit(Multiplication multiplication);
+ default void visit(ConnectByPriorOperator connectByPriorOperator) {
+ this.visit(connectByPriorOperator, null);
+ }
- void visit(Subtraction subtraction);
+ T visit(OracleNamedFunctionParameter oracleNamedFunctionParameter, S context);
- void visit(AndExpression andExpression);
+ default void visit(OracleNamedFunctionParameter oracleNamedFunctionParameter) {
+ this.visit(oracleNamedFunctionParameter, null);
+ }
- void visit(OrExpression orExpression);
+ T visit(AllColumns allColumns, S context);
- void visit(Between between);
+ T visit(FunctionAllColumns functionColumns, S context);
- void visit(EqualsTo equalsTo);
+ default void visit(AllColumns allColumns) {
+ this.visit(allColumns, null);
+ }
- void visit(GreaterThan greaterThan);
+ T visit(AllTableColumns allTableColumns, S context);
- void visit(GreaterThanEquals greaterThanEquals);
+ default void visit(AllTableColumns allTableColumns) {
+ this.visit(allTableColumns, null);
+ }
- void visit(InExpression inExpression);
+ T visit(AllValue allValue, S context);
- void visit(IsNullExpression isNullExpression);
+ default void visit(AllValue allValue) {
+ this.visit(allValue, null);
+ }
- void visit(LikeExpression likeExpression);
+ T visit(IsDistinctExpression isDistinctExpression, S context);
- void visit(MinorThan minorThan);
+ default void visit(IsDistinctExpression isDistinctExpression) {
+ this.visit(isDistinctExpression, null);
+ }
- void visit(MinorThanEquals minorThanEquals);
+ T visit(GeometryDistance geometryDistance, S context);
- void visit(NotEqualsTo notEqualsTo);
+ default void visit(GeometryDistance geometryDistance) {
+ this.visit(geometryDistance, null);
+ }
- void visit(Column tableColumn);
+ T visit(Select select, S context);
- void visit(SubSelect subSelect);
+ T visit(TranscodingFunction transcodingFunction, S context);
- void visit(CaseExpression caseExpression);
+ default void visit(TranscodingFunction transcodingFunction) {
+ this.visit(transcodingFunction, null);
+ }
- void visit(WhenClause whenClause);
+ T visit(TrimFunction trimFunction, S context);
- void visit(ExistsExpression existsExpression);
+ default void visit(TrimFunction trimFunction) {
+ this.visit(trimFunction, null);
+ }
- void visit(AllComparisonExpression allComparisonExpression);
+ T visit(RangeExpression rangeExpression, S context);
- void visit(AnyComparisonExpression anyComparisonExpression);
+ default void visit(RangeExpression rangeExpression) {
+ this.visit(rangeExpression, null);
+ }
- void visit(Concat concat);
+ T visit(TSQLLeftJoin tsqlLeftJoin, S context);
- void visit(Matches matches);
+ default void visit(TSQLLeftJoin tsqlLeftJoin) {
+ this.visit(tsqlLeftJoin, null);
+ }
- void visit(BitwiseAnd bitwiseAnd);
+ T visit(TSQLRightJoin tsqlRightJoin, S context);
- void visit(BitwiseOr bitwiseOr);
+ default void visit(TSQLRightJoin tsqlRightJoin) {
+ this.visit(tsqlRightJoin, null);
+ }
- void visit(BitwiseXor bitwiseXor);
+ T visit(StructType structType, S context);
- void visit(CastExpression cast);
+ default void visit(StructType structType) {
+ this.visit(structType, null);
+ }
- void visit(Modulo modulo);
+ T visit(LambdaExpression lambdaExpression, S context);
- void visit(AnalyticExpression aexpr);
+ default void visit(LambdaExpression lambdaExpression) {
+ this.visit(lambdaExpression, null);
+ }
- void visit(ExtractExpression eexpr);
+ T visit(HighExpression highExpression, S context);
- void visit(IntervalExpression iexpr);
+ default void visit(HighExpression highExpression) {
+ this.visit(highExpression, null);
+ }
- void visit(OracleHierarchicalExpression oexpr);
+ T visit(LowExpression lowExpression, S context);
- void visit(RegExpMatchOperator rexpr);
+ default void visit(LowExpression lowExpression) {
+ this.visit(lowExpression, null);
+ }
- void visit(JsonExpression jsonExpr);
+ T visit(Plus plus, S context);
- void visit(JsonOperator jsonExpr);
+ default void visit(Plus plus) {
+ this.visit(plus, null);
+ }
- void visit(RegExpMySQLOperator regExpMySQLOperator);
+ T visit(PriorTo priorTo, S context);
- void visit(UserVariable var);
+ default void visit(PriorTo priorTo) {
+ this.visit(priorTo, null);
+ }
- void visit(NumericBind bind);
+ T visit(Inverse inverse, S context);
- void visit(KeepExpression aexpr);
+ default void visit(Inverse inverse) {
+ this.visit(inverse, null);
+ }
- void visit(MySQLGroupConcat groupConcat);
-
- void visit(ValueListExpression valueList);
+ T visit(CosineSimilarity cosineSimilarity, S context);
- void visit(RowConstructor rowConstructor);
+ T visit(FromQuery fromQuery, S context);
- void visit(OracleHint hint);
+ T visit(DateUnitExpression dateUnitExpression, S context);
- void visit(TimeKeyExpression timeKeyExpression);
+ T visit(KeyExpression keyExpression, S context);
- void visit(DateTimeLiteralExpression literal);
+ default void visit(KeyExpression keyExpression) {
+ this.visit(keyExpression, null);
+ }
- public void visit(NotExpression aThis);
+ T visit(PostgresNamedFunctionParameter postgresNamedFunctionParameter, S context);
+ default void visit(PostgresNamedFunctionParameter postgresNamedFunctionParameter) {
+ this.visit(postgresNamedFunctionParameter, null);
+ }
}
diff --git a/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapter.java b/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapter.java
index 995c22810..c546a4c2c 100644
--- a/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapter.java
+++ b/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapter.java
@@ -1,503 +1,888 @@
-/*
+/*-
* #%L
* JSQLParser library
* %%
- * Copyright (C) 2004 - 2015 JSQLParser
+ * Copyright (C) 2004 - 2019 JSQLParser
* %%
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation, either version 2.1 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Lesser Public License for more details.
- *
- * You should have received a copy of the GNU General Lesser Public
- * License along with this program. If not, see
- * T visit(NullValue nullValue, S context) {
+ return applyExpression(nullValue, context);
}
@Override
- public void visit(Function function) {
+ public T visit(Function function, S context) {
+ ArrayList T visit(SignedExpression signedExpression, S context) {
+ return signedExpression.getExpression().accept(this, context);
}
@Override
- public void visit(SignedExpression expr) {
- expr.getExpression().accept(this);
+ public T visit(JdbcParameter jdbcParameter, S context) {
+ return applyExpression(jdbcParameter, context);
}
@Override
- public void visit(JdbcParameter parameter) {
+ public T visit(JdbcNamedParameter jdbcNamedParameter, S context) {
+ return applyExpression(jdbcNamedParameter, context);
+ }
+
+ @Override
+ public T visit(DoubleValue doubleValue, S context) {
+ return applyExpression(doubleValue, context);
+ }
+ @Override
+ public T visit(LongValue longValue, S context) {
+ return applyExpression(longValue, context);
}
@Override
- public void visit(JdbcNamedParameter parameter) {
+ public T visit(DateValue dateValue, S context) {
+ return applyExpression(dateValue, context);
+ }
+ @Override
+ public T visit(TimeValue timeValue, S context) {
+ return applyExpression(timeValue, context);
}
@Override
- public void visit(DoubleValue value) {
+ public T visit(TimestampValue timestampValue, S context) {
+ return applyExpression(timestampValue, context);
+ }
+ @Override
+ public T visit(StringValue stringValue, S context) {
+ return applyExpression(stringValue, context);
}
@Override
- public void visit(LongValue value) {
+ public T visit(BooleanValue booleanValue, S context) {
+ return applyExpression(booleanValue, context);
+ }
+ @Override
+ public T visit(Addition addition, S context) {
+ return visitBinaryExpression(addition, context);
}
@Override
- public void visit(DateValue value) {
+ public T visit(Division division, S context) {
+ return visitBinaryExpression(division, context);
+ }
+ @Override
+ public T visit(IntegerDivision integerDivision, S context) {
+ return visitBinaryExpression(integerDivision, context);
}
@Override
- public void visit(TimeValue value) {
+ public T visit(Multiplication multiplication, S context) {
+ return visitBinaryExpression(multiplication, context);
+ }
+ @Override
+ public T visit(Subtraction subtraction, S context) {
+ return visitBinaryExpression(subtraction, context);
}
@Override
- public void visit(TimestampValue value) {
+ public T visit(AndExpression andExpression, S context) {
+ return visitBinaryExpression(andExpression, context);
+ }
+ @Override
+ public