v1.6.0

🚀 GoSQLX v1.6.0 - Major Feature Release

This release represents a major milestone with 20+ PRs merged, adding comprehensive PostgreSQL support, a full Language Server Protocol implementation, VSCode extension, and significant performance optimizations.

✨ Highlights

Feature	Description
🐘 PostgreSQL Extensions	LATERAL JOIN, JSON/JSONB operators, DISTINCT ON, FILTER clause
🔌 LSP Server	Full Language Server Protocol for IDE integration
📝 VSCode Extension	Official extension with syntax highlighting & autocomplete
⚡ Performance	14x faster tokens, 575x faster keyword suggestions
🔍 Linter Rules	10 built-in rules (L001-L010) with auto-fix

---

🐘 PostgreSQL Features (PRs #173-#177)

LATERAL JOIN Support

SELECT u.name, recent_orders.total
FROM users u
LEFT JOIN LATERAL (
    SELECT SUM(amount) as total FROM orders WHERE user_id = u.id
) AS recent_orders ON true

JSON/JSONB Operators

• Arrow operators: ->, ->>
• Path operators: #>, #>>
• Containment: @>, <@
• Existence: ?, ?|, ?&
• Delete: #-

SELECT data -> 'user' ->> 'email', 
       data #> '{address,city}'
FROM users 
WHERE data @> '{"active": true}'

DISTINCT ON & FILTER Clause

SELECT DISTINCT ON (user_id) user_id, created_at, status
FROM orders ORDER BY user_id, created_at DESC;

SELECT COUNT(*) FILTER (WHERE status = 'completed') FROM orders;

---

🔌 Language Server Protocol (PRs #128-#129)

Full LSP implementation for IDE integration:

• Diagnostics: Real-time syntax error detection
• Hover: Documentation for 60+ SQL keywords
• Completion: 100+ keywords, functions, and 22 snippets
• Formatting: SQL code formatting
• Document Symbols: Statement outline navigation
• Signature Help: Function signatures for 20+ SQL functions
• Code Actions: Quick fixes (add semicolon, uppercase keywords)

gosqlx lsp              # Start LSP server
gosqlx lsp --log /tmp/lsp.log  # With debug logging

---

📝 VSCode Extension (PRs #132, #135)

Official GoSQLX extension for Visual Studio Code:

• Real-time SQL validation via LSP
• SQL syntax highlighting with TextMate grammar
• SQL formatting with customizable options
• Intelligent autocomplete
• Multi-dialect support

---

🔍 Linter Rules (PRs #164, #176)

10 built-in rules with auto-fix:

Rule	Description
L001	Avoid SELECT *
L002	Missing table aliases in JOIN
L003	Implicit column aliases
L004	Missing WHERE in UPDATE/DELETE
L005	Inefficient LIKE patterns
L006	Use explicit JOIN syntax
L007	ORDER BY ordinal numbers
L008	Inconsistent keyword casing
L009	Missing column list in INSERT
L010	DISTINCT without ORDER BY

gosqlx lint query.sql
gosqlx lint --fix query.sql

---

⚡ Performance Improvements

• 14x faster token type comparison with O(1) int-based lookups
• 575x faster keyword suggestions with caching
• 22.5x faster config file loading
• 1.38M+ ops/sec sustained throughput maintained

---

🛠️ Developer Tools

• go-task: Modern Taskfile.yml replacing Makefile
• Structured Errors: Error codes E1001-E3004
• Security Scanner: Enhanced SQL injection detection
• Test Coverage: AST 80%+, Models 100%

---

📦 Installation

# Library
go get github.com/ajitpratap0/[email protected]

# CLI
go install github.com/ajitpratap0/GoSQLX/cmd/[email protected]

---

📋 Full Changelog

See CHANGELOG.md for the complete list of changes.

Full Changelog: v1.5.1...v1.6.0

v1.5.0

GoSQLX v1.5.0 - Phase 1 Test Coverage Achievement

Release Date: November 15, 2025
Release Type: Minor Version Release
Focus: Comprehensive Test Coverage & Quality Assurance

---

🎯 Executive Summary

GoSQLX v1.5.0 marks a major quality milestone with the completion of Phase 1 comprehensive test coverage improvements across CLI, Parser, and Tokenizer packages. This release establishes GoSQLX as enterprise-grade software with test coverage exceeding industry standards.

✅ Key Achievements

• ✅ Triple Coverage Success: All three Phase 1 coverage targets met or exceeded
• ✅ 3,094 Lines of Tests: Comprehensive test suite across 7 new test files
• ✅ 115+ Real-World Queries: Production SQL validation (95%+ success rate)
• ✅ Zero Race Conditions: 20,000+ concurrent operations tested
• ✅ International Validation: Full UTF-8 testing across 8 languages
• ✅ Code Quality: 529 lines removed through refactoring

---

📊 Test Coverage Achievements

Package	Baseline	Target	Achieved	Status
CLI	~50%	60%	63.3%	✅ Exceeded by 3.3%
Parser	57.4%	75%	75.0%	✅ Met exactly
Tokenizer	60.0%	70%	76.5%	✅ Exceeded by 6.5%

Improvement Metrics:

• CLI: +13.3 percentage points
• Parser: +17.6 percentage points
• Tokenizer: +16.5 percentage points

---

🚀 Production Readiness Enhancements

Battle-Tested Reliability

• 3,094 lines of new test code across 7 comprehensive test files
• 115+ production SQL queries tested across multiple dialects (PostgreSQL, MySQL, SQL Server, Oracle)
• 95%+ success rate on real-world SQL queries
• Zero race conditions detected across 20,000+ concurrent operations

International Support

• Full UTF-8 testing across 8 languages
• Chinese, Japanese, Korean, Arabic, Russian, Spanish, French, German
• Emoji support validated
• Comprehensive multi-byte character handling

Code Quality Improvements

• 529 lines removed through refactoring
• Enhanced error handling across all CLI commands
• Improved UTF-8 character handling
• Consolidated input reading logic

---

📦 Installation

Go Module

```bash
go get github.com/ajitpratap0/[email protected]
```

CLI Tool

```bash
go install github.com/ajitpratap0/GoSQLX/cmd/[email protected]
```

---

🔄 Upgrade from v1.4.0

100% Backward Compatible - This is a drop-in replacement for v1.4.0.

```bash

Update dependency

go get -u github.com/ajitpratap0/[email protected]

Update CLI (if installed)

go install github.com/ajitpratap0/GoSQLX/cmd/[email protected]

Verify

go list -m github.com/ajitpratap0/GoSQLX
```

No breaking changes - All existing APIs and functionality remain fully supported.

---

📈 Performance Metrics (Maintained)

All performance metrics maintained from v1.4.0:

Metric	Value	Status
Sustained Throughput	1.38M+ ops/sec	✅ Maintained
Peak Throughput	1.5M+ ops/sec	✅ Maintained
Token Processing	8M+ tokens/sec	✅ Maintained
Simple Query Latency	<280ns (p50)	✅ Maintained
Complex Query Latency	<1μs	✅ Maintained
Memory Efficiency	60-80% reduction	✅ Maintained

Zero performance regression across all test scenarios.

---

📚 Documentation

New Documentation (v1.5.0)

• RELEASE_NOTES_v1.5.0.md - Complete release documentation (400+ lines)
• UPGRADE_GUIDE.md - Comprehensive upgrade instructions (300+ lines)

Updated Documentation

• CHANGELOG.md - v1.5.0 release notes added
• README.md - Updated with v1.5.0 highlights
• TASKS.md - Phase 1 tasks marked complete

Phase 1 Summary Documents (from v1.4.0)

• CLI_REFACTORING_SUMMARY.md - CLI coverage details
• PARSER_COVERAGE_SUMMARY.md - Parser test details
• TOKENIZER_COVERAGE_SUMMARY.md - Tokenizer test details
• SESSION_PROGRESS_SUMMARY.md - Overall progress tracking

---

🔗 Related Pull Requests

• PR #85: Phase 1 Test Coverage Implementation

  • 81 files changed, 25,883 insertions, 1,735 deletions
  • 20 commits (12 feature + 8 CI/CD fixes)
  • All 16 CI checks passing

• PR #86: v1.5.0 Release Documentation

  • 5 files changed, 886 lines added/modified
  • Comprehensive release notes and upgrade guide

---

🎯 What's Next

Recommended Priorities (from TASKS.md)

1. TEST-003: Increase Keywords Coverage to 75% (current: 50.6%)
2. QW-002: Enhanced Error Messages with context and suggestions
3. TEST-004: Add Fuzz Testing for security and robustness
4. FEAT-002: Streaming Parser API for large files (>10MB)
5. INT-001: IDE Integration (VS Code, GoLand)

Upcoming Releases

• v1.6.0: Keywords package coverage + Enhanced error messages
• v1.7.0: Fuzz testing + Security hardening
• v2.0.0: Dialect specialization + Advanced features

---

🤝 Contributors

Special thanks to all contributors who made this release possible!

Core Team

• @ajitpratap0 - Lead Developer

Community

• All users who reported issues and provided feedback
• Contributors who submitted bug reports and feature requests

---

📄 License

MIT License - see LICENSE file for details

---

🔗 Resources

• Repository: https://github.com/ajitpratap0/GoSQLX
• Documentation: https://pkg.go.dev/github.com/ajitpratap0/GoSQLX
• Issues: https://github.com/ajitpratap0/GoSQLX/issues
• Discussions: https://github.com/ajitpratap0/GoSQLX/discussions
• Full Release Notes: RELEASE_NOTES_v1.5.0.md

---

🎉 Thank you for using GoSQLX! 🎉

---

🤖 Generated with Claude Code

Co-Authored-By: Claude [email protected]

v1.4.0

GoSQLX v1.4.0

High-performance SQL parsing SDK for Go with zero-copy tokenization and object pooling.

Changelog

Other

• 2a1d7e1 Feature/enhanced cli (#14)
• aa4737c Merge branch 'main' of https://github.com/ajitpratap0/GoSQLX
• b42d0fe Merge branch 'main' of https://github.com/ajitpratap0/GoSQLX
• 52fdd11 Technical Roadmap 2025: CLI-First Platform Evolution (#13)

Documentation

• Getting Started
• API Reference
• Examples

Full Changelog: v1.3.0...v1.4.0

v1.3.0

v1.3.0: Window Functions (Phase 2.5)

Complete SQL-99 window function implementation achieving ~80-85% SQL-99 compliance

🚀 Major Features Implemented

Window Function Support

• Complete OVER clause - Full SQL-99 compliant window function parsing
• PARTITION BY and ORDER BY - Complete window specification support with expression parsing
• Window Frame Clauses - ROWS and RANGE frame specifications with proper bounds (UNBOUNDED PRECEDING/FOLLOWING, CURRENT ROW)

Function Categories

• Ranking Functions: ROW_NUMBER(), RANK(), DENSE_RANK(), NTILE() with full integration
• Analytic Functions: LAG(), LEAD(), FIRST_VALUE(), LAST_VALUE() with offset and default value support
• Enhanced Function Calls: Complete parsing with parentheses, arguments, and DISTINCT support

⚡ Performance & Quality

• 1.38M+ operations/second sustained throughput maintained (up to 1.5M peak with concurrency)
• Zero performance regression - all existing functionality performs at same speed
• Race-free implementation - comprehensive concurrent testing validates thread safety
• Memory efficient - object pooling preserved with 60-80% memory reduction
• Production-grade reliability - extensive load testing and memory leak detection

🎯 SQL Standards Compliance

• ~80-85% SQL-99 compliance achieved (significant advancement from ~70% SQL-92 in v1.2.0)
• Complete window function standard implemented per SQL-99 specification
• Advanced analytical capabilities - full support for ranking and analytic window functions
• Complex query compositions - window functions integrated with CTEs and set operations from previous phases

🔧 Technical Implementation

• parseFunctionCall() - Complete function call parsing with OVER clause detection and window specification handling
• parseWindowSpec() - Window specification parsing with PARTITION BY, ORDER BY, and frame clause support
• parseWindowFrame() - Frame clause parsing with ROWS/RANGE and bound specifications (UNBOUNDED, CURRENT ROW)
• parseFrameBound() - Individual frame bound parsing with expression support for offset values
• Enhanced parseExpression() - Function call detection and routing to window function parsing
• Updated parseSelectStatement() - Integrated enhanced expression parsing for SELECT column lists

📊 Comprehensive Testing

• 6 comprehensive test functions with 14 total test cases covering all window function scenarios
• Basic window functions: ROW_NUMBER() OVER (ORDER BY column)
• Partitioned window functions: RANK() OVER (PARTITION BY dept ORDER BY salary DESC)
• Frame specifications: SUM(column) OVER (ORDER BY date ROWS BETWEEN 2 PRECEDING AND CURRENT ROW)
• Complex compositions: Multiple window functions in single queries with various specifications
• 100% test pass rate with race detection enabled
• Extensive error case coverage with contextual error messages

🔄 Backward Compatibility

• 100% backward compatible - all existing functionality preserved without changes
• API stability - no breaking changes to public interfaces or method signatures
• Legacy test compatibility - all Phase 1, Phase 2, and prior tests continue passing
• Performance maintained - no degradation in existing query parsing performance

Goals Achieved

• ✅ ~80-85% SQL-99 compliance milestone reached
• ✅ Production-grade window function implementation with complete SQL-99 feature set
• ✅ Enhanced parser architecture supporting complex function calls and specifications
• ✅ Comprehensive test coverage for all window function categories
• ✅ Zero performance regression while adding significant new functionality
• ✅ Complete integration with existing CTE and set operations from previous phases

Example Usage

-- Basic ranking
SELECT name, salary, ROW_NUMBER() OVER (ORDER BY salary DESC) as rank
FROM employees;

-- Partitioned analytics
SELECT dept, name, salary,
       RANK() OVER (PARTITION BY dept ORDER BY salary DESC) as dept_rank,
       LAG(salary, 1) OVER (PARTITION BY dept ORDER BY salary) as prev_salary
FROM employees;

-- Frame specifications  
SELECT date, amount,
       SUM(amount) OVER (ORDER BY date ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) as rolling_sum
FROM transactions;

---

What's Next: Phase 3 (Dialect Specialization) - Multi-dialect parser with PostgreSQL, MySQL, SQL Server, Oracle, and SQLite specific features.

v1.2.0

🚀 GoSQLX v1.2.0 - Phase 2: Advanced SQL Features

📋 Major Release Overview

This release delivers Phase 2 of the GoSQLX roadmap, implementing comprehensive Common Table Expressions (CTE) and Set Operations support. GoSQLX now provides enterprise-grade SQL parsing with ~70% SQL-92 compliance while maintaining the high-performance, race-free architecture.

✨ Key Features Implemented

🔄 Common Table Expressions (CTEs)

• ✅ Simple CTEs: WITH table_name AS (SELECT ...)
• ✅ Recursive CTEs: WITH RECURSIVE table_name AS (...)
• ✅ Multiple CTEs: Support for comma-separated CTE definitions
• ✅ Column Specifications: WITH cte(col1, col2) AS (...)
• ✅ CTE Integration: Full compatibility with all statement types

🔗 Set Operations

• ✅ UNION: Standard set union with automatic deduplication
• ✅ UNION ALL: Set union preserving duplicates
• ✅ EXCEPT: Set difference (SQL standard, equivalent to MINUS)
• ✅ INTERSECT: Set intersection
• ✅ Left-Associative Parsing: A UNION B INTERSECT C = (A UNION B) INTERSECT C
• ✅ Combined Operations: CTEs with set operations in the same query

📊 Performance Metrics

Metric	Value	Status
Sustained Throughput	946K+ ops/sec (30s)	✅ No Regression
Peak Throughput	1.25M+ ops/sec (concurrent)	✅ Enhanced
Token Processing	8M+ tokens/sec	✅ Maintained
Simple Query Latency	<280ns	✅ Optimized
Complex Query Latency	<1μs (CTE/Set Ops)	✅ New Capability
Memory Efficiency	60-80% reduction	✅ Preserved
Race Conditions	0 detected	✅ Thread-Safe

🏗️ Technical Implementation

New Parser Functions

• parseWithStatement() - Complete WITH clause parsing with recursive support
• parseSelectWithSetOperations() - Set operations parsing with proper precedence
• parseCommonTableExpr() - Individual CTE parsing with column specifications
• parseMainStatementAfterWith() - Post-CTE statement routing

Enhanced Test Coverage

• pkg/sql/parser/cte_test.go - 4 comprehensive CTE test functions
• pkg/sql/parser/set_operations_test.go - 5 comprehensive set operation tests
• Coverage: Simple CTE, Recursive CTE, Multiple CTEs, Set Operations, Complex Combinations

🎯 SQL Standards Compliance

✅ SQL-92 Features Implemented

• Common Table Expressions (WITH clause)
• Recursive queries (WITH RECURSIVE)
• Set operations (UNION, EXCEPT, INTERSECT)
• Complex query compositions
• Proper operator precedence

📈 Compliance Progress

• Phase 1: ~40% SQL-92 compliance (Basic SELECT, JOINs)
• Phase 2: ~70% SQL-92 compliance (CTEs, Set Operations) ⬅️ Current
• Phase 3 Target: 90%+ compliance (Window Functions, Advanced Features)

🔧 Production Deployment

✅ Ready for Production

• Enterprise Workloads: Handles complex SQL parsing at scale
• High-Throughput Systems: 946K+ operations/second sustained
• Mission-Critical Applications: Race-free, memory-safe operation
• International Usage: Full Unicode SQL support maintained

🚀 Deployment Requirements

• Go Version: Go 1.19+ (tested with Go 1.21+)
• Memory: Object pools auto-scale, minimal configuration needed
• Concurrency: Scales linearly, no artificial limits
• Monitoring: Built-in metrics and memory leak detection

📋 Example Usage

Simple CTE

WITH sales_summary AS (
    SELECT region, SUM(amount) as total 
    FROM sales GROUP BY region
) 
SELECT region FROM sales_summary WHERE total > 1000

Recursive CTE

WITH RECURSIVE employee_tree AS (
    SELECT employee_id, manager_id, name FROM employees WHERE manager_id IS NULL
    UNION ALL
    SELECT e.employee_id, e.manager_id, e.name 
    FROM employees e JOIN employee_tree et ON e.manager_id = et.employee_id
) 
SELECT * FROM employee_tree

Set Operations

SELECT name FROM users UNION SELECT name FROM customers;
SELECT id FROM orders UNION ALL SELECT id FROM invoices;
SELECT product FROM inventory EXCEPT SELECT product FROM discontinued;
SELECT customer_id FROM orders INTERSECT SELECT customer_id FROM payments;

Combined CTE + Set Operations

WITH regional AS (SELECT region FROM sales) 
SELECT region FROM regional UNION SELECT region FROM returns;

🔄 Backward Compatibility

• ✅ 100% Backward Compatible: All existing functionality preserved
• ✅ API Stability: No breaking changes to public interfaces
• ✅ Legacy Tests: All Phase 1 and prior tests continue passing
• ✅ Performance: No degradation in existing query parsing

🔜 Next Steps (Phase 3 - Q1 2025)

Phase 2 lays the groundwork for Phase 3 advanced features:

• Window Functions: OVER clauses, ranking functions
• Advanced JOINs: LATERAL joins, multiple-column USING clauses
• Subquery Enhancements: Correlated subqueries, EXISTS clauses
• Data Modification: Enhanced INSERT/UPDATE/DELETE with CTEs
• SQL-99 Compliance: Advanced analytical functions

---

📝 Full Changelog

Added

• Complete Common Table Expression (CTE) parsing with recursive support
• Set operations: UNION, UNION ALL, EXCEPT, INTERSECT with proper precedence
• Multiple CTE definitions in single query
• CTE column specifications
• Integration of CTEs with set operations
• Comprehensive test coverage for all new features
• Enhanced Go package documentation with Phase 2 examples

Changed

• Enhanced parser statement routing to support set operations
• Improved WITH clause attachment for complex statement types
• Updated performance metrics and benchmarks

Performance

• Maintains 946K+ sustained operations per second
• Zero performance regression from Phase 1
• Memory-efficient object pooling preserved
• Race-free concurrent access validated

---

🎉 GoSQLX v1.2.0 delivers enterprise-grade SQL parsing with advanced CTE and set operations support!

v1.1.0

🚀 GoSQLX v1.1.0: Phase 1 Core SQL Enhancements

This major release delivers enterprise-grade JOIN support and establishes the foundation for Phase 2 CTE implementation.

✅ Major Features Implemented

Complete JOIN Support

• All JOIN types: INNER, LEFT, RIGHT, FULL OUTER, CROSS, NATURAL
• Proper join tree logic: Left-associative relationships with synthetic table references
• USING clause: Single-column parsing (multi-column planned for Phase 2)
• Enhanced error handling: Contextual error messages with JOIN type information

Production-Ready Quality

• Zero race conditions: Validated through comprehensive concurrent testing
• High performance: 2.2M operations/second maintained
• Comprehensive tests: 15+ JOIN scenarios including error cases
• 100% test coverage: All JOIN functionality thoroughly tested

🏗️ Phase 2 Foundation Laid

CTE Infrastructure Ready

• AST structures: WithClause and CommonTableExpr fully defined
• Token support: WITH, RECURSIVE, UNION, EXCEPT, INTERSECT keywords added
• Parser integration points: Documented TODO markers for Phase 2 completion

📊 Performance Metrics

• Operations/sec: 2.2M (JOIN queries)
• Memory efficiency: 60-80% reduction with object pooling
• Concurrency: Race-free under 20,000+ concurrent operations
• SQL compatibility: Multi-dialect support (PostgreSQL, MySQL, SQL Server, Oracle, SQLite)

🔧 Technical Highlights

JOIN Tree Logic

-- Properly handles: FROM A JOIN B JOIN C as ((A JOIN B) JOIN C)
SELECT * FROM users u 
LEFT JOIN orders o ON u.id = o.user_id 
INNER JOIN products p ON o.product_id = p.id

Error Context

• "expected JOIN after LEFT, got IDENT"
• "expected table name after LEFT JOIN, got ON"
• "error parsing ON condition for INNER JOIN: unexpected token"

📖 What's Next (Phase 2)

• Common Table Expressions (CTEs) with RECURSIVE support
• Set operations: UNION, EXCEPT, INTERSECT with ALL modifier
• Multi-column USING clause support
• Advanced subquery contexts

🔗 Links

• Pull Request: #8 Phase 1 Core SQL Enhancements
• Documentation: Updated README and CHANGELOG
• Performance: All benchmarks passing with race detection

---

Full Changelog: v1.0.2...v1.1.0

v1.0.2

GoSQLX v1.0.2

High-performance SQL parsing SDK for Go with zero-copy tokenization and object pooling.

Changelog

Documentation

• Getting Started
• API Reference
• Examples

Full Changelog: v1.0.1...v1.0.2

v1.0.1

GoSQLX v1.0.1

High-performance SQL parsing SDK for Go with zero-copy tokenization and object pooling.

Changelog

New Features

• 9554b50 feat(monitor): Add performance monitoring package for v1.0.1
• 312642d feat: Complete open-source community standards implementation for v1.0.0

Bug Fixes

• a464045 fix: Add missing EOF tokens to all benchmark test cases
• 8a66cce fix: Apply gofmt formatting to monitor package
• a7d9efc fix: Comprehensive GitHub Actions workflow fixes
• f0efa77 fix: Critical issues in PR #7 and remove misleading badges
• 64ed5c8 fix: Critical parser and test issues for CI/CD success
• 650c3ae fix: Final ineffectual assignment in tokenizer exponent parsing
• 326f519 fix: Format code with gofmt
• 716e8da fix: GitHub Actions workflow issues and dependency updates
• f60f5b8 fix: Go 1.18 compatibility and workflow version alignment
• d7d7d2a fix: Remove unused code detected by staticcheck
• 4a5ee59 fix: Resolve all golangci-lint issues
• a3aea4d fix: Resolve monitor package mutex copy issues
• 3527678 fix: Resolve race conditions in monitor package
• bb4ec40 fix: Resolve test workflow failures
• dfd967b fix: Update GitHub Actions to non-deprecated versions

Other

• faa71a1 "Claude Code Review workflow"
• 03319e4 "Claude PR Assistant workflow"
• 76e984e Add tokenizer and keywords packages with Unicode support
• e9998fb Add tokenizer and keywords packages with Unicode support
• 04223e2 Fix GitHub Actions failures and compilation errors
• bd3c9e2 Format code for consistency by aligning struct fields and return statements
• 8b57b0a Initial commit
• 14a7b6e Merge branch 'main' into feature/v1.0.1-performance-improvements
• 8bd3ec6 Merge pull request #5 from SunnysideAaron/module
• bf3437d Merge pull request #6 from ajitpratap0/add-claude-github-actions-1755934584040
• 552cb4d Merge pull request #7 from ajitpratap0/feature/v1.0.1-performance-improvements
• 082cf36 Merge remote-tracking branch 'origin/main'
• 1e0c2ce Rename module to match repository path
• 287f0ba Update README.md to enhance performance benchmarks and improve parser initialization
• 1a04de3 Update README.md to include example usage of GoSQLX and enhance resource management
• b2f51bf Update documentation and add LICENSE
• 8e8e596 added write up to readme. updated go.mod to point to actual repo
• 33a85ee more module path updates
• 73af757 🚀 Release v1.0.0: Production-ready SQL parsing SDK with enterprise validation

Documentation

• Getting Started
• API Reference
• Examples

Full Changelog: ...v1.0.1

GoSQLX v1.0.0 - Production Ready 🎉

GoSQLX v1.0.0 - Production Ready Release 🚀

We're excited to announce the first stable production release of GoSQLX!

🎯 Release Highlights

Performance

• 2.2M ops/sec sustained throughput
• 8M tokens/sec processing speed
• 47% faster than v0.9.0
• < 200ns latency for simple queries
• 60-80% memory reduction with intelligent pooling

Production Ready

• ✅ Zero race conditions detected in extensive testing
• ✅ 20,000+ concurrent operations validated
• ✅ 115+ real-world SQL queries tested
• ✅ Linear scaling to 128+ cores
• ✅ Thread-safe implementation

✨ Key Features

Core Capabilities

• 🚀 Zero-copy tokenization for maximum performance
• 💾 Object pooling for memory efficiency
• 🌍 Full Unicode/UTF-8 support for international SQL
• 🔧 Multi-dialect support: PostgreSQL, MySQL, SQL Server, Oracle, SQLite
• 📊 AST generation from SQL tokens
• 🎯 Position tracking with line/column information

New in v1.0.0

• MySQL backtick identifier support
• Enhanced error reporting
• Comprehensive test suite
• Production validation suite
• Performance benchmarking tools
• Real-world SQL compatibility testing

📦 Installation

go get github.com/ajitpratap0/[email protected]

🚀 Quick Start

package main

import (
    "fmt"
    "log"
    
    "github.com/ajitpratap0/GoSQLX/pkg/sql/tokenizer"
    "github.com/ajitpratap0/GoSQLX/pkg/sql/parser"
)

func main() {
    // Get tokenizer from pool
    tkz := tokenizer.GetTokenizer()
    defer tokenizer.PutTokenizer(tkz)
    
    // Tokenize SQL
    sql := "SELECT id, name FROM users WHERE age > 18"
    tokens, err := tkz.Tokenize([]byte(sql))
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("Generated %d tokens\n", len(tokens))
}

📊 Performance Benchmarks

BenchmarkTokenizer/SimpleSQL-16         965,466    1,238 ns/op    1,585 B/op    20 allocs/op
BenchmarkParser/SimpleSelect-16       6,330,259      185 ns/op      536 B/op     9 allocs/op
BenchmarkThroughput-16                3,144,678      381 ns/op    2.2M ops/sec
BenchmarkTokensPerSecond-16             733,141    1,619 ns/op    8.0M tokens/sec

🧪 Quality Metrics

Metric	Value
Race Conditions	0 detected
Test Coverage	95%+
Real-world SQL	115+ queries
International Support	8 languages
Memory Efficiency	60-80% reduction

📚 Documentation

• Getting Started Guide
• API Reference
• Architecture Overview
• Production Guide
• Troubleshooting

🛠️ Example Tools

This release includes example command-line tools:

• sql-validator: Validate SQL syntax across dialects
• sql-formatter: Format SQL queries

🙏 Acknowledgments

Thanks to all contributors and the Go community for making this release possible!

📝 Changelog

See CHANGELOG.md for detailed changes.

🔮 What's Next

• v1.0.1: Performance monitoring package (PR #7)
• v1.1.0: Streaming parser for large files
• v1.2.0: Query optimization hints

---

Full Changelog: v0.9.0...v1.0.0

What's Changed

• Updating module to work with actual path by @SunnysideAaron in #5

New Contributors

• @SunnysideAaron made their first contribution in #5

Full Changelog: https://github.com/ajitpratap0/GoSQLX/commits/v1.0.0