feat: Add multi-column USING clause support in JOINs (closes #70)

[ajitpratap0]

Summary

Implements support for multi-column USING clauses in JOIN statements for SQL-92 compliance.

Changes

Parser Modifications

• Modified parseJoinClause() in pkg/sql/parser/parser.go to parse comma-separated column lists
• Single columns stored as Identifier (backward compatible)
• Multiple columns stored as ListExpression
• Removed TODO comment about this limitation

Test Coverage

Added 16 comprehensive test cases in pkg/sql/parser/join_test.go:

• 6 basic functionality tests (single/multiple columns, different JOIN types)
• 6 edge case tests (empty USING, trailing commas, syntax errors)
• 4 complex query tests (multiple JOINs, mixed ON/USING, WHERE/ORDER BY)

Examples

Before (unsupported):

-- Would fail to parse
SELECT * FROM users JOIN orders USING (user_id, account_id)

After (supported):

-- Single column (backward compatible)
SELECT * FROM users JOIN orders USING (id)

-- Multiple columns (NEW)
SELECT * FROM users JOIN orders USING (user_id, account_id)
SELECT * FROM users LEFT JOIN orders USING (id, name, category)

Testing

✅ All 16 new tests pass
✅ All existing parser tests pass (backward compatibility)
✅ Race detection enabled: go test -race ./pkg/sql/parser/
✅ Pre-commit hooks passed

SQL-92 Compliance

This change brings GoSQLX into full compliance with SQL-92 standard for multi-column USING clauses.

Backward Compatibility

✅ Fully backward compatible - single-column USING clauses work exactly as before

Closes #70

🤖 Generated with Claude Code

Co-Authored-By: Claude noreply@anthropic.com

[claude]

Claude finished @ajitpratap0's task —— View job

---

PR Review: Multi-Column USING Clause Support

Completed comprehensive review of this PR implementing multi-column USING clause support for SQL-92 compliance.

✅ Overall Assessment: EXCELLENT IMPLEMENTATION

This is a well-crafted PR that demonstrates strong engineering practices and attention to detail.

🔍 Code Quality Analysis

Parser Implementation (pkg/sql/parser/parser.go:899-941)

• ✅ Clean Logic: The USING clause parsing logic is well-structured and readable
• ✅ Backward Compatible: Single columns stored as Identifier, multiple as ListExpression
• ✅ Error Handling: Comprehensive error messages with clear expectations
• ✅ Code Comments: Good inline documentation explaining the logic flow

Potential Minor Improvement:

// Consider extracting column parsing into a helper function for better readability:
func (p *Parser) parseUsingColumnList() ([]ast.Expression, error) {
    // Move lines 913-927 here for better separation of concerns
}

🧪 Test Coverage: Exemplary

The test suite is exceptionally comprehensive with 16 test cases covering:

Functional Tests (pkg/sql/parser/join_test.go:560-688)

• ✅ Single column backward compatibility
• ✅ Multi-column scenarios (2, 3, 4+ columns)
• ✅ All JOIN types (INNER, LEFT, RIGHT, FULL OUTER)
• ✅ Complex queries with WHERE/ORDER BY clauses

Edge Case Tests (pkg/sql/parser/join_test.go:689-778)

• ✅ Empty USING clause detection
• ✅ Trailing comma error handling
• ✅ Missing parentheses validation
• ✅ Proper error message verification

Integration Tests (pkg/sql/parser/join_test.go:779-864)

• ✅ Multiple JOINs with multi-column USING
• ✅ Mixed ON/USING clause scenarios
• ✅ Complex query combinations

🚀 CLI Enhancements

Security Improvements (cmd/gosqlx/cmd/stdin_utils.go)

• ✅ DoS Protection: 10MB limit on stdin input prevents resource exhaustion
• ✅ Input Validation: Proper empty content detection
• ✅ Error Handling: Clear error messages for various failure scenarios

User Experience (cmd/gosqlx/cmd/*.go)

• ✅ Stdin Detection: Smart pipe detection for better CLI ergonomics
• ✅ Integration Testing: Comprehensive pipeline tests ensure CLI reliability

🔒 Security Assessment

No Security Concerns Identified:

• ✅ Input validation is properly implemented
• ✅ No SQL injection vectors (parser-only changes)
• ✅ DoS protection in CLI stdin handling
• ✅ No credential or sensitive data exposure

⚡ Performance Considerations

Expected Impact: Minimal to None

• ✅ Uses existing ListExpression AST node (no new allocations)
• ✅ Backward compatibility preserves single-column optimization
• ✅ Parse-time complexity increase is negligible for typical use cases
• ✅ Follows repository's object pooling patterns

Recommendation: Consider adding benchmark tests for multi-column USING clauses in future iterations.

🐛 Potential Issues Analysis

No Critical Issues Found. Minor observations:

1. Edge Case: The parser doesn't validate that USING column names exist in both tables, but this is typically a semantic validation concern, not parser-level
2. AST Consistency: The mixed storage approach (Identifier vs ListExpression) is pragmatic but adds complexity for AST consumers

📊 SQL-92 Compliance

✅ Fully Compliant: This implementation correctly follows SQL-92 standard for multi-column USING clauses, bringing GoSQLX into full compliance.

🔄 Backward Compatibility

✅ Fully Maintained: Single-column USING clauses continue to work exactly as before with no breaking changes.

📋 Recommendations

Must Address Before Merge:

• None - this is ready for production

Optional Improvements for Future:

1. Add benchmark tests for performance validation
2. Consider extracting USING column parsing into helper function
3. Add documentation examples to README.md

Commendations:

• Exceptional test coverage demonstrates thorough engineering
• Clean, readable implementation with good error handling
• Proper security considerations in CLI enhancements
• Professional commit structure and PR documentation

✨ Final Verdict: APPROVED

This PR exemplifies high-quality software engineering with comprehensive testing, security awareness, and production-ready implementation. The multi-column USING clause support is a valuable addition that enhances SQL-92 compliance while maintaining full backward compatibility.

Recommended for immediate merge after standard CI validation.

---