Build a Sybase T‑SQL migration tool
Use General SQL Parser from Java or .NET to turn a Sybase ASE or IQ codebase into a migration inventory: parsed statements, stored procedures, tables, columns, calls, errors, and dependencies. GSP provides the analysis foundation—not a one-click T-SQL-to-application-code converter.
Short answer
Teams searching for a “Sybase T-SQL to Java conversion tool” usually face two separate jobs. First, understand and classify the SQL estate. Second, replace or rewrite each behavior in the chosen target architecture. GSP automates the first job and supplies AST primitives for reviewed, narrow rewrites in the second; it does not claim that parsing alone completes the migration.
A migration workflow that preserves evidence
- Parse the complete source corpus. Record every file, batch, statement type, and parser error with its location instead of treating an unreadable routine as an empty dependency set.
- Build a procedural inventory. Classify procedures, functions, triggers, dynamic SQL, temporary objects, transaction control, and Sybase-specific statements before estimating conversion effort.
- Extract the dependency graph. Connect routines to tables, views, columns, and other routines so sequencing and impact analysis are based on relationships rather than file names.
- Apply only reviewed transformations. Use AST nodes for explicit rules such as identifier changes or approved syntax rewrites. Keep ambiguous procedural behavior in a manual-remediation queue.
- Validate every output layer. Re-parse generated SQL, compile generated application code, and run database-level behavior tests. Preserve source-to-target traceability for each automated decision.
Start the inventory in Java or C#
Both editions select the dedicated Sybase grammar with EDbVendor.dbvsybase. The
snippets below use the same stored-procedure sample published on the Sybase parser page; Java
uses getters for parser errors, while .NET exposes idiomatic properties. This minimal entry
point records parse status and statement type; use GSP's visitor or lineage APIs to walk nested
procedure bodies and collect dependencies.
Java
import gudusoft.gsqlparser.*;
String sql = "CREATE PROCEDURE update_dept_count @dept INT AS\nBEGIN\n UPDATE dept SET cnt = (SELECT COUNT(*) FROM emp WHERE emp.dept_id = @dept)\n WHERE dept.id = @dept\nEND";
TGSqlParser parser = new TGSqlParser(EDbVendor.dbvsybase);
parser.sqltext = sql;
if (parser.parse() != 0) {
System.out.println(parser.getErrormessage());
return;
}
for (int i = 0; i < parser.sqlstatements.size(); i++) {
TCustomSqlStatement statement = parser.sqlstatements.get(i);
System.out.println(statement.sqlstatementtype);
}C#
using gudusoft.gsqlparser;
string sql = "CREATE PROCEDURE update_dept_count @dept INT AS\nBEGIN\n UPDATE dept SET cnt = (SELECT COUNT(*) FROM emp WHERE emp.dept_id = @dept)\n WHERE dept.id = @dept\nEND";
TGSqlParser parser = new TGSqlParser(EDbVendor.dbvsybase);
parser.sqltext = sql;
if (parser.parse() != 0)
{
Console.WriteLine(parser.Errormessage);
return;
}
for (int i = 0; i < parser.sqlstatements.size(); i++)
{
TCustomSqlStatement statement = parser.sqlstatements.get(i);
Console.WriteLine(statement.sqlstatementtype);
}Measured Sybase coverage, with a clear boundary
These figures come from the versioned Sybase documented-example corpus and update with the dialect manifest. They measure whether every example in a construct parses; they are not an estimate of how much of your migration can be converted automatically.
- Documented constructs
- 111 of 123 parse fully (90%)
- Individual statements
- 296 of 335 parse successfully
- Measured release
- GSP 4.1.10, measured 2026-08-08
- Construct-level evidence
- Open capability data
What GSP contributes—and what remains yours
GSP is a strong fit when the migration product needs dialect-aware parsing, a traversable AST, table and column extraction, validation signals, controlled rewriting, or column-level lineage inside Java or .NET.
- GSP does not decide whether a stored procedure should become Java, C#, target-database SQL, or a service boundary.
- GSP does not prove transactional or runtime equivalence between the source and target systems.
- Dynamic SQL with unresolved runtime fragments requires conservative handling and representative test data.
- Customer-specific ASE and IQ patterns should be evaluated before estimating automation rates.
Common migration questions
Does GSP convert Sybase T-SQL directly into Java or C#?
No. GSP is not an end-to-end transpiler and does not turn a stored procedure into equivalent application code automatically. It supplies the Sybase parser, AST, dependency extraction, validation, lineage, and controlled rewriting layer that a Java or .NET migration tool can build on.
What does “to Java or .NET” mean on this page?
Java and .NET are the runtimes that host the migration analysis. The input remains Sybase T-SQL. Your application uses GSP to inventory and inspect that SQL, apply explicit rules where they are safe, and route the remaining cases for manual remediation.
Does the Sybase analysis require a live database connection?
No. Parsing, AST inspection, syntax validation, and dependency extraction run in-process. A catalog can improve semantic resolution, but GSP does not need Sybase credentials just to parse and classify a source corpus.
Does GSP cover both Sybase ASE and Sybase IQ syntax?
The dedicated Sybase grammar covers ASE Transact-SQL and tested IQ and Watcom-style constructs. Coverage is measured against a documented-example corpus, but no aggregate percentage guarantees that every customer procedure will parse. Submit representative ASE or IQ routines before relying on automation.
How should a team validate a Sybase migration?
Start with a source parse inventory, preserve dependency and lineage evidence, limit automatic rewrites to reviewed rules, parse or compile the generated target, and run database-level behavior tests. Parsing is one verification layer, not a substitute for semantic and runtime testing.
Test the procedure that sets your migration risk
Send one representative Sybase stored procedure with customer data and production identifiers removed. Gudu will check whether it parses, identify the relevant AST and dependency outputs, and separate feasible automation from work that still needs engineering judgment.