feat: sections for arrays

README.md

@@ -24,10 +24,10 @@ Hello {{you}}!
 You just won {{qt}} at {{at}}.
 $$ language plmustache;
 
-select win_money('Slonik', '12000', now());
+select win_money('Sir Meowalot', '12000', now());
  win_money
 -----------------------------------------------------------
- Hello Slonik! +
+ Hello Sir Meowalot! +
  You just won $12,000.00 at 2023-12-04 07:44:26.915735-05.
 (1 row)
 ```
@@ -60,6 +60,8 @@ select do_not_escape_me('<script>evil()</script>');
 
 ### Sections
 
+Boolean sections:
+
 ```sql
 create or replace function show_cat(cat text, show bool default true) returns text as $$
 {{#show}}
@@ -85,6 +87,21 @@ select show_cat('Mr. Sleepy', false);
 (1 row)
 ```
 
+Array iterators:
+
+```sql
+create or replace function hello_cats(cats text[]) returns text as $$
+Say hello to: {{#cats}}{{.}}, {{/cats}}
+$$ language plmustache;
+
+
+postgres=# select hello_cats('{Sir Meowalot, Mr. Sleepy, Paquito}');
+ hello_cats
+---------------------------------------------------
+ Say hello to: Sir Meowalot, Mr. Sleepy, Paquito,
+(1 row)
+```
+
 ## Installation
 
 Clone the repo and submodules:

src/build.c

@@ -19,38 +19,55 @@
 const char IMPLICIT_ITERATOR = '.';
 
 static int
-plmustache_enter_section(void *userdata, const char *name){
+plmustache_section_enter(void *userdata, const char *name){
  plmustache_ctx *ctx = (plmustache_ctx *)userdata;
 
  for(size_t i = 0; i < ctx->num_params; i++){
  plmustache_param* prm = &ctx->params[i];
 
  if(strcmp(prm->prm_name, name) == 0){
+ ctx->section_key = prm->prm_name;
+ ctx->section_arr_length = prm->is_array? prm->prm_arr_length : 0;
+ ctx->section_idx = 0;
  return prm->enters_section;
  }
  }
 
  return 0;
 }
 
-// TODO these are used to handle sections, they're mandatory otherwise mustach segfaults
-static int plmustache_next(void *closure){
- return MUSTACH_OK;
+static int plmustache_section_next(void *userdata){
+ plmustache_ctx *ctx = (plmustache_ctx *)userdata;
+ return ctx->section_idx < ctx->section_arr_length;
 }
 
 static int
-plmustache_leave(void *closure){
+plmustache_section_leave(void *userdata){
+ plmustache_ctx *ctx = (plmustache_ctx *)userdata;
+ ctx->section_key = NULL;
+ ctx->section_idx = 0;
+ ctx->section_arr_length = 0;
  return MUSTACH_OK;
 }
 
 static int
 plmustache_get_variable(void *userdata, const char *name, struct mustach_sbuf *sbuf){
  plmustache_ctx *ctx = (plmustache_ctx *)userdata;
 
- for(size_t i = 0; i < ctx->num_params; i++){
+ if (name[0] == IMPLICIT_ITERATOR){
+ for(size_t i = 0; i < ctx->num_params; i++){
+ plmustache_param* prm = &ctx->params[i];
+
+ if(strcmp(prm->prm_name,ctx->section_key) == 0){
+ sbuf->value = prm->prm_arr[ctx->section_idx];
+ }
+ }
+ ctx->section_idx = ctx->section_idx + 1;
+ }
+ else for(size_t i = 0; i < ctx->num_params; i++){
  plmustache_param* prm = &ctx->params[i];
 
- if(strcmp(prm->prm_name, name) == 0){
+ if(strcmp(name, prm->prm_name) == 0){
  sbuf->value = prm->prm_value;
  }
  }
@@ -60,9 +77,9 @@ plmustache_get_variable(void *userdata, const char *name, struct mustach_sbuf *s
 
 struct mustach_itf build_mustach_itf(){
  return (struct mustach_itf)
- { .enter = plmustache_enter_section
- , .next = plmustache_next
- , .leave = plmustache_leave
+ { .enter = plmustache_section_enter
+ , .next = plmustache_section_next
+ , .leave = plmustache_section_leave
  , .get = plmustache_get_variable
  };
 }
@@ -143,15 +160,42 @@ build_mustache_ctx(plmustache_call_info call_info, NullableDatum args[]){
  for(size_t i = 0; i < call_info.numargs; i++){
  params[i].prm_name = call_info.argnames[i];
  NullableDatum arg = args[i];
+ Oid arg_type = call_info.argtypes[i];
+ Oid array_elem_type = get_element_type(arg_type);
+ bool arg_is_array = array_elem_type != InvalidOid;
+
  if(arg.isnull){
  params[i].prm_value = NULL;
  params[i].enters_section = false;
+ params[i].is_array = false;
  }else{
  params[i].prm_value = datum_to_cstring(arg.value, call_info.argtypes[i], ereporter);
- if(call_info.argtypes[i] == BOOLOID)
+ if(arg_type == BOOLOID)
  params[i].enters_section = DatumGetBool(arg.value);
  else
  params[i].enters_section = true;
+
+ if(arg_is_array){
+ params[i].is_array = true;
+ ArrayType *array = DatumGetArrayTypeP(arg.value);
+ ArrayIterator array_iterator = array_create_iterator(array, 0, NULL);
+ int arr_ndim = ARR_NDIM(array);
+ int arr_length = ArrayGetNItems(arr_ndim, ARR_DIMS(array));
+ if(arr_ndim > 1)
+ ereport(ERROR, errmsg("support for multidimensional arrays is not implemented"));
+
+ if(arr_length > 0){
+ Datum value; bool isnull; int j = 0;
+ params[i].prm_arr_length = arr_length;
+ params[i].prm_arr = palloc0(sizeof(char*) * arr_length);
+
+ while (array_iterate(array_iterator, &value, &isnull)) {
+ params[i].prm_arr[j] = isnull? NULL : datum_to_cstring(value, array_elem_type, ereporter);
+ j++;
+ }
+ } else
+ params[i].enters_section = false;
+ }
  }
  }
  }

src/build.h

@@ -6,14 +6,20 @@
 #include "observation.h"
 
 typedef struct {
- char *prm_name;
- char *prm_value;
- bool enters_section;
+ char *prm_name;
+ char *prm_value;
+ char **prm_arr;
+ size_t prm_arr_length;
+ bool enters_section;
+ bool is_array;
 } plmustache_param;
 
 typedef struct {
  size_t num_params;
  plmustache_param *params;
+ char *section_key;
+ size_t section_idx;
+ size_t section_arr_length;
  char *template;
 } plmustache_ctx;
 

test/expected/sections.out

@@ -67,6 +67,8 @@ select foo_test(false);
 create or replace function foo_null_test(foo bool) returns text as $$
 foo is {{#foo}}full{{/foo}}{{^foo}}null{{/foo}}
 $$ language plmustache;
+\echo
+
 select foo_null_test(null);
  foo_null_test 
 ---------------
@@ -79,3 +81,76 @@ select foo_null_test(true);
  foo is full
 (1 row)
 
+create or replace function foo_array(arr text[]) returns text as $$
+arr is {{#arr}}{{.}}, {{/arr}}
+$$ language plmustache;
+\echo
+
+select foo_array(ARRAY['one', 'two', 'three']);
+ foo_array 
+--------------------------
+ arr is one, two, three, 
+(1 row)
+
+create or replace function foo_array(arr int[]) returns text as $$
+arr is {{#arr}}{{.}}, {{/arr}}
+$$ language plmustache;
+\echo
+
+select foo_array(ARRAY[1, 2, 3]::int[]);
+ foo_array 
+------------------
+ arr is 1, 2, 3, 
+(1 row)
+
+-- empty array is handled properly
+select foo_array(ARRAY[]::int[]);
+ foo_array 
+-----------
+ arr is 
+(1 row)
+
+create or replace function mixed_var_array(var int, arr int[]) returns text as $$
+var is {{var}}, arr is {{#arr}}{{.}}, {{/arr}}
+$$ language plmustache;
+\echo
+
+select mixed_var_array(4, ARRAY[1, 2, 3]::int[]);
+ mixed_var_array 
+----------------------------
+ var is 4, arr is 1, 2, 3, 
+(1 row)
+
+create or replace function mixed_array_var(arr int[], var int) returns text as $$
+arr is {{#arr}}{{.}}, {{/arr}} var is {{var}}
+$$ language plmustache;
+\echo
+
+select mixed_array_var(ARRAY[1, 2, 3]::int[], 4);
+ mixed_array_var 
+---------------------------
+ arr is 1, 2, 3, var is 4
+(1 row)
+
+create or replace function mixed_array_var_array(arr1 int[], var text, arr2 int[]) returns text as $$
+arr1 is {{#arr1}}{{.}}, {{/arr1}} var is {{var}}
+arr2 is {{#arr2}}{{.}}, {{/arr2}} var is {{var}}
+$$ language plmustache;
+\echo
+
+select mixed_array_var_array(ARRAY[1, 2, 3], 'something', ARRAY[4, 5, 6]);
+ mixed_array_var_array 
+------------------------------------
+ arr1 is 1, 2, 3, var is something+
+ arr2 is 4, 5, 6, var is something
+(1 row)
+
+create or replace function nested_array(arr int[]) returns text as $$
+arr is {{#arr}}{{.}}, {{/arr}}
+$$ language plmustache;
+\echo
+
+select nested_array(ARRAY[[1,2,3], [4,5,6]]);
+ERROR: support for multidimensional arrays is not implemented
+select nested_array(ARRAY[[[1,2], [3,4]], [[5,6], [7,8]]]);
+ERROR: support for multidimensional arrays is not implemented

test/sql/sections.sql

@@ -38,7 +38,56 @@ select foo_test(false);
 create or replace function foo_null_test(foo bool) returns text as $$
 foo is {{#foo}}full{{/foo}}{{^foo}}null{{/foo}}
 $$ language plmustache;
+\echo
 
 select foo_null_test(null);
 
 select foo_null_test(true);
+
+create or replace function foo_array(arr text[]) returns text as $$
+arr is {{#arr}}{{.}}, {{/arr}}
+$$ language plmustache;
+\echo
+
+select foo_array(ARRAY['one', 'two', 'three']);
+
+create or replace function foo_array(arr int[]) returns text as $$
+arr is {{#arr}}{{.}}, {{/arr}}
+$$ language plmustache;
+\echo
+
+select foo_array(ARRAY[1, 2, 3]::int[]);
+
+-- empty array is handled properly
+select foo_array(ARRAY[]::int[]);
+
+create or replace function mixed_var_array(var int, arr int[]) returns text as $$
+var is {{var}}, arr is {{#arr}}{{.}}, {{/arr}}
+$$ language plmustache;
+\echo
+
+select mixed_var_array(4, ARRAY[1, 2, 3]::int[]);
+
+create or replace function mixed_array_var(arr int[], var int) returns text as $$
+arr is {{#arr}}{{.}}, {{/arr}} var is {{var}}
+$$ language plmustache;
+\echo
+
+select mixed_array_var(ARRAY[1, 2, 3]::int[], 4);
+
+create or replace function mixed_array_var_array(arr1 int[], var text, arr2 int[]) returns text as $$
+arr1 is {{#arr1}}{{.}}, {{/arr1}} var is {{var}}
+arr2 is {{#arr2}}{{.}}, {{/arr2}} var is {{var}}
+$$ language plmustache;
+\echo
+
+select mixed_array_var_array(ARRAY[1, 2, 3], 'something', ARRAY[4, 5, 6]);
+
+create or replace function nested_array(arr int[]) returns text as $$
+arr is {{#arr}}{{.}}, {{/arr}}
+$$ language plmustache;
+\echo
+
+select nested_array(ARRAY[[1,2,3], [4,5,6]]);
+
+select nested_array(ARRAY[[[1,2], [3,4]], [[5,6], [7,8]]]);