The SQL parser your product builds on.

General SQL Parser turns raw SQL into an AST, resolved tables and columns, validation errors, and column-level lineage — in-process, offline, in Java and .NET. 37 dialects, each with its own dedicated grammar.

Start free trial Send SQL sample

No database connection, no cloud round-trip — the parser runs where your code runs.

oracle · parse

select c.customer_id, sum(o.amount) total
  from customers c
  join orders o on c.id = o.customer_id
 group by c.customer_id

statement 1 · sstselect
tables   customers c · orders o
columns  c.customer_id · sum(o.amount) AS total

Parse into a real AST

Statement type, clauses, expressions, joins, predicates, and nested query structure — a semantic tree your code traverses, not a token stream.

java

TGSqlParser parser = new TGSqlParser(EDbVendor.dbvoracle);
parser.sqltext = sql;
if (parser.parse() == 0) {
    System.out.println(parser.sqlstatements.size() + " statement(s) parsed");
}
// 1 statement(s) parsed

Resolve tables and columns

Source tables, result columns, aliases, and scopes — resolved across subqueries, CTEs, and views, ready for downstream tooling.

c# · output in comments

for (int t = 0; t < stmt.tables.size(); t++)
{
    TTable table = stmt.tables.getTable(t);
    Console.WriteLine(table.FullName + " " + table.AliasName);
}
// customers c
// orders o

Validate without a database

Syntax and semantic errors with line and column positions, entirely offline — point a user straight at the problem before execution.

c# · real error output

if (result != 0)
{
    Console.WriteLine(parser.Errormessage);
    // syntax error, state:90(10101) near: from(1,8)
    return;
}

Trace column-level lineage

The DataFlowAnalyzer resolves a view’s column back through aggregates and joins to its source — the engine behind Gudu SQLFlow and the DataHub and OpenMetadata integrations.

dlineage · real output, trimmed

<dlineage>
  <table id="2" name="ORDERS" type="table" alias="O">
    <column id="5" name="AMOUNT" />
  </table>
  <view id="4" name="V_CUSTOMER_TOTAL" type="view">
    <column id="9" name="TOTAL_AMOUNT" />
  </view>
  <relation type="dataflow" id="2">
    <target id="7" column="TOTAL_AMOUNT" parent_name="RESULT_OF_SELECT-QUERY" />
    <source id="5" column="AMOUNT"       parent_name="ORDERS" />
  </relation>
</dlineage>

37dedicated dialect grammars

12,000+unit tests behind releases

Weeklyrelease cadence

Java · .NETnative SDKs

Open-source parsers are useful. Enterprise edge cases need a support path.

JSqlParser, sqlglot, Calcite, and ANTLR grammars can be good fits for prototypes or narrow syntax needs. GSP is for commercial Java and .NET teams that need broad dialect coverage, stable APIs, private deployment — and a vendor who fixes the grammar when real customer SQL breaks the happy path.

GSP vs JSqlParser → the Java open-source default
GSP vs ANTLR → build your parser, or buy one
GSP vs sqlglot → the Python transpiler
GSP vs Apache Calcite → the query framework
GSP vs ScriptDom → Microsoft’s T-SQL-only parser

Built for SQL-aware enterprise products

Database IDEs, SQL editors, and formatters
Data lineage and impact analysis
SQL migration and modernization tools
AI-generated SQL validation and guardrails
Field-level permission checks
Audit and compliance workflows

Coverage for the SQL your customers actually use

Have a stored procedure, migration script, dynamic SQL block, or generated query that is hard to parse? Send a sample for review — Gudu replies with compatibility notes and the recommended integration path.