feat: add INSERT statement parsing with host variable bindings

allieseb · claude · allieseb · commit e1d415625762 · 2026-04-08T12:18:01.000+02:00
Add structured parsing for SQL INSERT statements in embedded COBOL SQL.
Introduces HostVariableBinding shared class for column-to-variable mapping.

- New InsertStatement CodeElement with TableName, Columns, HostVariables, HasSubselect
- New Insert AST node (GenericNode&lt;InsertStatement&gt;)
- ANTLR grammar rule: insertStatement with insertColumnList
- Remove SQL_INSERT from unsupportedSqlStatement catch-all
- Full infrastructure: enum, visitor, CUP terminal/production, builder, dispatcher, listener
- SqlCodeElementBuilder.CreateInsertStatement() with helper methods
- Test: 4 INSERT scenarios (VALUES, schema-qualified, subselect, no column list)
- Updated UnsupportedSqlStatement test expected output

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/TypeCobol.Test/Parser/Programs/Cobol85/ExecSql/ExecInDataDivision_NoEndExec.Mix.txt b/TypeCobol.Test/Parser/Programs/Cobol85/ExecSql/ExecInDataDivision_NoEndExec.Mix.txt
@@ -1,6 +1,6 @@
 ﻿       IDENTIFICATION DIVISION.
        PROGRAM-ID. TCOMFL06.
-Line 3[8,21] <27, Error, Syntax> - Syntax error : extraneous input 'datadivision.' expecting {ExecStatementText, ExecStatementEnd, CommitStatement, SelectStatement, RollbackStatement, TruncateStatement, SavepointStatement, WhenEverStatement, LockTableStatement, ReleaseSavepointStatement, ConnectStatement, DropTableStatement, SetAssignmentStatement, GetDiagnosticsStatement, AlterSequenceStatement, ExecuteImmediateStatement, UnsupportedSqlStatement}
+Line 3[8,21] <27, Error, Syntax> - Syntax error : extraneous input 'datadivision.' expecting {ExecStatementText, ExecStatementEnd, CommitStatement, SelectStatement, RollbackStatement, TruncateStatement, SavepointStatement, WhenEverStatement, LockTableStatement, ReleaseSavepointStatement, ConnectStatement, DropTableStatement, SetAssignmentStatement, GetDiagnosticsStatement, AlterSequenceStatement, ExecuteImmediateStatement, InsertStatement, UnsupportedSqlStatement}
        data division.
        working-storage section.
       *Issue #2121, this would previously throw an InvalidCastException
diff --git a/TypeCobol.Test/Parser/Programs/Cobol85/ExecSql/ExecSqlWithInsertStatement.SQL.txt b/TypeCobol.Test/Parser/Programs/Cobol85/ExecSql/ExecSqlWithInsertStatement.SQL.txt
@@ -0,0 +1,22 @@
+--- Sql Statements ---
+line 11: InsertStatement
+- TableName = EMPLOYEE
+- Columns = [NAME, AGE]
+- HasSubselect = False
+- HostVariables:
+  - IN WS-NAME -> NAME
+  - IN WS-AGE -> AGE
+line 16: InsertStatement
+- TableName = HR.EMPLOYEE
+- Columns = [SALARY]
+- HasSubselect = False
+- HostVariables:
+  - IN WS-SALARY -> SALARY
+line 26: InsertStatement
+- TableName = EMPLOYEE
+- Columns = <NULL>
+- HasSubselect = False
+- HostVariables:
+  - IN WS-NAME -> <NULL>
+  - IN WS-AGE -> <NULL>
+  - IN WS-SALARY -> <NULL>
diff --git a/TypeCobol.Test/Parser/Programs/Cobol85/ExecSql/ExecSqlWithInsertStatement.rdz.cbl b/TypeCobol.Test/Parser/Programs/Cobol85/ExecSql/ExecSqlWithInsertStatement.rdz.cbl
@@ -0,0 +1,30 @@
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. TSTINSRT.
+       DATA DIVISION.
+       WORKING-STORAGE SECTION.
+       01  WS-NAME          PIC X(30).
+       01  WS-AGE           PIC 9(3).
+       01  WS-SALARY        PIC 9(7)V99.
+       PROCEDURE DIVISION.
+      * Simple INSERT with host variables
+           EXEC SQL
+              INSERT INTO EMPLOYEE (NAME, AGE)
+              VALUES (:WS-NAME, :WS-AGE)
+           END-EXEC
+      * INSERT with schema-qualified table
+           EXEC SQL
+              INSERT INTO HR.EMPLOYEE (SALARY)
+              VALUES (:WS-SALARY)
+           END-EXEC
+      * INSERT with subselect
+           EXEC SQL
+              INSERT INTO ARCHIVE.EMPLOYEE (NAME, AGE)
+              SELECT NAME, AGE FROM EMPLOYEE
+           END-EXEC
+      * INSERT without column list
+           EXEC SQL
+              INSERT INTO EMPLOYEE
+              VALUES (:WS-NAME, :WS-AGE, :WS-SALARY)
+           END-EXEC
+           GOBACK.
+       END PROGRAM TSTINSRT.
diff --git a/TypeCobol.Test/Parser/Programs/Cobol85/ExecSql/ExecSqlWithUnsupportedStatement.SQL.txt b/TypeCobol.Test/Parser/Programs/Cobol85/ExecSql/ExecSqlWithUnsupportedStatement.SQL.txt
@@ -1,3 +1,10 @@
-﻿--- Sql Statements ---
+--- Sql Statements ---
+line 14: InsertStatement
+- TableName = TABLE1
+- Columns = [COL1, COL2]
+- HasSubselect = False
+- HostVariables:
+  - IN WS-VAR1 -> COL1
+  - IN WS-VAR2 -> COL2
 line 47: RollbackStatement
 - SavePointClause = <NULL>
diff --git a/TypeCobol.Test/Utils/Comparators.cs b/TypeCobol.Test/Utils/Comparators.cs
@@ -7,6 +7,7 @@
 using TypeCobol.Compiler.Parser;
 using TypeCobol.Compiler.Preprocessor;
 using TypeCobol.Compiler.Scanner;
+using TypeCobol.Compiler.Sql.CodeElements;
 using TypeCobol.Compiler.Sql.CodeElements.Statements;
 using TypeCobol.Compiler.Sql.Model;
 using TypeCobol.Compiler.Text;
@@ -713,6 +714,11 @@ private void DumpObject(string name, object value)
                 SqlObject.DumpProperty(_writer, name, value, 0);
             }
 
+            private void DumpString(string name, string value)
+            {
+                _writer.WriteLine($"- {name} = {value ?? "<NULL>"}");
+            }
+
             public override bool Visit(SelectStatement selectStatement)
             {
                 _writer.WriteLine($"line {selectStatement.Line}: {nameof(SelectStatement)}");
@@ -835,6 +841,47 @@ public override bool Visit(ExecuteImmediateStatement executeImmediateStatement)
                 DumpObject(nameof(executeImmediateStatement.StatementExpression), executeImmediateStatement.StatementExpression);
                 return true;
             }
+
+            public override bool Visit(InsertStatement insertStatement)
+            {
+                _writer.WriteLine($"line {insertStatement.Line}: {nameof(InsertStatement)}");
+                DumpString(nameof(insertStatement.TableName), insertStatement.TableName);
+                DumpStringList(nameof(insertStatement.Columns), insertStatement.Columns);
+                DumpObject(nameof(insertStatement.HasSubselect), insertStatement.HasSubselect);
+                DumpHostVariableBindings(insertStatement.HostVariables);
+                return true;
+            }
+
+            public override bool Visit(UnsupportedSqlStatement unsupportedSqlStatement)
+            {
+                _writer.WriteLine($"line {unsupportedSqlStatement.Line}: {nameof(UnsupportedSqlStatement)}");
+                DumpString(nameof(unsupportedSqlStatement.SqlKeyword), unsupportedSqlStatement.SqlKeyword);
+                return true;
+            }
+
+            private void DumpStringList(string name, IList<string> values)
+            {
+                if (values == null)
+                {
+                    _writer.WriteLine($"- {name} = <NULL>");
+                    return;
+                }
+                _writer.WriteLine($"- {name} = [{string.Join(", ", values)}]");
+            }
+
+            private void DumpHostVariableBindings(IList<HostVariableBinding> bindings, string name = "HostVariables")
+            {
+                if (bindings == null || bindings.Count == 0)
+                {
+                    _writer.WriteLine($"- {name} = <NONE>");
+                    return;
+                }
+                _writer.WriteLine($"- {name}:");
+                foreach (var b in bindings)
+                {
+                    _writer.WriteLine($"  - {b.Direction} {b.VariableName} -> {b.ColumnName ?? "<NULL>"}");
+                }
+            }
         }
 
         public string Format(CompilationUnit compilationResult, IncrementalChangesHistory history)
diff --git a/TypeCobol/AntlrGrammar/CobolCodeElements.g4 b/TypeCobol/AntlrGrammar/CobolCodeElements.g4
@@ -228,6 +228,7 @@ codeElement:
 	| getDiagnosticsStatement
 	| alterSequenceStatement
 	| executeImmediateStatement
+	| insertStatement
 	| unsupportedSqlStatement
 
 //	[TYPECOBOL]
@@ -8531,6 +8532,15 @@ executeImmediateStatement : SQL_EXECUTE SQL_IMMEDIATE (sqlVariable | stringExpre
 //TODO extend stringExpression to support all expressions that yield a string (i.e string concat, function calls returning text,...)
 stringExpression: AlphanumericLiteral;
 
+// INSERT statement
+// See Documentation [https://www.ibm.com/docs/en/db2-for-zos/12?topic=statements-insert]
+insertStatement:
+    SQL_INSERT SQL_INTO tableOrViewOrCorrelationName
+    insertColumnList?
+    (SQL_VALUES LeftParenthesisSeparator repeatedSourceValue RightParenthesisSeparator | fullselect);
+insertColumnList:
+    LeftParenthesisSeparator column_name (SQL_CommaSeparator column_name)* RightParenthesisSeparator;
+
 // Catch-all rule for SQL statements without dedicated grammar rules.
 // Must be listed LAST among SQL alternatives in codeElement so that
 // supported statements are tried first.
diff --git a/TypeCobol/Compiler/CodeElements/CobolLanguageLevelVisitor.cs b/TypeCobol/Compiler/CodeElements/CobolLanguageLevelVisitor.cs
@@ -414,6 +414,8 @@ bool IsStopVisitingChildren
         bool Visit([NotNull] ExecuteImmediate executeImmediate);
         bool Visit([NotNull] UnsupportedSqlStatement unsupportedSqlStatement);
         bool Visit([NotNull] UnsupportedSql unsupportedSql);
+        bool Visit([NotNull] InsertStatement insertStatement);
+        bool Visit([NotNull] Insert insert);
     }
 
 
@@ -1674,5 +1676,13 @@ public virtual bool Visit([NotNull] UnsupportedSql unsupportedSql)
         {
             return true;
         }
+        public virtual bool Visit([NotNull] InsertStatement insertStatement)
+        {
+            return true;
+        }
+        public virtual bool Visit([NotNull] Insert insert)
+        {
+            return true;
+        }
     }
 }
diff --git a/TypeCobol/Compiler/CodeElements/CodeElementType.cs b/TypeCobol/Compiler/CodeElements/CodeElementType.cs
@@ -176,6 +176,7 @@ public enum CodeElementType
         GetDiagnosticsStatement,
         AlterSequenceStatement,
         ExecuteImmediateStatement,
+        InsertStatement,
         UnsupportedSqlStatement,
 
         // [TYPECOBOL]
diff --git a/TypeCobol/Compiler/CodeElements/StatementElement.cs b/TypeCobol/Compiler/CodeElements/StatementElement.cs
@@ -144,6 +144,7 @@ public enum StatementType
         GetDiagnosticsStatement,
         AlterSequenceStatement,
         ExecuteImmediateStatement,
+        InsertStatement,
         UnsupportedSqlStatement
 
     }
diff --git a/TypeCobol/Compiler/CupParser/NodeBuilder/IProgramClassBuilder.cs b/TypeCobol/Compiler/CupParser/NodeBuilder/IProgramClassBuilder.cs
@@ -890,6 +890,7 @@ public interface IProgramClassBuilder
         /// </summary>
         /// <param name="unsupportedSql">The corresponding UnsupportedSql Statement Code Element</param>
         void OnUnsupportedSqlStatement([NotNull] UnsupportedSqlStatement unsupportedSql);
+        void OnInsertStatement([NotNull] InsertStatement insert);
         #endregion
     }
 }
diff --git a/TypeCobol/Compiler/CupParser/NodeBuilder/ProgramClassBuilder.cs b/TypeCobol/Compiler/CupParser/NodeBuilder/ProgramClassBuilder.cs
@@ -1804,5 +1804,11 @@ public void OnUnsupportedSqlStatement([NotNull] UnsupportedSqlStatement unsuppor
             Exit();
             Dispatcher.OnUnsupportedSqlStatement(unsupportedSql);
         }
+        public void OnInsertStatement([NotNull] InsertStatement insert)
+        {
+            Enter(new Insert(insert), insert);
+            Exit();
+            Dispatcher.OnInsertStatement(insert);
+        }
     }
 }
diff --git a/TypeCobol/Compiler/CupParser/NodeBuilder/ProgramClassBuilderNodeDispatcher.cs b/TypeCobol/Compiler/CupParser/NodeBuilder/ProgramClassBuilderNodeDispatcher.cs
@@ -910,5 +910,9 @@ public void OnUnsupportedSqlStatement([NotNull] UnsupportedSqlStatement unsuppor
         {
             foreach (var listener in _listeners) listener.OnUnsupportedSqlStatement(unsupportedSql);
         }
+        public void OnInsertStatement([NotNull] InsertStatement insert)
+        {
+            foreach (var listener in _listeners) listener.OnInsertStatement(insert);
+        }
     }
 }
diff --git a/TypeCobol/Compiler/CupParser/NodeBuilder/ProgramClassBuilderNodeListener.cs b/TypeCobol/Compiler/CupParser/NodeBuilder/ProgramClassBuilderNodeListener.cs
@@ -898,5 +898,6 @@ public void OnUnsupportedSqlStatement([NotNull] UnsupportedSqlStatement unsuppor
         {
 
         }
+        public void OnInsertStatement([NotNull] InsertStatement insert) { }
     }
 }
diff --git a/TypeCobol/Compiler/CupParser/TypeCobolProgram.cup b/TypeCobol/Compiler/CupParser/TypeCobolProgram.cup
@@ -248,6 +248,7 @@ terminal TypeCobol.Compiler.Sql.CodeElements.Statements.SetAssignmentStatement S
 terminal TypeCobol.Compiler.Sql.CodeElements.Statements.GetDiagnosticsStatement GetDiagnosticsStatement;
 terminal TypeCobol.Compiler.Sql.CodeElements.Statements.AlterSequenceStatement AlterSequenceStatement;
 terminal TypeCobol.Compiler.Sql.CodeElements.Statements.ExecuteImmediateStatement ExecuteImmediateStatement;
+terminal TypeCobol.Compiler.Sql.CodeElements.Statements.InsertStatement InsertStatement;
 terminal TypeCobol.Compiler.Sql.CodeElements.Statements.UnsupportedSqlStatement UnsupportedSqlStatement;
 
 
@@ -832,6 +833,8 @@ sqlStatement ::= CommitStatement:stmt
 {: my_parser.Builder.OnAlterSequenceStatement(stmt); :}
 |	ExecuteImmediateStatement:stmt
 {: my_parser.Builder.OnExecuteImmediateStatement(stmt); :}
+|	InsertStatement:stmt
+{: my_parser.Builder.OnInsertStatement(stmt); :}
 |	UnsupportedSqlStatement:stmt
 {: my_parser.Builder.OnUnsupportedSqlStatement(stmt); :}
 ;
diff --git a/TypeCobol/Compiler/Parser/CodeElementBuilder/CobolCodeElementBuilder.cs b/TypeCobol/Compiler/Parser/CodeElementBuilder/CobolCodeElementBuilder.cs
@@ -2469,5 +2469,11 @@ public override void EnterUnsupportedSqlStatement([NotNull] CodeElementsParser.U
             Context = context;
             CodeElement = _sqlCodeElementBuilder.CreateUnsupportedSqlStatement(context);
         }
+
+        public override void EnterInsertStatement([NotNull] CodeElementsParser.InsertStatementContext context)
+        {
+            Context = context;
+            CodeElement = _sqlCodeElementBuilder.CreateInsertStatement(context);
+        }
     }
 }
diff --git a/TypeCobol/Compiler/Sql/CodeElements/HostVariableBinding.cs b/TypeCobol/Compiler/Sql/CodeElements/HostVariableBinding.cs
@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+
+namespace TypeCobol.Compiler.Sql.CodeElements
+{
+    public enum HostVariableDirection
+    {
+        IN,
+        OUT
+    }
+
+    public class HostVariableBinding
+    {
+        public string ColumnName { get; set; }
+        public string VariableName { get; set; }
+        public string IndicatorName { get; set; }
+        public HostVariableDirection Direction { get; set; }
+
+        public HostVariableBinding(string variableName, HostVariableDirection direction, string columnName = null, string indicatorName = null)
+        {
+            VariableName = variableName;
+            Direction = direction;
+            ColumnName = columnName;
+            IndicatorName = indicatorName;
+        }
+    }
+}
diff --git a/TypeCobol/Compiler/Sql/CodeElements/SqlCodeElementBuilder.cs b/TypeCobol/Compiler/Sql/CodeElements/SqlCodeElementBuilder.cs
@@ -944,5 +944,82 @@ public UnsupportedSqlStatement CreateUnsupportedSqlStatement(CodeElementsParser.
             string keyword = firstToken?.Text ?? "UNKNOWN";
             return new UnsupportedSqlStatement(keyword);
         }
+
+        public InsertStatement CreateInsertStatement(CodeElementsParser.InsertStatementContext context)
+        {
+            string tableName = ExtractQualifiedTableName(context.tableOrViewOrCorrelationName());
+
+            List<string> columns = null;
+            if (context.insertColumnList() != null)
+            {
+                columns = new List<string>();
+                foreach (var col in context.insertColumnList().column_name())
+                {
+                    columns.Add(col.GetText());
+                }
+            }
+
+            var hostVariables = new List<HostVariableBinding>();
+            bool hasSubselect = false;
+
+            if (context.repeatedSourceValue() != null)
+            {
+                int colIndex = 0;
+                foreach (var value in context.repeatedSourceValue().sourceValue())
+                {
+                    // sourceValue can contain a hostVariable via sqlExpression → sqlVariable → hostVariable
+                    var hostVar = FindHostVariable(value);
+                    if (hostVar != null)
+                    {
+                        string colName = columns != null && colIndex < columns.Count ? columns[colIndex] : null;
+                        var binding = CreateHostVariableBinding(hostVar, HostVariableDirection.IN, colName);
+                        hostVariables.Add(binding);
+                    }
+                    colIndex++;
+                }
+            }
+            else if (context.fullselect() != null)
+            {
+                hasSubselect = true;
+            }
+
+            return new InsertStatement(tableName, columns, hostVariables, hasSubselect);
+        }
+
+        private string ExtractQualifiedTableName(CodeElementsParser.TableOrViewOrCorrelationNameContext context)
+        {
+            if (context == null) return "UNKNOWN";
+            string name = context.Name?.Text ?? "UNKNOWN";
+            if (context.SchemaName != null)
+                name = context.SchemaName.Text + "." + name;
+            if (context.DBMS != null)
+                name = context.DBMS.Text + "." + name;
+            return name;
+        }
+
+        private HostVariableBinding CreateHostVariableBinding(CodeElementsParser.HostVariableContext context, HostVariableDirection direction, string columnName = null)
+        {
+            string varName = context.mainVariable?.Text;
+            string indName = context.indicatorVariable?.Text;
+            return new HostVariableBinding(varName, direction, columnName, indName);
+        }
+
+        /// <summary>
+        /// Navigate sourceValue → sqlExpression → sqlVariable → hostVariable
+        /// </summary>
+        private CodeElementsParser.HostVariableContext FindHostVariable(Antlr4.Runtime.ParserRuleContext context)
+        {
+            if (context == null) return null;
+            if (context is CodeElementsParser.HostVariableContext hv) return hv;
+            foreach (var child in context.children ?? System.Array.Empty<Antlr4.Runtime.Tree.IParseTree>())
+            {
+                if (child is Antlr4.Runtime.ParserRuleContext childCtx)
+                {
+                    var result = FindHostVariable(childCtx);
+                    if (result != null) return result;
+                }
+            }
+            return null;
+        }
     }
 }
diff --git a/TypeCobol/Compiler/Sql/CodeElements/Statements/InsertStatement.cs b/TypeCobol/Compiler/Sql/CodeElements/Statements/InsertStatement.cs
diff --git a/TypeCobol/Compiler/Sql/Nodes/Insert.cs b/TypeCobol/Compiler/Sql/Nodes/Insert.cs

Original file line number	Diff line number	Diff line change
`@@ -414,6 +414,8 @@ bool IsStopVisitingChildren`
`414`	`414`	`bool Visit([NotNull] ExecuteImmediate executeImmediate);`
`415`	`415`	`bool Visit([NotNull] UnsupportedSqlStatement unsupportedSqlStatement);`
`416`	`416`	`bool Visit([NotNull] UnsupportedSql unsupportedSql);`
	`417`	`+ bool Visit([NotNull] InsertStatement insertStatement);`
	`418`	`+ bool Visit([NotNull] Insert insert);`
`417`	`419`	`}`
`418`	`420`
`419`	`421`
`@@ -1674,5 +1676,13 @@ public virtual bool Visit([NotNull] UnsupportedSql unsupportedSql)`
`1674`	`1676`	`{`
`1675`	`1677`	`return true;`
`1676`	`1678`	`}`
	`1679`	`+ public virtual bool Visit([NotNull] InsertStatement insertStatement)`
	`1680`	`+ {`
	`1681`	`+ return true;`
	`1682`	`+ }`
	`1683`	`+ public virtual bool Visit([NotNull] Insert insert)`
	`1684`	`+ {`
	`1685`	`+ return true;`
	`1686`	`+ }`
`1677`	`1687`	`}`
`1678`	`1688`	`}`
Original file line number	Diff line number	Diff line change
`@@ -144,6 +144,7 @@ public enum StatementType`
`144`	`144`	`GetDiagnosticsStatement,`
`145`	`145`	`AlterSequenceStatement,`
`146`	`146`	`ExecuteImmediateStatement,`
	`147`	`+ InsertStatement,`
`147`	`148`	`UnsupportedSqlStatement`
`148`	`149`
`149`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -890,6 +890,7 @@ public interface IProgramClassBuilder`
`890`	`890`	`/// </summary>`
`891`	`891`	`/// <param name="unsupportedSql">The corresponding UnsupportedSql Statement Code Element</param>`
`892`	`892`	`void OnUnsupportedSqlStatement([NotNull] UnsupportedSqlStatement unsupportedSql);`
	`893`	`+ void OnInsertStatement([NotNull] InsertStatement insert);`
`893`	`894`	`#endregion`
`894`	`895`	`}`
`895`	`896`	`}`