Fix punctuation parsing

Now parser can correctly handle:

```sql
CREATE TABLE users
(
    id         INT AUTO_INCREMENT,
    name       VARCHAR(122) NOT NULL UNIQUE,
    profile_id INT,
    PRIMARY KEY (id),
    FOREIGN KEY (id)
);
```

FK definition is still incomplete,
cause reference statement is not defined.

DbSeeder/Program.cs

@@ -11,15 +11,18 @@ private static void Main()
     {
         const string sqlScript =
             """
-            CREATE TABLE Users (
-                Id INT PRIMARY KEY,
-                Name VARCHAR(122) NOT NULL UNIQUE,
-                ProfileId UUID FOREIGN KEY
+            CREATE TABLE users
+            (
+                id         INT AUTO_INCREMENT,
+                name       VARCHAR(122) NOT NULL UNIQUE,
+                profile_id INT,
+                PRIMARY KEY (id)
             );
 
-            CREATE TABLE Profiles (
-                Id UUID PRIMARY KEY,
-                Nickname VARCHAR(122) NOT NULL UNIQUE,
+            CREATE TABLE profiles
+            (
+                id         INT AUTO_INCREMENT PRIMARY KEY,
+                nickname   VARCHAR(122) NOT NULL UNIQUE
             );
             """;
         var lexer = new SqlLexer(sqlScript);

DbSeeder/SqlParser/ParserConstants.cs

@@ -19,7 +19,7 @@ public static class ParserConstants
 
     public static readonly HashSet<string> Constraints =
     [
-        "PRIMARY KEY", "FOREIGN KEY", "NOT NULL", "UNIQUE"
+        "PRIMARY KEY", "FOREIGN KEY", "NOT NULL", "UNIQUE", "AUTO_INCREMENT"
     ];
 
     public static readonly SearchValues<char> Punctuation = SearchValues.Create("(),.;");

DbSeeder/SqlParser/SyntaxTree/AstBuilder.cs

@@ -84,7 +84,14 @@ private void HandleIdentifier(SqlToken token, ref SyntaxTreeNode localRoot)
                 AddNode(SyntaxTreeNodeType.TableRoot, token.Value, ref localRoot!);
                 break;
             case SyntaxTreeNodeType.TableColumns:
-                AddNode(SyntaxTreeNodeType.Column, token.Value, ref localRoot!);
+                if (!IsConstraint(token))
+                {
+                    AddNode(SyntaxTreeNodeType.Column, token.Value, ref localRoot!);
+                }
+                else
+                {
+                    BuildConstraint(token, ref localRoot);
+                }
                 break;
             case SyntaxTreeNodeType.Column:
                 AddNode(SyntaxTreeNodeType.ColumnDataType, token.Value, ref localRoot!);
@@ -100,6 +107,25 @@ private void HandleIdentifier(SqlToken token, ref SyntaxTreeNode localRoot)
         }
     }
 
+    private bool IsConstraint(SqlToken token)
+    {
+        var isConstraintKeyWord = token.Value.Equals("constraint", StringComparison.OrdinalIgnoreCase);
+        var isIdentifier = ParserConstants.Constraints
+            .Any(c => c.Contains(token.Value, StringComparison.OrdinalIgnoreCase));
+
+        return isConstraintKeyWord || isIdentifier;
+    }
+
+    private void BuildConstraint(SqlToken token, ref SyntaxTreeNode localRoot)
+    {
+        Console.WriteLine($"Detected Constraint: {token.Value}");
+
+        AddNode(SyntaxTreeNodeType.ColumnConstraint, token.Value, ref localRoot!);
+
+
+
+    }
+
     private void HandleColumnConstraintIdentifier(SqlToken token, ref SyntaxTreeNode localRoot)
     {
         // Handle composite constraints (e.g., NOT NULL)
@@ -108,6 +134,18 @@ private void HandleColumnConstraintIdentifier(SqlToken token, ref SyntaxTreeNode
             var updatedConstraintValue = localRoot.Value + " " + token.Value;
             UpdateColumnConstraintNode(updatedConstraintValue, ref localRoot);
         }
+        else if (localRoot.Parent?.Type is SyntaxTreeNodeType.TableColumns)
+        {
+            // PRIMARY KEY (id). If we're here, we are looking at the col name.
+            var colsContainerNode = localRoot.Parent;
+
+            colsContainerNode.Children.Remove(localRoot);
+            var constraintOwner = colsContainerNode.Children.First(x => x!.Value.Equals(token.Value))!;
+
+            var temp = new SyntaxTreeNode(localRoot.Type, localRoot.Value, constraintOwner);
+            localRoot = temp;
+            constraintOwner.Children.Add(temp);
+        }
         else
         {
             AddColumnConstraintNode(token, ref localRoot);
@@ -156,6 +194,7 @@ private void HandlePunctuation(SqlToken token, SyntaxTreeNode root, ref SyntaxTr
                     break;
                 case SyntaxTreeNodeType.ColumnConstraint:
                 case SyntaxTreeNodeType.ColumnDataType:
+                case SyntaxTreeNodeType.TableColumns:
                     HandleColumnConstraintOrDataTypePunctuation(token, ref localRoot);
                     break;
                 case SyntaxTreeNodeType.DataTypeConstraint:
@@ -165,7 +204,6 @@ private void HandlePunctuation(SqlToken token, SyntaxTreeNode root, ref SyntaxTr
                 case SyntaxTreeNodeType.Root:
                 case SyntaxTreeNodeType.CreateStatement:
                 case SyntaxTreeNodeType.CreateTable:
-                case SyntaxTreeNodeType.TableColumns:
                 case SyntaxTreeNodeType.Column:
                 default:
                     throw new NotImplementedException($"Punctuation is not expected after '{localRoot.Type}'");
@@ -190,10 +228,13 @@ private void HandleColumnConstraintOrDataTypePunctuation(SqlToken token, ref Syn
         }
         else
         {
-            // For other punctuation, validate and potentially move back to TableColumns
-            EnsureNodeType(
-                ref localRoot,
-                SyntaxTreeNodeType.TableColumns);
+            if (localRoot.Type != SyntaxTreeNodeType.TableColumns)
+            {
+                // For other punctuation, validate and potentially move back to TableColumns
+                EnsureNodeType(
+                    ref localRoot,
+                    SyntaxTreeNodeType.TableColumns);
+            }
         }
     }