---

## What it does

Give it SQL. Get an AST you can walk, rewrite, and print back out.

```sql
SELECT 1 FROM dual WHERE a = b
```

```text
SQL Text
 └─Statements: statement.select.PlainSelect
    ├─selectItems: statement.select.SelectItem
    │  └─LongValue: 1
    ├─Table: dual
    └─where: expression.operators.relational.EqualsTo
       ├─Column: a
       └─Column: b
```

```java
String sqlStr = "select 1 from dual where a=b";

PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse(sqlStr);

SelectItem selectItem = select.getSelectItems().get(0);
Assertions.assertEquals(new LongValue(1), selectItem.getExpression());

Table table = (Table) select.getFromItem();
Assertions.assertEquals("dual", table.getName());

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());
```

The tree is traversable with the Visitor pattern, and the same object model works in reverse:
build statements from Java with a [fluent API](https://jsqlparser.github.io/JSqlParser/usage.html#build-a-sql-statements)
and render them as SQL text.

## Install

Use the stable **Manticore builds**. They are released continuously from the current development
line and carry all of the performance and grammar work described below. The upstream
`com.github.jsqlparser` release on Maven Central is considerably older.

```xml
<dependency>
    <groupId>com.manticore-projects.jsqlformatter</groupId>
    <artifactId>jsqlparser</artifactId>
    <version>[5.3.218,)</version>
</dependency>
```

```gradle
implementation("com.manticore-projects.jsqlformatter:jsqlparser:+")
```


Upstream release and snapshots

```xml
<dependency>
    <groupId>com.github.jsqlparser</groupId>
    <artifactId>jsqlparser</artifactId>
    <version>5.3</version>
</dependency>
```

Snapshot coordinates and repository setup are on the
[build dependencies page](https://jsqlparser.github.io/JSqlParser/usage.html#build-dependencies).



## Performance

**11× faster than 5.3**, and the fastest parser on real-world SQL of any of the parsers
tested, in any language — 19× ahead of `sqlglot[c]` on JSqlParser's own `SELECT` test suite.


  <a href="https://github.com/manticore-projects/jsqlparser-bench">
    
  </a>


```text
Benchmark                               (version)  Mode  Cnt   Score   Error  Units
JSQLParserBenchmark.parseSQLStatements     latest  avgt   15   7.602 ± 0.135  ms/op
JSQLParserBenchmark.parseSQLStatements        5.3  avgt   15  84.687 ± 3.321  ms/op
```

Methodology and the full cross-parser comparison against SQLGlot, `sqlglot[c]` and
polyglot-sql: **[jsqlparser-bench](https://github.com/manticore-projects/jsqlparser-bench)**.

## What it parses

JSqlParser targets the SQL standard plus all major RDBMS. One grammar covers all of them,
and missing syntax gets added on demand — [open an issue](https://github.com/JSQLParser/JSqlParser/issues).



|  | Statements |
|---|---|
| **Queries** | `SELECT` · `WITH …` · Piped SQL |
| **DML** | `INSERT` · `UPDATE` · `UPSERT` · `MERGE` · `DELETE` · `TRUNCATE TABLE` |
| **DDL** | `CREATE …` · `ALTER …` · `DROP …` |
| **PostgreSQL RLS** | `CREATE POLICY` · `ALTER TABLE … ENABLE`/`DISABLE`/`FORCE`/`NO FORCE ROW LEVEL SECURITY` |
| **Salesforce SOQL** | `INCLUDES` · `EXCLUDES` |

Beyond statement shapes, the grammar handles nested sub-selects, bind parameters (`?`,
`:name`), window and analytic functions, Oracle hints, and the T-SQL square-bracket versus
array-literal ambiguity. The complete reference is on the
[syntax page](https://jsqlparser.github.io/JSqlParser/syntax.html).

## Piped SQL

Support is progressing for Piped SQL, which writes queries in the order they actually
execute rather than the order SQL historically demanded.

```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;
```

Background reading: the [Google research paper](https://storage.googleapis.com/gweb-research2023-media/pubtools/1004848.pdf),
[BigQuery pipe syntax](https://cloud.google.com/bigquery/docs/reference/standard-sql/pipe-syntax)
and [DuckDB FROM-first syntax](https://duckdb.org/docs/sql/query_syntax/from.html#from-first-syntax).

## Java version

| JSqlParser | Runtime | Notes |
|------------|---------|-------|
| 4.9 | JDK 8 | last JDK 8 compatible release |
| 5.0 and later | JDK 11 | breaking changes to the AST Visitors, see the Migration Guide |
| 5.1 and later | JDK 11 | building requires a **JDK 17 toolchain** (plugin requirement) |
| 5.4 and later | JDK 11 | parser generated with **JavaCC 8** |

## Sister projects

- **[JSQLFormatter](https://manticore-projects.com/JSQLFormatter/index.html)** — pretty-printing and formatting of SQL text
- **[JSQLTranspiler](https://manticore-projects.com/JSQLTranspiler/index.html)** — dialect-specific rewriting, column resolution and lineage, by [Starlake.ai](https://starlake.ai/)

## Alternatives

The dual-licensed [JOOQ](https://www.jooq.org/doc/latest/manual/sql-building/sql-parser/)
ships a hand-written parser with broad RDBMS support, cross-dialect translation, SQL
transformation, and a JDBC proxy mode. Worth a look if translation between dialects is your
primary need rather than AST access.

## Sponsor

A huge thank you to **[Starlake.ai](https://starlake.ai/)**, who simplify data ingestion,
transformation and orchestration for faster delivery of high-quality data. Starlake has been
instrumental in providing Piped SQL support and a large number of test cases for BigQuery,
Redshift, Databricks and DuckDB. If JSqlParser is useful to you, visit
[Starlake.ai](https://starlake.ai/) and give them a star.

## Documentation

1. [Samples](https://jsqlparser.github.io/JSqlParser/usage.html#parse-a-sql-statements)
2. [Build instructions](https://jsqlparser.github.io/JSqlParser/usage.html) and [Maven artifact](https://jsqlparser.github.io/JSqlParser/usage.html#build-dependencies)
3. [Contribution guide](https://jsqlparser.github.io/JSqlParser/contribution.html)
4. [Change log](https://jsqlparser.github.io/JSqlParser/changelog.html#latest-changes-since-jsqlparser-version)
5. [Issues](https://github.com/JSQLParser/JSqlParser/issues)

## License

Dual licensed under **LGPL 2.1** or the **Apache License, Version 2.0**. Take your pick.