Benchmark plxcobol; add STRING-APPEND, %, and a VARYING->FOR fast path

Add plxcobol to the benchmark harness across all five workloads. Two changes
make the comparison fair and idiomatic:

- STRING-APPEND <expr> TO <var> lowers to the plx_strbuild string builder, the
  COBOL counterpart of the other dialects' append operators, so in-loop string
  building is amortized O(1) (10 ms vs plpgsql's 1743 ms).
- A PERFORM VARYING v FROM a BY 1 UNTIL v > b (or >= b) counting loop now lowers
  to a plpgsql integer FOR loop instead of a WHILE with a manual step; this
  brings arith from 2.6x to parity with plpgsql. Other VARYING forms keep WHILE.
- % is accepted as the modulo operator in expressions.

Result on PostgreSQL 18.4: plxcobol matches plpgsql on arith (0.97x), strbuild
(10 ms), iter (1.09x), and call (1.04x). Branch is 1.32x because EVALUATE lowers
to CASE rather than the IF/ELSIF chain the other dialects use. Adds a
STRING-APPEND regression case; all 9 suites pass on PostgreSQL 17 and 18.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: plx

CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to plx are recorded here. The format follows
 [Keep a Changelog](https://keepachangelog.com/), and plx uses the extension
 version in `plx.control` (currently `1.0`).
 
+## [Unreleased]
+
+### Added
+
+- plxcobol: `STRING-APPEND <expr> TO <var>`, which lowers to the `plx_strbuild`
+  string builder (the COBOL counterpart of the other dialects' append operators),
+  and `%` as the modulo operator in expressions.
+
+### Changed
+
+- plxcobol: a `PERFORM VARYING v FROM a BY 1 UNTIL v > b` (or `>= b`) counting
+  loop now lowers to a plpgsql integer `FOR` loop instead of a `WHILE` with a
+  manual step, which is faster; other `PERFORM VARYING` forms still use `WHILE`.
+- Benchmarks now cover plxcobol (`bench/BENCHMARKS.md`): it matches plpgsql on
+  arith, strbuild, iter, and call, and is about 1.3x on the branch workload
+  because `EVALUATE` lowers to `CASE`.
+
 ## [1.1] - 2026-07-14
 
 ### Added

bench/BENCHMARKS.md

@@ -10,7 +10,8 @@ Five workloads were measured on PostgreSQL 18.4 in the development container
 - strbuild: build a 200,000-character string one character at a time in a loop
   (text handling with the natural in-language idiom for each language). plpgsql
   uses `s := s || 'x'`. The plx dialects use their append operator (`s << 'x'`,
-  `$s .= 'x'`, `s += 'x'`), which plx lowers to the plx_strbuild builder.
+  `$s .= 'x'`, `s += 'x'`, and `STRING-APPEND 'x' TO S` in plxcobol), which plx
+  lowers to the plx_strbuild builder.
 - iter: sum a `bigint` column over a 1,000,000-row table (SPI and per-row
   marshalling).
 - branch: a four-way conditional per element over 2,000,000 elements (branch
@@ -26,33 +27,34 @@ reported. The harness is `bench/run_bench.py`. All languages run in one database
 plx uses plx-prefixed language names, so it coexists with the native plruby,
 plphp, plperl, and plpython3u.
 
-plxruby, plxphp, plxjs, and plxpython3 transpile to plpgsql at `CREATE FUNCTION`
-time, so at run time they execute as plpgsql. plperl and plpython3u run their own
-embedded interpreters and retrieve rows through SPI.
+plxruby, plxphp, plxjs, plxpython3, and plxcobol transpile to plpgsql at
+`CREATE FUNCTION` time, so at run time they execute as plpgsql. plperl and
+plpython3u run their own embedded interpreters and retrieve rows through SPI.
 
 ## Results
 
 Times are milliseconds; the multiplier is relative to plpgsql (lower is faster).
 
 | language   | arith        | strbuild     | iter          | branch        | call          |
 |------------|--------------|--------------|---------------|---------------|---------------|
-| plpgsql    | 53 (1.00x)   | 1705 (1.00x) | 92 (1.00x)    | 157 (1.00x)   | 160 (1.00x)   |
-| plxruby    | 56 (1.06x)   | 10 (0.01x)   | 103 (1.12x)   | 175 (1.11x)   | 165 (1.03x)   |
-| plxphp     | 56 (1.07x)   | 10 (0.01x)   | 106 (1.14x)   | 165 (1.05x)   | 168 (1.04x)   |
-| plxjs      | 58 (1.10x)   | 10 (0.01x)   | 109 (1.18x)   | 175 (1.11x)   | 167 (1.04x)   |
-| plxpython3 | 58 (1.10x)   | 10 (0.01x)   | 103 (1.12x)   | 165 (1.05x)   | 163 (1.02x)   |
-| plperl     | 45 (0.86x)   | 12 (0.01x)   | 555 (6.00x)   | 163 (1.04x)   | 302 (1.88x)   |
-| plpython3u | 74 (1.40x)   | 15 (0.01x)   | 369 (4.00x)   | 111 (0.70x)   | 181 (1.13x)   |
-| plruby     | 101 (1.91x)  | 53 (0.03x)   | 392 (4.24x)   | 144 (0.92x)   | 476 (2.97x)   |
-| plphp      | 50 (0.95x)   | 14 (0.01x)   | 263 (2.84x)   | 66 (0.42x)    | 270 (1.68x)   |
+| plpgsql    | 56 (1.00x)   | 1743 (1.00x) | 96 (1.00x)    | 161 (1.00x)   | 164 (1.00x)   |
+| plxruby    | 56 (1.00x)   | 10 (0.01x)   | 112 (1.17x)   | 163 (1.01x)   | 157 (0.96x)   |
+| plxphp     | 54 (0.97x)   | 10 (0.01x)   | 101 (1.06x)   | 174 (1.08x)   | 169 (1.03x)   |
+| plxjs      | 58 (1.03x)   | 10 (0.01x)   | 105 (1.09x)   | 162 (1.00x)   | 169 (1.03x)   |
+| plxpython3 | 57 (1.02x)   | 10 (0.01x)   | 103 (1.07x)   | 167 (1.03x)   | 159 (0.97x)   |
+| plxcobol   | 55 (0.97x)   | 10 (0.01x)   | 104 (1.09x)   | 214 (1.32x)   | 170 (1.04x)   |
+| plperl     | 44 (0.79x)   | 12 (0.01x)   | 539 (5.61x)   | 153 (0.95x)   | 300 (1.83x)   |
+| plpython3u | 73 (1.31x)   | 17 (0.01x)   | 350 (3.64x)   | 109 (0.68x)   | 191 (1.16x)   |
+| plruby     | 100 (1.79x)  | 53 (0.03x)   | 385 (4.00x)   | 145 (0.90x)   | 497 (3.03x)   |
+| plphp      | 51 (0.90x)   | 15 (0.01x)   | 259 (2.69x)   | 64 (0.40x)    | 282 (1.72x)   |
 
 The last two rows, plruby and plphp, are the third-party native PL/Ruby and
 PL/PHP (see the build notes below); the plx dialects with the same names but a
 `plx` prefix are the transpile-to-plpgsql implementations.
 
 In the strbuild column, native plpgsql is the `s := s || 'x'` baseline and the
 plx dialects use the builder. This is the intended native-versus-plx comparison:
-the same accumulation idiom is 1705 ms in stock plpgsql and about 10 ms in the
+the same accumulation idiom is 1743 ms in stock plpgsql and about 10 ms in the
 plx dialects. The plx builder is also faster than the native PLs' own in-language
 append on this workload (native plruby 53 ms, native plphp 14 ms), because it
 mutates one expanded-object buffer in place rather than materializing an
@@ -63,10 +65,18 @@ building). On PostgreSQL 13 to 17 the plx strbuild column would match plpgsql
 
 ## Analysis
 
-- The four plx dialects match plpgsql within about 11 percent on every workload,
-  because the stored function body is plpgsql. There is no run-time translation
-  cost; the translation happens once at `CREATE FUNCTION`. The small spread among
-  the dialects is measurement noise.
+- The plx dialects match plpgsql within about 10 percent on the arith, iter, and
+  call workloads, because the stored function body is plpgsql. There is no
+  run-time translation cost; the translation happens once at `CREATE FUNCTION`.
+  The small spread among the dialects is measurement noise.
+
+- plxcobol (branch): the one place plxcobol trails is the four-way branch
+  (1.32x). It is idiomatic in COBOL to write the branch as `EVALUATE`, which
+  lowers to a plpgsql `CASE` statement, whereas the other dialects and the
+  plpgsql baseline use an `IF`/`ELSIF` chain. The `CASE` form is modestly slower
+  here; on the other workloads plxcobol matches plpgsql (its `PERFORM VARYING`
+  counting loop lowers to an integer `FOR`, and `STRING-APPEND` lowers to the
+  string builder).
 
 - Row iteration (iter): plpgsql, and therefore the plx dialects, are 2.8x to 6.0x
   faster than the embedded PLs (plperl, plpython3u, native plruby, native plphp).

bench/run_bench.py

@@ -239,6 +239,73 @@ def add(tag, ext, defs):
 $x$;""", "SELECT b_call_xpy(%d)" % CALL_N, None),
 })
 
+# ---- plxcobol ----
+add("plxcobol", None, {
+ "arith": ("""CREATE FUNCTION b_arith_xcob(n bigint) RETURNS bigint LANGUAGE plxcobol AS $x$
+WORKING-STORAGE SECTION.
+01 WS-S PIC 9(18) VALUE 0.
+01 WS-I PIC 9(18).
+PROCEDURE DIVISION.
+    PERFORM VARYING WS-I FROM 1 BY 1 UNTIL WS-I > N
+        ADD WS-I TO WS-S
+    END-PERFORM
+    GOBACK RETURNING WS-S.
+$x$;""", "SELECT b_arith_xcob(%d)" % ARITH_N, None),
+ "strbuild": ("""CREATE FUNCTION b_str_xcob(n int) RETURNS int LANGUAGE plxcobol AS $x$
+WORKING-STORAGE SECTION.
+01 WS-S PIC X(1) VALUE "".
+01 WS-I PIC 9(9).
+PROCEDURE DIVISION.
+    PERFORM VARYING WS-I FROM 1 BY 1 UNTIL WS-I > N
+        STRING-APPEND "x" TO WS-S
+    END-PERFORM
+    GOBACK RETURNING length(WS-S).
+$x$;""", "SELECT b_str_xcob(%d)" % STR_N, str(STR_N)),
+ "iter": ("""CREATE FUNCTION b_iter_xcob() RETURNS bigint LANGUAGE plxcobol AS $x$
+WORKING-STORAGE SECTION.
+01 WS-S PIC 9(18) VALUE 0.
+01 WS-R TYPE RECORD.
+PROCEDURE DIVISION.
+    PERFORM WS-R OVER "SELECT v FROM bench_data"
+        ADD WS-R.V TO WS-S
+    END-PERFORM
+    GOBACK RETURNING WS-S.
+$x$;""", "SELECT b_iter_xcob()", None),
+ "branch": ("""CREATE FUNCTION b_branch_xcob(n int) RETURNS bigint LANGUAGE plxcobol AS $x$
+WORKING-STORAGE SECTION.
+01 WS-S PIC 9(18) VALUE 0.
+01 WS-I PIC 9(9).
+PROCEDURE DIVISION.
+    PERFORM VARYING WS-I FROM 1 BY 1 UNTIL WS-I > N
+        EVALUATE WS-I % 4
+            WHEN 0
+                ADD 3 TO WS-S
+            WHEN 1
+                ADD 1 TO WS-S
+            WHEN 2
+                ADD 2 TO WS-S
+            WHEN OTHER
+                ADD 4 TO WS-S
+        END-EVALUATE
+    END-PERFORM
+    GOBACK RETURNING WS-S.
+$x$;""", "SELECT b_branch_xcob(%d)" % BRANCH_N, None),
+ "call": ("""CREATE FUNCTION b_leaf_xcob(x int) RETURNS int LANGUAGE plxcobol AS $x$
+PROCEDURE DIVISION.
+    GOBACK RETURNING X + 1.
+$x$;
+CREATE FUNCTION b_call_xcob(n int) RETURNS bigint LANGUAGE plxcobol AS $x$
+WORKING-STORAGE SECTION.
+01 WS-S PIC 9(18) VALUE 0.
+01 WS-I PIC 9(9).
+PROCEDURE DIVISION.
+    PERFORM VARYING WS-I FROM 1 BY 1 UNTIL WS-I > N
+        COMPUTE WS-S = WS-S + b_leaf_xcob(WS-I)
+    END-PERFORM
+    GOBACK RETURNING WS-S.
+$x$;""", "SELECT b_call_xcob(%d)" % CALL_N, None),
+})
+
 # ---- native plperl ----
 add("plperl", "plperl", {
  "arith": ("""CREATE FUNCTION b_arith_pl(n bigint) RETURNS bigint LANGUAGE plperl AS $x$

doc/plxcobol.md

@@ -237,6 +237,27 @@ CALL "my_proc" USING WS-A WS-B
 
 `COMMIT` and `ROLLBACK` are available in a procedure context.
 
+### Building strings in a loop
+
+Concatenating onto a string in a loop is slow in plpgsql (O(n^2), because text is
+immutable and each step copies the whole string). `STRING-APPEND <expr> TO <var>`
+lowers to the plx string builder (`plx_strbuild`), whose append is amortized
+O(1):
+
+```sql
+01 WS-OUT PIC X(1) VALUE "".
+...
+PERFORM WS-ROW OVER "SELECT name FROM t ORDER BY id"
+    STRING-APPEND WS-ROW.NAME TO WS-OUT
+    STRING-APPEND "," TO WS-OUT
+END-PERFORM
+GOBACK RETURNING WS-OUT.
+```
+
+On PostgreSQL 18 this is amortized O(1) per append; on PostgreSQL 13 to 17 it is
+correct but not accelerated (the in-place optimization needs a PostgreSQL 18
+feature).
+
 ## Errors
 
 ### Raising
@@ -279,7 +300,8 @@ ASSERT N > 0
 - Concatenation and formatting: `DISPLAY` concatenates its operands.
 - Figurative constants: `ZERO` / `ZEROS` map to `0`, `SPACE` / `SPACES` to the
   empty string, `NULL` to SQL `NULL`.
-- Exponent: `**` maps to SQL `^`. The other arithmetic operators are as in SQL.
+- Arithmetic: `+`, `-`, `*`, `/` are as in SQL; `**` maps to SQL `^` (exponent)
+  and `%` is modulo. `COMPUTE` evaluates the expression as SQL.
 - Comparisons use SQL three-valued logic. Use `IS NULL` / `IS NOT NULL` to test
   for null.
 

src/plx_transpile.c

@@ -4553,7 +4553,7 @@ cob_lex(Cb *cb, const char *body)
 			continue;
 		}
 		if (*p == '+' || *p == '-' || *p == '*' || *p == '/' || *p == '=' ||
-			*p == '<' || *p == '>' || *p == ':')
+			*p == '<' || *p == '>' || *p == ':' || *p == '%')
 		{
 			CBPUSH(CB_OP, p, 1);
 			p++;
@@ -4577,7 +4577,8 @@ cob_is_verb(CbTok *tk)
 		"EVALUATE", "PERFORM", "DISPLAY", "RAISE", "ASSERT", "GOBACK", "RETURN",
 		"CONTINUE", "EXIT", "CALL", "EXECUTE", "COMMIT", "ROLLBACK",
 		"RETURN-NEXT", "RETURN-QUERY", "GET", "BEGIN-TRY",
-		"OPEN-CURSOR", "FETCH-CURSOR", "CLOSE-CURSOR", "MOVE-CURSOR", NULL
+		"OPEN-CURSOR", "FETCH-CURSOR", "CLOSE-CURSOR", "MOVE-CURSOR",
+		"STRING-APPEND", NULL
 	};
 	int			i;
 
@@ -5477,6 +5478,46 @@ cob_perform(Cb *cb, int ind)
 		initStringInfo(&by);
 		cob_value(cb, &by, s_until, 1);
 		cob_expect(cb, "UNTIL");
+
+		/*
+		 * Fast path: PERFORM VARYING v FROM a BY 1 UNTIL v > b (or >= b) is an
+		 * integer FOR loop, which plpgsql runs faster than a WHILE with a manual
+		 * increment. Requires BY 1 and a condition "<var> > b" / "<var> >= b".
+		 */
+		{
+			char	   *bytrim = by.data;
+			CbTok	   *c0 = cob_cur(cb);
+			CbTok	   *c1 = &cb->t[cb->pos + 1];
+			bool		gt = (c1->kind == CB_OP && c1->len == 1 && c1->s[0] == '>');
+			bool		ge = (c1->kind == CB_OP && c1->len == 2 &&
+							  c1->s[0] == '>' && c1->s[1] == '=');
+
+			while (*bytrim == ' ')
+				bytrim++;
+			if (strcmp(bytrim, "1") == 0 && c0->kind == CB_WORD && (gt || ge) &&
+				strcmp(cob_map(c0->s, c0->len), var) == 0)
+			{
+				StringInfoData bound;
+
+				cb->pos += 2;			/* control variable and the operator */
+				initStringInfo(&bound);
+				cob_value(cb, &bound, NULL, 0);
+				indent(&cb->cx->out, ind);
+				if (gt)
+					appendStringInfo(&cb->cx->out, "FOR %s IN (%s )..(%s ) LOOP\n",
+									 var, from.data, bound.data);
+				else
+					appendStringInfo(&cb->cx->out, "FOR %s IN (%s )..((%s ) - 1) LOOP\n",
+									 var, from.data, bound.data);
+				cob_block(cb, ind + 1);
+				cob_expect(cb, "END-PERFORM");
+				indent(&cb->cx->out, ind);
+				appendStringInfoString(&cb->cx->out, "END LOOP;\n");
+				return;
+			}
+		}
+
+		/* general PERFORM VARYING -> WHILE with a manual step */
 		initStringInfo(&c);
 		cob_value(cb, &c, NULL, 0);
 		indent(&cb->cx->out, ind);
@@ -6110,13 +6151,43 @@ cob_move_cursor(Cb *cb, int ind)
 	appendStringInfo(&cb->cx->out, "MOVE FORWARD %s FROM %s;\n", n ? n : "1", c);
 }
 
+/* STRING-APPEND <expr> TO <var>: lower to the plx_strbuild string builder
+ * (amortized-O(1) append), the COBOL counterpart of the other dialects'
+ * append operators. */
+static void
+cob_string_append(Cb *cb, int ind)
+{
+	StringInfoData v;
+	char	   *tgt;
+	PlxLocal2  *l;
+	static const char *stops[] = {"TO"};
+
+	cb->pos++;								/* STRING-APPEND */
+	initStringInfo(&v);
+	if (!cob_value(cb, &v, stops, 1))
+		cob_err(cb, "STRING-APPEND requires a value");
+	cob_expect(cb, "TO");
+	if (cob_cur(cb)->kind != CB_WORD)
+		cob_err(cb, "STRING-APPEND requires a receiving field");
+	tgt = cob_map(cob_cur(cb)->s, cob_cur(cb)->len);
+	cb->pos++;
+	l = local_find(cb->cx, tgt, strlen(tgt));
+	if (l && !l->is_record)
+		l->typ = pstrdup("plx_strbuild");	/* the accumulator becomes a builder */
+	indent(&cb->cx->out, ind);
+	appendStringInfo(&cb->cx->out, "%s := plx_sb_append(%s, (%s )::text);\n",
+					 tgt, tgt, v.data);
+}
+
 static void
 cob_stmt(Cb *cb, int ind)
 {
 	CbTok	   *tk = cob_cur(cb);
 
 	if (cob_ci(tk, "MOVE"))
 		cob_move(cb, ind);
+	else if (cob_ci(tk, "STRING-APPEND"))
+		cob_string_append(cb, ind);
 	else if (cob_ci(tk, "RETURN-NEXT"))
 		cob_return_next(cb, ind);
 	else if (cob_ci(tk, "RETURN-QUERY"))

test/expected/plxcobol.out

@@ -154,6 +154,25 @@ SELECT cob_area(2);
  12.56636
 (1 row)
 
+-- STRING-APPEND lowers to the plx_strbuild string builder; % is modulo
+CREATE FUNCTION cob_build(n int) RETURNS text LANGUAGE plxcobol AS $$
+WORKING-STORAGE SECTION.
+01 WS-S PIC X(1) VALUE "".
+01 WS-I PIC 9(9).
+PROCEDURE DIVISION.
+    PERFORM VARYING WS-I FROM 1 BY 1 UNTIL WS-I > N
+        IF WS-I % 2 = 0
+            STRING-APPEND "ab" TO WS-S
+        END-IF
+    END-PERFORM
+    GOBACK RETURNING WS-S.
+$$;
+SELECT cob_build(6);
+ cob_build 
+-----------
+ ababab
+(1 row)
+
 -- data set-up for the SQL constructs
 CREATE TEMP TABLE cob_items(id int, amount int);
 INSERT INTO cob_items VALUES (1, 10), (2, 20), (3, 30);

test/sql/plxcobol.sql

@@ -121,6 +121,21 @@ PROCEDURE DIVISION.
 $$;
 SELECT cob_area(2);
 
+-- STRING-APPEND lowers to the plx_strbuild string builder; % is modulo
+CREATE FUNCTION cob_build(n int) RETURNS text LANGUAGE plxcobol AS $$
+WORKING-STORAGE SECTION.
+01 WS-S PIC X(1) VALUE "".
+01 WS-I PIC 9(9).
+PROCEDURE DIVISION.
+    PERFORM VARYING WS-I FROM 1 BY 1 UNTIL WS-I > N
+        IF WS-I % 2 = 0
+            STRING-APPEND "ab" TO WS-S
+        END-IF
+    END-PERFORM
+    GOBACK RETURNING WS-S.
+$$;
+SELECT cob_build(6);
+
 -- data set-up for the SQL constructs
 CREATE TEMP TABLE cob_items(id int, amount int);
 INSERT INTO cob_items VALUES (1, 10), (2, 20), (3, 30);