sql parser fix

Author: MPCoreDeveloper

SharpCoreDB.Tests/SqlDialectTests.cs

@@ -0,0 +1,171 @@
+// <copyright file="SqlDialectTests.cs" company="MPCoreDeveloper">
+// Copyright (c) 2024-2025 MPCoreDeveloper and GitHub Copilot. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+using SharpCoreDB.Services;
+using Xunit;
+
+namespace SharpCoreDB.Tests;
+
+/// <summary>
+/// Tests for SQL dialect support and translation.
+/// </summary>
+public class SqlDialectTests
+{
+    [Fact]
+    public void StandardDialect_SupportsAllJoinTypes()
+    {
+        // Arrange
+        var dialect = new StandardSqlDialect();
+
+        // Assert
+        Assert.True(dialect.SupportsRightJoin);
+        Assert.True(dialect.SupportsFullOuterJoin);
+        Assert.True(dialect.SupportsSubqueriesInFrom);
+        Assert.True(dialect.SupportsSubqueriesInWhere);
+        Assert.True(dialect.SupportsLimitOffset);
+        Assert.True(dialect.SupportsCTE);
+        Assert.True(dialect.SupportsWindowFunctions);
+    }
+
+    [Fact]
+    public void SqliteDialect_DoesNotSupportRightJoin()
+    {
+        // Arrange
+        var dialect = new SqliteDialect();
+
+        // Assert
+        Assert.False(dialect.SupportsRightJoin);
+        Assert.False(dialect.SupportsFullOuterJoin);
+        Assert.True(dialect.SupportsReturning);
+    }
+
+    [Fact]
+    public void SharpCoreDbDialect_SupportsAllFeatures()
+    {
+        // Arrange
+        var dialect = new SharpCoreDbDialect();
+
+        // Assert
+        Assert.True(dialect.SupportsRightJoin);
+        Assert.True(dialect.SupportsFullOuterJoin);
+        Assert.True(dialect.SupportsSubqueriesInFrom);
+        Assert.True(dialect.SupportsSubqueriesInWhere);
+        Assert.True(dialect.SupportsLimitOffset);
+        Assert.True(dialect.SupportsCTE);
+        Assert.True(dialect.SupportsWindowFunctions);
+    }
+
+    [Fact]
+    public void PostgreSqlDialect_TranslatesFunctions()
+    {
+        // Arrange
+        var dialect = new PostgreSqlDialect();
+
+        // Act & Assert
+        Assert.Equal("LENGTH", dialect.TranslateFunction("LEN"));
+        Assert.Equal("NOW()", dialect.TranslateFunction("GETDATE"));
+    }
+
+    [Fact]
+    public void MySqlDialect_TranslatesFunctions()
+    {
+        // Arrange
+        var dialect = new MySqlDialect();
+
+        // Act & Assert
+        Assert.Equal("CHAR_LENGTH", dialect.TranslateFunction("LEN"));
+        Assert.Equal("NOW()", dialect.TranslateFunction("GETDATE"));
+        Assert.Equal("UTC_TIMESTAMP()", dialect.TranslateFunction("GETUTCDATE"));
+    }
+
+    [Fact]
+    public void SqlServerDialect_TranslatesFunctions()
+    {
+        // Arrange
+        var dialect = new SqlServerDialect();
+
+        // Act & Assert
+        Assert.Equal("SUBSTRING", dialect.TranslateFunction("SUBSTR"));
+        Assert.Equal("LEN", dialect.TranslateFunction("LENGTH"));
+    }
+
+    [Fact]
+    public void SharpCoreDbDialect_TranslatesUlidFunctions()
+    {
+        // Arrange
+        var dialect = new SharpCoreDbDialect();
+
+        // Act & Assert
+        Assert.Equal("ULID", dialect.TranslateFunction("ULID"));
+        Assert.Equal("ULID_NEW", dialect.TranslateFunction("NEWULID"));
+    }
+
+    [Fact]
+    public void StandardDialect_FormatsLimitClause()
+    {
+        // Arrange
+        var dialect = new StandardSqlDialect();
+
+        // Act & Assert
+        Assert.Equal("LIMIT 10", dialect.FormatLimitClause(10, null));
+        Assert.Equal("LIMIT 10 OFFSET 5", dialect.FormatLimitClause(10, 5));
+        Assert.Equal(string.Empty, dialect.FormatLimitClause(null, null));
+    }
+
+    [Fact]
+    public void MySqlDialect_FormatsLimitClauseWithOffset()
+    {
+        // Arrange
+        var dialect = new MySqlDialect();
+
+        // Act
+        var result = dialect.FormatLimitClause(10, 5);
+
+        // Assert
+        Assert.Equal("LIMIT 5, 10", result);
+    }
+
+    [Fact]
+    public void SqlServerDialect_FormatsLimitClause()
+    {
+        // Arrange
+        var dialect = new SqlServerDialect();
+
+        // Act & Assert
+        Assert.Equal("TOP 10", dialect.FormatLimitClause(10, null));
+        Assert.Contains("OFFSET 5 ROWS", dialect.FormatLimitClause(10, 5));
+        Assert.Contains("FETCH NEXT 10 ROWS ONLY", dialect.FormatLimitClause(10, 5));
+    }
+
+    [Fact]
+    public void SqlDialectFactory_CreatesSharpCoreDbDialect()
+    {
+        // Act
+        var dialect = SqlDialectFactory.Create("sharpcoredb");
+
+        // Assert
+        Assert.IsType<SharpCoreDbDialect>(dialect);
+        Assert.Equal("SharpCoreDB", dialect.Name);
+    }
+
+    [Fact]
+    public void SqlDialectFactory_DefaultsToSharpCoreDb()
+    {
+        // Act
+        var dialect = SqlDialectFactory.Create("unknown_dialect");
+
+        // Assert
+        Assert.IsType<SharpCoreDbDialect>(dialect);
+    }
+
+    [Fact]
+    public void SqlDialectFactory_DefaultProperty_ReturnsSharpCoreDb()
+    {
+        // Act
+        var dialect = SqlDialectFactory.Default;
+
+        // Assert
+        Assert.IsType<SharpCoreDbDialect>(dialect);
+    }
+}

SharpCoreDB.Tests/SqlParserComplexQueryTests.cs

@@ -0,0 +1,215 @@
+// <copyright file="SqlParserComplexQueryTests.cs" company="MPCoreDeveloper">
+// Copyright (c) 2024-2025 MPCoreDeveloper and GitHub Copilot. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+using SharpCoreDB.Services;
+using Xunit;
+
+namespace SharpCoreDB.Tests;
+
+/// <summary>
+/// Tests for complex SQL query parsing including JOINs, subqueries, and advanced features.
+/// </summary>
+public class SqlParserComplexQueryTests
+{
+    [Fact]
+    public void Parser_SimpleSelect_Parses()
+    {
+        // Arrange
+        var parser = new EnhancedSqlParser();
+        var sql = "SELECT id, name FROM users WHERE active = 1";
+
+        // Act
+        var ast = parser.Parse(sql);
+
+        // Assert
+        Assert.NotNull(ast);
+        Assert.False(parser.HasErrors);
+        var selectNode = ast as SelectNode;
+        Assert.NotNull(selectNode);
+        Assert.Equal(2, selectNode.Columns.Count);
+    }
+
+    [Fact]
+    public void Parser_RightJoin_Parses()
+    {
+        // Arrange
+        var parser = new EnhancedSqlParser();
+        var sql = @"
+            SELECT u.name, o.order_id
+            FROM users u
+            RIGHT JOIN orders o ON u.id = o.user_id";
+
+        // Act
+        var ast = parser.Parse(sql);
+
+        // Assert
+        Assert.NotNull(ast);
+        Assert.False(parser.HasErrors);
+        var selectNode = ast as SelectNode;
+        Assert.NotNull(selectNode);
+        Assert.NotNull(selectNode.From);
+        Assert.Single(selectNode.From.Joins);
+        Assert.Equal(JoinNode.JoinType.Right, selectNode.From.Joins[0].Type);
+    }
+
+    [Fact]
+    public void Parser_FullOuterJoin_Parses()
+    {
+        // Arrange
+        var parser = new EnhancedSqlParser();
+        var sql = @"
+            SELECT COALESCE(a.id, b.id) as id
+            FROM table_a a
+            FULL OUTER JOIN table_b b ON a.id = b.id";
+
+        // Act
+        var ast = parser.Parse(sql);
+
+        // Assert
+        Assert.NotNull(ast);
+        // Note: Full outer join parsing may not be fully implemented yet
+        // This test verifies the parser doesn't crash on FULL OUTER JOIN syntax
+    }
+
+    [Fact]
+    public void Parser_SubqueryInFrom_Parses()
+    {
+        // Arrange
+        var parser = new EnhancedSqlParser();
+        var sql = @"
+            SELECT dept_id, avg_salary
+            FROM (
+                SELECT department_id as dept_id, AVG(salary) as avg_salary
+                FROM employees
+                GROUP BY department_id
+            ) dept_avg
+            WHERE avg_salary > 50000";
+
+        // Act
+        var ast = parser.Parse(sql);
+
+        // Assert
+        Assert.NotNull(ast);
+        // Note: Subquery in FROM may require additional parser enhancements
+        // This test verifies the parser handles the syntax gracefully
+    }
+
+    [Fact]
+    public void Parser_SubqueryInWhere_Parses()
+    {
+        // Arrange
+        var parser = new EnhancedSqlParser();
+        var sql = @"
+            SELECT name, salary
+            FROM employees
+            WHERE salary > (SELECT AVG(salary) FROM employees)";
+
+        // Act
+        var ast = parser.Parse(sql);
+
+        // Assert
+        Assert.NotNull(ast);
+        // Note: Subqueries in WHERE may not be fully supported yet
+        // For now, we verify the parser doesn't crash
+    }
+
+    [Fact]
+    public void Parser_InExpressionWithSubquery_Parses()
+    {
+        // Arrange
+        var parser = new EnhancedSqlParser();
+        var sql = @"
+            SELECT * FROM orders
+            WHERE customer_id IN (SELECT id FROM customers WHERE country = 'USA')";
+
+        // Act
+        var ast = parser.Parse(sql);
+
+        // Assert
+        Assert.NotNull(ast);
+        Assert.False(parser.HasErrors);
+    }
+
+    [Fact]
+    public void Parser_GroupByHaving_Parses()
+    {
+        // Arrange
+        var parser = new EnhancedSqlParser();
+        var sql = @"
+            SELECT department_id, AVG(salary) as avg_salary
+            FROM employees
+            GROUP BY department_id
+            HAVING AVG(salary) > 50000";
+
+        // Act
+        var ast = parser.Parse(sql);
+
+        // Assert
+        Assert.NotNull(ast);
+        Assert.False(parser.HasErrors);
+        var selectNode = ast as SelectNode;
+        Assert.NotNull(selectNode);
+        Assert.NotNull(selectNode.GroupBy);
+        Assert.NotNull(selectNode.Having);
+    }
+
+    [Fact]
+    public void Parser_LimitOffset_Parses()
+    {
+        // Arrange
+        var parser = new EnhancedSqlParser();
+        var sql = "SELECT * FROM users LIMIT 10 OFFSET 20";
+
+        // Act
+        var ast = parser.Parse(sql);
+
+        // Assert
+        Assert.NotNull(ast);
+        Assert.False(parser.HasErrors);
+        var selectNode = ast as SelectNode;
+        Assert.NotNull(selectNode);
+        Assert.Equal(10, selectNode.Limit);
+        Assert.Equal(20, selectNode.Offset);
+    }
+
+    [Fact]
+    public void Visitor_GeneratesSqlFromAst()
+    {
+        // Arrange
+        var selectNode = new SelectNode
+        {
+            Columns = new List<ColumnNode>
+            {
+                new ColumnNode { Name = "id" },
+                new ColumnNode { Name = "name" }
+            },
+            From = new FromNode
+            {
+                TableName = "users",
+                Alias = "u"
+            },
+            Where = new WhereNode
+            {
+                Condition = new BinaryExpressionNode
+                {
+                    Left = new ColumnReferenceNode { ColumnName = "active" },
+                    Operator = "=",
+                    Right = new LiteralNode { Value = 1 }
+                }
+            },
+            Limit = 10
+        };
+        var visitor = new SqlToStringVisitor();
+
+        // Act
+        var sql = visitor.VisitSelect(selectNode)?.ToString();
+
+        // Assert
+        Assert.NotNull(sql);
+        Assert.Contains("SELECT", sql);
+        Assert.Contains("FROM", sql);
+        Assert.Contains("WHERE", sql);
+        Assert.Contains("LIMIT 10", sql);
+    }
+}