Skip to content

Technical FAQ

Find answers to common technical questions about General SQL Parser. If you can't find what you're looking for, check our support channels.

Installation & Dependencies

Does General SQL Parser depend on any third-party libraries?

Dependencies

General SQL Parser (GSP) is completely self-contained and doesn't depend on any third-party libraries, software, or DLLs.

System Requirements:

  • Minimum: JRE 1.5+
  • Recommended: JRE 8+ or higher
  • Latest tested: Java 21
  • Minimum: .NET Framework 4.5
  • Supports: .NET Standard 2.0+
  • Compatible with: .NET Core, .NET 5/6/7/8

Is the .NET version compatible with .NET Standard?

Yes, fully compatible

General SQL Parser .NET version is .NET Standard 2.0 compatible, which means it can run on all .NET platforms that implement .NET Standard, including:

  • .NET Framework 4.6.1+
  • .NET Core 2.0+
  • .NET 5/6/7/8
  • Xamarin
  • Unity

Database Connectivity

Do I need to connect to a database to validate SQL syntax?

No database connection required

GSP can validate SQL syntax completely offline without any connection to database instances.

Key Benefits:

  • ✅ No internet connection required
  • ✅ No database server needed
  • ✅ All SQL parser engines included
  • ✅ Works in air-gapped environments
  • ✅ Fast local validation

Example: 

1
2
3
TGSqlParser parser = new TGSqlParser(EDbVendor.dbvoracle);
parser.sqltext = "SELECT * FROM employees WHERE salary > 50000";
int result = parser.parse(); // No database connection needed!

Which databases can GSP parse without connecting to them?

GSP supports 30+ database vendors for offline parsing:

  • Oracle Database
  • Microsoft SQL Server
  • PostgreSQL
  • MySQL / MariaDB
  • IBM DB2
  • Teradata
  • Amazon Redshift
  • Google BigQuery
  • Snowflake
  • Microsoft Azure SQL
  • Amazon Aurora

SQL Syntax Support

How comprehensive is GSP's SQL syntax support?

Our Philosophy

The goal of General SQL Parser is NOT to support ALL SQL syntax of every database, but to support the most commonly used SQL syntax that covers 95%+ of real-world use cases.

Coverage by Statement Type:

SQL Type Coverage Notes
SELECT statements 98%+ Comprehensive support including CTEs, window functions
INSERT/UPDATE/DELETE 95%+ Standard and vendor-specific extensions
DDL (CREATE/ALTER/DROP) 90%+ Most common schema operations
PL/SQL / T-SQL blocks 85%+ Stored procedures, functions, triggers
Advanced features 80%+ Vendor-specific extensions, new syntax

When will new SQL syntax be supported?

Support Strategy

We add support for new SQL syntax based on user demand and practical usage. Here's our typical timeline:

Response Times:

2-3 weeks for widely-used syntax or critical parsing errors

4-8 weeks for new SQL features or vendor extensions

2-6 months for complex language features or major vendor updates

How to Request Support:

  1. Submit a request via our support channels
  2. Provide SQL examples that aren't parsing correctly
  3. Specify the database vendor and version
  4. Describe your use case to help us prioritize

Expedited Support

For urgent requirements, we offer custom development services with guaranteed timelines. Contact info@sqlparser.com for details.

Performance & Scalability

How fast is General SQL Parser?

Performance Characteristics

Typical Performance: - Simple queries: < 1ms - Complex queries: 1-10ms - Large stored procedures: 10-100ms - Batch processing: 1000+ queries/second

Factors Affecting Performance:

  • Number of tables and joins
  • Depth of subqueries
  • Size of SQL text
  • Vendor-specific features used
  • Available memory (heap size for Java)
  • CPU performance
  • JVM configuration
  • Concurrent parsing threads
  • Database vendor selection
  • Parser options enabled
  • AST traversal depth

Optimization Tips: 

1
2
3
4
5
6
7
8
9
// Reuse parser instances when possible
TGSqlParser parser = new TGSqlParser(EDbVendor.dbvoracle);

// Parse multiple statements efficiently
for (String sql : sqlStatements) {
    parser.sqltext = sql;
    parser.parse();
    // Process results...
}

Can GSP handle large SQL files?

Yes, with proper configuration

GSP can handle large SQL files, but consider these best practices:

Memory Management: - Java: Increase heap size (-Xmx4g or higher) - Batch Processing: Parse statements individually rather than as one large file - Streaming: Process large files in chunks

Example for Large Files: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
// For large SQL files, parse statements one by one
List<String> statements = splitSQLStatements(largeSQLFile);
for (String statement : statements) {
    parser.sqltext = statement;
    int result = parser.parse();
    if (result == 0) {
        // Process successful parse
        processStatement(parser.sqlstatements.get(0));
    }
    // Clear parser state for next statement
    parser.sqlstatements.clear();
}

Support & Troubleshooting

How do I get help with parsing errors?

Getting Help

Before Asking for Help:

  1. ✅ Check this FAQ and our documentation
  2. ✅ Verify you're using the correct database vendor
  3. ✅ Try the SQL with a simpler example
  4. ✅ Check our error handling guide

When Reporting Issues, Include:

  • SQL statement that's failing to parse
  • Database vendor and version
  • Error message from GSP
  • Expected behavior vs actual behavior
  • GSP version you're using
  • Use case description
  • Programming language (Java/.NET)
  • Environment details (OS, JVM version, etc.)
  • Sample data if relevant

Contact Methods:

What's included in technical support?

Support Levels

Free Support: Email-based technical support for all users

Response Time: 2-3 weeks (not guaranteed)

Email-based technical support for all users:

  • ✅ Bug reports and fixes
  • ✅ Feature requests evaluation
  • ✅ Basic usage questions
  • ✅ Documentation clarifications

Expedited support for critical business needs:

  • 🚀 Guaranteed response times
  • 🚀 Direct engineer access
  • 🚀 Custom development
  • 🚀 Priority bug fixes
  • 🚀 Feature implementation

Contact: info@sqlparser.com

Advanced Usage

Can I extend GSP with custom SQL syntax?

Limited Extensibility

General SQL Parser has limited built-in extensibility for custom SQL syntax. However, we offer several options:

Available Options:

  1. Custom Development: We can extend GSP to support your specific SQL dialect
  2. Parser Modification: Source code modifications for enterprise customers
  3. Preprocessing: Transform your custom syntax before parsing
  4. Feature Requests: Submit requests for widely-applicable extensions

Does GSP support SQL transformation and rewriting?

Yes, with AST manipulation

GSP provides full Abstract Syntax Tree (AST) access for SQL transformation:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
// Example: Transform SQL after parsing
TGSqlParser parser = new TGSqlParser(EDbVendor.dbvoracle);
parser.sqltext = "SELECT * FROM old_table";
parser.parse();

TSelectSqlStatement select = (TSelectSqlStatement) parser.sqlstatements.get(0);
// Modify the AST
select.tables.getTable(0).setTableName("new_table");

// Generate modified SQL
String newSQL = select.toString(); // "SELECT * FROM new_table"

Common Transformations: - Table name substitution - Column aliasing - Query optimization - Dialect conversion - Schema migration

Still Need Help?

Can't find the answer you're looking for? We're here to help!

Visit Support Center Browse Tutorials Check How-to Guides