Failure Details — Result Set Comparisons

Full expected (Postgres) vs actual (Legend) result sets for every test where results differ.

Total result mismatches: 91

Table of Contents

• div__num_num__from_table [TDS]
• div__num_num__from_table [Relation]
• concat_ws__txt_variadic__from_table [TDS]
• concat_ws__txt_variadic__from_table [Relation]
• initcap__txt__from_table [TDS]
• initcap__txt__from_table [Relation]
• regexp_substr__nth_occurrence__ignored_by_legend [TDS]
• regexp_substr__nth_occurrence__ignored_by_legend [Relation]
• regexp_substr__nth_occurrence_last__ignored_by_legend [TDS]
• regexp_substr__nth_occurrence_last__ignored_by_legend [Relation]
• regexp_substr__start_position__ignored_by_legend [TDS]
• regexp_substr__start_position__ignored_by_legend [Relation]
• regexp_substr__start_and_nth__ignored_by_legend [TDS]
• regexp_substr__start_and_nth__ignored_by_legend [Relation]
• regexp_count__start_position__ignored_by_legend [TDS]
• regexp_count__start_position__ignored_by_legend [Relation]
• string_to_array__txt_txt__from_table [TDS]
• string_to_array__txt_txt__from_table [Relation]
• date_literal__fractional_6_digits [TDS]
• date_literal__fractional_6_digits [Relation]
• date_literal__fractional_9_digits [TDS]
• date_literal__fractional_9_digits [Relation]
• json_extract_path__from_column [Relation]
• array_position__anycompatiblearray_anycompatible__from_table [Relation]
• op_div__int__truncates_toward_zero [TDS]
• op_div__int__truncates_toward_zero [Relation]
• op_div__negative__truncates_toward_zero [TDS]
• op_div__negative__truncates_toward_zero [Relation]
• op_mod__negative__basic [TDS]
• op_mod__negative__basic [Relation]
• op_mod__numeric__basic [TDS]
• op_add__date_plus_int_days [TDS]
• op_add__date_plus_int_days [Relation]
• op_sub__date_minus_int_days [TDS]
• op_sub__date_minus_int_days [Relation]
• concat_op__txt_txt__from_table [TDS]
• concat_op__mixed_types__null_handling [TDS]
• eq__null_null [TDS]
• neq__int__null [TDS]
• neq__int__null [Relation]
• lt__int__null [Relation]
• gt__int__null [Relation]
• neq__filter__int [TDS]
• neq__filter__int [Relation]
• and__false_null [TDS]
• and__false_null [Relation]
• or__true_null [TDS]
• or__true_null [Relation]
• json_arrow_get_field [Relation]
• jsonb_arrow_get_field [Relation]
• json_arrow_get_index [Relation]
• jsonb_arrow_get_index [Relation]
• array_gt [TDS]
• anycompatible_concat_scalar_array [TDS]
• anycompatible_concat_array_scalar [TDS]
• anycompatible_concat_array_array [TDS]
• between__int__null [TDS]
• between__int__null [Relation]
• is_distinct_from__int__one_null [Relation]
• to_char_token__FF1 [TDS]
• to_char_token__FF1 [Relation]
• to_char_token__FF6 [TDS]
• to_char_token__FF6 [Relation]
• to_char_token__TZH [TDS]
• to_char_token__TZH [Relation]
• to_char_token__TZM [TDS]
• to_char_token__TZM [Relation]
• subquery_quant_all_empty_null_value [Relation]
• null_equals_null [TDS]
• null_not_equals [TDS]
• null_concat [TDS]
• null_concat [Relation]
• where_not_between [TDS]
• where_not_between [Relation]
• where_not_in_list [TDS]
• where_not_in_list [Relation]
• where_not_compound [Relation]
• bool_null_and_false [TDS]
• bool_null_and_false [Relation]
• bool_null_or_true [TDS]
• bool_null_or_true [Relation]
• star_multiple_tables [TDS]
• star_multiple_tables [Relation]
• schema_information_tables [TDS]
• schema_information_tables [Relation]
• schema_information_columns [TDS]
• schema_information_columns [Relation]
• json_extract_array_index [Relation]
• json_extract_array_negative_index [Relation]
• interval_compound_literal [TDS]
• interval_compound_literal [Relation]

❌ div__num_num__from_table [TDS]

SQL (Postgres):

SELECT DIV(numeric_val, 3.0) AS result FROM numbers WHERE numeric_val IS NOT NULL AND numeric_val <> 0 ORDER BY 1

SQL (Legend, rewritten):

SELECT DIV(numeric_val, 3.0) AS result FROM func('e2e::tds_numbers') WHERE numeric_val IS NOT NULL AND numeric_val <> 0 ORDER BY 1

SQL (Generated, executed against DB):

select ((1.0 * "root".numeric_val) / 3.0) as "result" from public.numbers as "root" where ("root".numeric_val is not null and "root".numeric_val is distinct from 0) order by "result"

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.intVal,
      'int_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.floatVal,
      'float_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.numericVal,
      'numeric_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.smallVal,
      'small_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.bigVal,
      'big_val'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getFloat('numeric_val')->meta::pure::functions::collection::isNotEmpty() &&
    $row.getFloat('numeric_val') != 0
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getFloat('numeric_val') / 3.0,
      'result'
    )
)->meta::pure::tds::sort(
  meta::pure::tds::asc('result')
)

Differences:

• Row 0, column 'result': expected '-33333' but got '-33333.33333'
• Row 1, column 'result': expected '0' but got '-0.3333333333333333'
• Row 2, column 'result': expected '0' but got '-3.3333333333333333E-6'
• Row 3, column 'result': expected '0' but got '3.3333333333333333E-6'
• Row 4, column 'result': expected '111' but got '111.11111'
• Row 5, column 'result': expected '4115' but got '4115.2263'
• Row 6, column 'result': expected '16666' but got '16666.70781666667'

Expected (Postgres):

Actual (Legend):

❌ div__num_num__from_table [Relation]

SQL (Postgres):

SELECT DIV(numeric_val, 3.0) AS result FROM numbers WHERE numeric_val IS NOT NULL AND numeric_val <> 0 ORDER BY 1

SQL (Legend, rewritten):

SELECT DIV(numeric_val, 3.0) AS result FROM func('e2e::rel_numbers') WHERE numeric_val IS NOT NULL AND numeric_val <> 0 ORDER BY 1

SQL (Generated, executed against DB):

select ((1.0 * "root".numeric_val) / 3.0) as "result" from public.numbers as "root" where ("root".numeric_val is not null and "root".numeric_val is distinct from 0) order by "result"

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::NumberRow[1]|$x.id,
     int_val: x: e2e::NumberRow[1]|$x.intVal,
     float_val: x: e2e::NumberRow[1]|$x.floatVal,
     numeric_val: x: e2e::NumberRow[1]|$x.numericVal,
     small_val: x: e2e::NumberRow[1]|$x.smallVal,
     big_val: x: e2e::NumberRow[1]|$x.bigVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.numeric_val->meta::pure::functions::collection::isNotEmpty() &&
    $x.numeric_val != 0
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.numeric_val->meta::pure::functions::multiplicity::toOne() / 3.0
   ]
)->meta::pure::functions::relation::sort(
  ~result->meta::pure::functions::relation::ascending()
)

Differences:

• Row 0, column 'result': expected '-33333' but got '-33333.33333'
• Row 1, column 'result': expected '0' but got '-0.3333333333333333'
• Row 2, column 'result': expected '0' but got '-3.3333333333333333E-6'
• Row 3, column 'result': expected '0' but got '3.3333333333333333E-6'
• Row 4, column 'result': expected '111' but got '111.11111'
• Row 5, column 'result': expected '4115' but got '4115.2263'
• Row 6, column 'result': expected '16666' but got '16666.70781666667'

Expected (Postgres):

Actual (Legend):

❌ concat_ws__txt_variadic__from_table [TDS]

SQL (Postgres):

SELECT CONCAT_WS(', ', val, nullable_val) AS result FROM strings ORDER BY 1

SQL (Legend, rewritten):

SELECT CONCAT_WS(', ', val, nullable_val) AS result FROM func('e2e::tds_strings') ORDER BY 1

SQL (Generated, executed against DB):

select "root".val || "root".nullable_val || Text', ' as "result" from public.strings as "root" order by "result"

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.val,
      'val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.nullableVal,
      'nullable_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.unicodeVal,
      'unicode_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.emptyVal,
      'empty_val'
    )
  ]
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|[
        $row.getString('val'),
        $row.getString('nullable_val')
      ]->meta::pure::functions::string::joinStrings(', '),
      'result'
    )
)->meta::pure::tds::sort(
  meta::pure::tds::asc('result')
)

Differences:

• Row 0, column 'result': expected '' but got ' spaces has spaces, '
• Row 1, column 'result': expected ' spaces , has spaces' but got 'UPPERCASElowercase, '
• Row 2, column 'result': expected 'MiXeD CaSe' but got 'WORLDtest, '
• Row 3, column 'result': expected 'UPPERCASE, lowercase' but got 'abcdefghijABCDEFGHIJ, '
• Row 4, column 'result': expected 'WORLD, test' but got 'helloworld, '
• Row 5, column 'result': expected 'abcdefghij, ABCDEFGHIJ' but got 'repeatrepeat, '
• Row 6, column 'result': expected 'hello, world' but got 'special!@#$%12345, '
• Row 7, column 'result': expected 'repeat, repeat' but got 'the quick brown foxjumps over, '
• Row 8, column 'result': expected 'special!@#$%, 12345' but got 'null'
• Row 9, column 'result': expected 'the quick brown fox, jumps over' but got 'null'

Expected (Postgres):

Actual (Legend):

❌ concat_ws__txt_variadic__from_table [Relation]

SQL (Postgres):

SELECT CONCAT_WS(', ', val, nullable_val) AS result FROM strings ORDER BY 1

SQL (Legend, rewritten):

SELECT CONCAT_WS(', ', val, nullable_val) AS result FROM func('e2e::rel_strings') ORDER BY 1

SQL (Generated, executed against DB):

select concat("root".val,Text', ',"root".nullable_val) as "result" from public.strings as "root" order by "result"

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::StringRow[1]|$x.id,
     val: x: e2e::StringRow[1]|$x.val,
     nullable_val: x: e2e::StringRow[1]|$x.nullableVal,
     unicode_val: x: e2e::StringRow[1]|$x.unicodeVal,
     empty_val: x: e2e::StringRow[1]|$x.emptyVal
   ]
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|[
    $x.val->meta::pure::functions::multiplicity::toOne(),
    $x.nullable_val->meta::pure::functions::multiplicity::toOne()
  ]->meta::pure::functions::string::joinStrings(', ')
   ]
)->meta::pure::functions::relation::sort(
  ~result->meta::pure::functions::relation::ascending()
)

Differences:

• Row 0, column 'result': expected '' but got ' spaces , has spaces'
• Row 1, column 'result': expected ' spaces , has spaces' but got ', '
• Row 2, column 'result': expected 'MiXeD CaSe' but got 'MiXeD CaSe, '

Expected (Postgres):

Actual (Legend):

❌ initcap__txt__from_table [TDS]

SQL (Postgres):

SELECT INITCAP(val) AS result FROM strings ORDER BY 1

SQL (Legend, rewritten):

SELECT INITCAP(val) AS result FROM func('e2e::tds_strings') ORDER BY 1

SQL (Generated, executed against DB):

select case when char_length("root".val) = 0 then "root".val else concat(upper(left("root".val,1)),'',substring("root".val, 2)) end as "result" from public.strings as "root" order by "result"

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.val,
      'val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.nullableVal,
      'nullable_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.unicodeVal,
      'unicode_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.emptyVal,
      'empty_val'
    )
  ]
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getString('val')->meta::pure::functions::string::toUpperFirstCharacter(),
      'result'
    )
)->meta::pure::tds::sort(
  meta::pure::tds::asc('result')
)

Differences:

• Row 1, column 'result': expected ' Spaces ' but got ' spaces '
• Row 4, column 'result': expected 'Mixed Case' but got 'MiXeD CaSe'
• Row 7, column 'result': expected 'The Quick Brown Fox' but got 'The quick brown fox'
• Row 8, column 'result': expected 'Uppercase' but got 'UPPERCASE'
• Row 9, column 'result': expected 'World' but got 'WORLD'

Expected (Postgres):

Actual (Legend):

❌ initcap__txt__from_table [Relation]

SQL (Postgres):

SELECT INITCAP(val) AS result FROM strings ORDER BY 1

SQL (Legend, rewritten):

SELECT INITCAP(val) AS result FROM func('e2e::rel_strings') ORDER BY 1

SQL (Generated, executed against DB):

select case when char_length("root".val) = 0 then "root".val else concat(upper(left("root".val,1)), substring("root".val, 2)) end as "result" from public.strings as "root" order by "result"

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::StringRow[1]|$x.id,
     val: x: e2e::StringRow[1]|$x.val,
     nullable_val: x: e2e::StringRow[1]|$x.nullableVal,
     unicode_val: x: e2e::StringRow[1]|$x.unicodeVal,
     empty_val: x: e2e::StringRow[1]|$x.emptyVal
   ]
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|$x.val->meta::pure::functions::multiplicity::toOne()->meta::pure::functions::string::toUpperFirstCharacter()
   ]
)->meta::pure::functions::relation::sort(
  ~result->meta::pure::functions::relation::ascending()
)

Differences:

• Row 1, column 'result': expected ' Spaces ' but got ' spaces '
• Row 4, column 'result': expected 'Mixed Case' but got 'MiXeD CaSe'
• Row 7, column 'result': expected 'The Quick Brown Fox' but got 'The quick brown fox'
• Row 8, column 'result': expected 'Uppercase' but got 'UPPERCASE'
• Row 9, column 'result': expected 'World' but got 'WORLD'

Expected (Postgres):

Actual (Legend):

❌ regexp_substr__nth_occurrence__ignored_by_legend [TDS]

SQL (Postgres):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 1, 2) AS result FROM strings WHERE id = 10

SQL (Legend, rewritten):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 1, 2) AS result FROM func('e2e::tds_strings') WHERE id = 10

SQL (Generated, executed against DB):

select regexp_substr("root".val, Text'[a-z]+', 1, 1, 'p', 0) as "result" from public.strings as "root" where "root".id = 10

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.val,
      'val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.nullableVal,
      'nullable_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.unicodeVal,
      'unicode_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.emptyVal,
      'empty_val'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 10
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getString('val')->meta::pure::functions::string::regexpExtract(
        '[a-z]+',
        false
      )->meta::pure::functions::multiplicity::toOne(),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected 'quick' but got 'the'

Expected (Postgres):

Actual (Legend):

❌ regexp_substr__nth_occurrence__ignored_by_legend [Relation]

SQL (Postgres):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 1, 2) AS result FROM strings WHERE id = 10

SQL (Legend, rewritten):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 1, 2) AS result FROM func('e2e::rel_strings') WHERE id = 10

SQL (Generated, executed against DB):

select regexp_substr("root".val, Text'[a-z]+', 1, 1, 'p', 0) as "result" from public.strings as "root" where "root".id = 10

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::StringRow[1]|$x.id,
     val: x: e2e::StringRow[1]|$x.val,
     nullable_val: x: e2e::StringRow[1]|$x.nullableVal,
     unicode_val: x: e2e::StringRow[1]|$x.unicodeVal,
     empty_val: x: e2e::StringRow[1]|$x.emptyVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|$x.id == 10
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|$x.val->meta::pure::functions::multiplicity::toOne()->meta::pure::functions::string::regexpExtract(
    '[a-z]+',
    false
  )->meta::pure::functions::multiplicity::toOne()
   ]
)

Differences:

• Row 0, column 'result': expected 'quick' but got 'the'

Expected (Postgres):

Actual (Legend):

❌ regexp_substr__nth_occurrence_last__ignored_by_legend [TDS]

SQL (Postgres):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 1, 4) AS result FROM strings WHERE id = 10

SQL (Legend, rewritten):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 1, 4) AS result FROM func('e2e::tds_strings') WHERE id = 10

SQL (Generated, executed against DB):

select regexp_substr("root".val, Text'[a-z]+', 1, 1, 'p', 0) as "result" from public.strings as "root" where "root".id = 10

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.val,
      'val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.nullableVal,
      'nullable_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.unicodeVal,
      'unicode_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.emptyVal,
      'empty_val'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 10
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getString('val')->meta::pure::functions::string::regexpExtract(
        '[a-z]+',
        false
      )->meta::pure::functions::multiplicity::toOne(),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected 'fox' but got 'the'

Expected (Postgres):

Actual (Legend):

❌ regexp_substr__nth_occurrence_last__ignored_by_legend [Relation]

SQL (Postgres):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 1, 4) AS result FROM strings WHERE id = 10

SQL (Legend, rewritten):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 1, 4) AS result FROM func('e2e::rel_strings') WHERE id = 10

SQL (Generated, executed against DB):

select regexp_substr("root".val, Text'[a-z]+', 1, 1, 'p', 0) as "result" from public.strings as "root" where "root".id = 10

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::StringRow[1]|$x.id,
     val: x: e2e::StringRow[1]|$x.val,
     nullable_val: x: e2e::StringRow[1]|$x.nullableVal,
     unicode_val: x: e2e::StringRow[1]|$x.unicodeVal,
     empty_val: x: e2e::StringRow[1]|$x.emptyVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|$x.id == 10
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|$x.val->meta::pure::functions::multiplicity::toOne()->meta::pure::functions::string::regexpExtract(
    '[a-z]+',
    false
  )->meta::pure::functions::multiplicity::toOne()
   ]
)

Differences:

• Row 0, column 'result': expected 'fox' but got 'the'

Expected (Postgres):

Actual (Legend):

❌ regexp_substr__start_position__ignored_by_legend [TDS]

SQL (Postgres):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 5) AS result FROM strings WHERE id = 10

SQL (Legend, rewritten):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 5) AS result FROM func('e2e::tds_strings') WHERE id = 10

SQL (Generated, executed against DB):

select regexp_substr("root".val, Text'[a-z]+', 1, 1, 'p', 0) as "result" from public.strings as "root" where "root".id = 10

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.val,
      'val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.nullableVal,
      'nullable_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.unicodeVal,
      'unicode_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.emptyVal,
      'empty_val'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 10
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getString('val')->meta::pure::functions::string::regexpExtract(
        '[a-z]+',
        false
      )->meta::pure::functions::multiplicity::toOne(),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected 'quick' but got 'the'

Expected (Postgres):

Actual (Legend):

❌ regexp_substr__start_position__ignored_by_legend [Relation]

SQL (Postgres):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 5) AS result FROM strings WHERE id = 10

SQL (Legend, rewritten):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 5) AS result FROM func('e2e::rel_strings') WHERE id = 10

SQL (Generated, executed against DB):

select regexp_substr("root".val, Text'[a-z]+', 1, 1, 'p', 0) as "result" from public.strings as "root" where "root".id = 10

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::StringRow[1]|$x.id,
     val: x: e2e::StringRow[1]|$x.val,
     nullable_val: x: e2e::StringRow[1]|$x.nullableVal,
     unicode_val: x: e2e::StringRow[1]|$x.unicodeVal,
     empty_val: x: e2e::StringRow[1]|$x.emptyVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|$x.id == 10
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|$x.val->meta::pure::functions::multiplicity::toOne()->meta::pure::functions::string::regexpExtract(
    '[a-z]+',
    false
  )->meta::pure::functions::multiplicity::toOne()
   ]
)

Differences:

• Row 0, column 'result': expected 'quick' but got 'the'

Expected (Postgres):

Actual (Legend):

❌ regexp_substr__start_and_nth__ignored_by_legend [TDS]

SQL (Postgres):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 5, 2) AS result FROM strings WHERE id = 10

SQL (Legend, rewritten):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 5, 2) AS result FROM func('e2e::tds_strings') WHERE id = 10

SQL (Generated, executed against DB):

select regexp_substr("root".val, Text'[a-z]+', 1, 1, 'p', 0) as "result" from public.strings as "root" where "root".id = 10

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.val,
      'val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.nullableVal,
      'nullable_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.unicodeVal,
      'unicode_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.emptyVal,
      'empty_val'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 10
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getString('val')->meta::pure::functions::string::regexpExtract(
        '[a-z]+',
        false
      )->meta::pure::functions::multiplicity::toOne(),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected 'brown' but got 'the'

Expected (Postgres):

Actual (Legend):

❌ regexp_substr__start_and_nth__ignored_by_legend [Relation]

SQL (Postgres):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 5, 2) AS result FROM strings WHERE id = 10

SQL (Legend, rewritten):

SELECT REGEXP_SUBSTR(val, '[a-z]+', 5, 2) AS result FROM func('e2e::rel_strings') WHERE id = 10

SQL (Generated, executed against DB):

select regexp_substr("root".val, Text'[a-z]+', 1, 1, 'p', 0) as "result" from public.strings as "root" where "root".id = 10

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::StringRow[1]|$x.id,
     val: x: e2e::StringRow[1]|$x.val,
     nullable_val: x: e2e::StringRow[1]|$x.nullableVal,
     unicode_val: x: e2e::StringRow[1]|$x.unicodeVal,
     empty_val: x: e2e::StringRow[1]|$x.emptyVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|$x.id == 10
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|$x.val->meta::pure::functions::multiplicity::toOne()->meta::pure::functions::string::regexpExtract(
    '[a-z]+',
    false
  )->meta::pure::functions::multiplicity::toOne()
   ]
)

Differences:

• Row 0, column 'result': expected 'brown' but got 'the'

Expected (Postgres):

Actual (Legend):

❌ regexp_count__start_position__ignored_by_legend [TDS]

SQL (Postgres):

SELECT REGEXP_COUNT(val, '[a-z]', 5) AS result FROM strings WHERE id = 10

SQL (Legend, rewritten):

SELECT REGEXP_COUNT(val, '[a-z]', 5) AS result FROM func('e2e::tds_strings') WHERE id = 10

SQL (Generated, executed against DB):

select regexp_count("root".val, Text'[a-z]', 1, 'p') as "result" from public.strings as "root" where "root".id = 10

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.val,
      'val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.nullableVal,
      'nullable_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.unicodeVal,
      'unicode_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.emptyVal,
      'empty_val'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 10
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getString('val')->meta::pure::functions::string::regexpCount('[a-z]'),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected '13' but got '16'

Expected (Postgres):

Actual (Legend):

❌ regexp_count__start_position__ignored_by_legend [Relation]

SQL (Postgres):

SELECT REGEXP_COUNT(val, '[a-z]', 5) AS result FROM strings WHERE id = 10

SQL (Legend, rewritten):

SELECT REGEXP_COUNT(val, '[a-z]', 5) AS result FROM func('e2e::rel_strings') WHERE id = 10

SQL (Generated, executed against DB):

select regexp_count("root".val, Text'[a-z]', 1, 'p') as "result" from public.strings as "root" where "root".id = 10

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::StringRow[1]|$x.id,
     val: x: e2e::StringRow[1]|$x.val,
     nullable_val: x: e2e::StringRow[1]|$x.nullableVal,
     unicode_val: x: e2e::StringRow[1]|$x.unicodeVal,
     empty_val: x: e2e::StringRow[1]|$x.emptyVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|$x.id == 10
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|$x.val->meta::pure::functions::multiplicity::toOne()->meta::pure::functions::string::regexpCount('[a-z]')
   ]
)

Differences:

• Row 0, column 'result': expected '13' but got '16'

Expected (Postgres):

Actual (Legend):

❌ string_to_array__txt_txt__from_table [TDS]

SQL (Postgres):

SELECT STRING_TO_ARRAY(val, ' ') AS result FROM strings WHERE val IS NOT NULL ORDER BY 1

SQL (Legend, rewritten):

SELECT STRING_TO_ARRAY(val, ' ') AS result FROM func('e2e::tds_strings') WHERE val IS NOT NULL ORDER BY 1

SQL (Generated, executed against DB):

select string_to_array("root".val, Text' ') as "result" from public.strings as "root" where "root".val is not null order by "result"

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.val,
      'val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.nullableVal,
      'nullable_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.unicodeVal,
      'unicode_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.emptyVal,
      'empty_val'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getString('val')->meta::pure::functions::collection::isNotEmpty()
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getString('val')->meta::pure::functions::string::split(' '),
      'result'
    )
)->meta::pure::tds::sort(
  meta::pure::tds::asc('result')
)

Differences:

• Row 0, column 'result': expected '{}' but got '[]'
• Row 1, column 'result': expected '{"","",spaces,"",""}' but got '["","","spaces","",""]'
• Row 2, column 'result': expected '{MiXeD,CaSe}' but got '["MiXeD","CaSe"]'
• Row 3, column 'result': expected '{UPPERCASE}' but got '["UPPERCASE"]'
• Row 4, column 'result': expected '{WORLD}' but got '["WORLD"]'
• Row 5, column 'result': expected '{abcdefghij}' but got '["abcdefghij"]'
• Row 6, column 'result': expected '{hello}' but got '["hello"]'
• Row 7, column 'result': expected '{repeat}' but got '["repeat"]'
• Row 8, column 'result': expected '{special!@#$%}' but got '["special!@#$%"]'
• Row 9, column 'result': expected '{the,quick,brown,fox}' but got '["the","quick","brown","fox"]'

Expected (Postgres):

Actual (Legend):

❌ string_to_array__txt_txt__from_table [Relation]

SQL (Postgres):

SELECT STRING_TO_ARRAY(val, ' ') AS result FROM strings WHERE val IS NOT NULL ORDER BY 1

SQL (Legend, rewritten):

SELECT STRING_TO_ARRAY(val, ' ') AS result FROM func('e2e::rel_strings') WHERE val IS NOT NULL ORDER BY 1

SQL (Generated, executed against DB):

select string_to_array("root".val, Text' ') as "result" from public.strings as "root" where "root".val is not null order by "result"

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::StringRow[1]|$x.id,
     val: x: e2e::StringRow[1]|$x.val,
     nullable_val: x: e2e::StringRow[1]|$x.nullableVal,
     unicode_val: x: e2e::StringRow[1]|$x.unicodeVal,
     empty_val: x: e2e::StringRow[1]|$x.emptyVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|$x.val->meta::pure::functions::collection::isNotEmpty()
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], val:String, nullable_val:String, unicode_val:String, empty_val:String)[1]|$x.val->meta::pure::functions::multiplicity::toOne()->meta::pure::functions::string::split(' ')
   ]
)->meta::pure::functions::relation::sort(
  ~result->meta::pure::functions::relation::ascending()
)

Differences:

• Row 0, column 'result': expected '{}' but got '[]'
• Row 1, column 'result': expected '{"","",spaces,"",""}' but got '["","","spaces","",""]'
• Row 2, column 'result': expected '{MiXeD,CaSe}' but got '["MiXeD","CaSe"]'
• Row 3, column 'result': expected '{UPPERCASE}' but got '["UPPERCASE"]'
• Row 4, column 'result': expected '{WORLD}' but got '["WORLD"]'
• Row 5, column 'result': expected '{abcdefghij}' but got '["abcdefghij"]'
• Row 6, column 'result': expected '{hello}' but got '["hello"]'
• Row 7, column 'result': expected '{repeat}' but got '["repeat"]'
• Row 8, column 'result': expected '{special!@#$%}' but got '["special!@#$%"]'
• Row 9, column 'result': expected '{the,quick,brown,fox}' but got '["the","quick","brown","fox"]'

Expected (Postgres):

Actual (Legend):

❌ date_literal__fractional_6_digits [TDS]

SQL (Postgres):

SELECT TIMESTAMP '1999-01-08 04:05:06.123456' AS result FROM dates LIMIT 1

SQL (Legend, rewritten):

SELECT TIMESTAMP '1999-01-08 04:05:06.123456' AS result FROM func('e2e::tds_dates') LIMIT 1

SQL (Generated, executed against DB):

select Timestamp'1999-01-08 04:05:06.123456' as "result" from public.dates as "root" limit 1

Lambda (Pure expression):

|e2e::DateRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.d,
      'd'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.ts,
      'ts'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.tsz,
      'tsz'
    )
  ]
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|%1999-01-08T04:05:06.123456+0000,
      'result'
    )
)->meta::pure::tds::limit(1)

Differences:

• Row 0, column 'result': expected '1999-01-08 04:05:06.123456' but got '1999-01-08 04:05:06.123'

Expected (Postgres):

Actual (Legend):

❌ date_literal__fractional_6_digits [Relation]

SQL (Postgres):

SELECT TIMESTAMP '1999-01-08 04:05:06.123456' AS result FROM dates LIMIT 1

SQL (Legend, rewritten):

SELECT TIMESTAMP '1999-01-08 04:05:06.123456' AS result FROM func('e2e::rel_dates') LIMIT 1

SQL (Generated, executed against DB):

select Timestamp'1999-01-08 04:05:06.123456' as "result" from public.dates as "root" limit 1

Lambda (Pure expression):

|e2e::DateRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::DateRow[1]|$x.id,
     d: x: e2e::DateRow[1]|$x.d,
     ts: x: e2e::DateRow[1]|$x.ts,
     tsz: x: e2e::DateRow[1]|$x.tsz
   ]
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], d:StrictDate, ts:DateTime, tsz:DateTime)[1]|%1999-01-08T04:05:06.123456+0000
   ]
)->meta::pure::functions::relation::limit(1)

Differences:

• Row 0, column 'result': expected '1999-01-08 04:05:06.123456' but got '1999-01-08 04:05:06.123'

Expected (Postgres):

Actual (Legend):

❌ date_literal__fractional_9_digits [TDS]

SQL (Postgres):

SELECT TIMESTAMP '1999-01-08 04:05:06.123456789' AS result FROM dates LIMIT 1

SQL (Legend, rewritten):

SELECT TIMESTAMP '1999-01-08 04:05:06.123456789' AS result FROM func('e2e::tds_dates') LIMIT 1

SQL (Generated, executed against DB):

select Timestamp'1999-01-08 04:05:06.123456789' as "result" from public.dates as "root" limit 1

Lambda (Pure expression):

|e2e::DateRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.d,
      'd'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.ts,
      'ts'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.tsz,
      'tsz'
    )
  ]
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|%1999-01-08T04:05:06.123456789+0000,
      'result'
    )
)->meta::pure::tds::limit(1)

Differences:

• Row 0, column 'result': expected '1999-01-08 04:05:06.123457' but got '1999-01-08 04:05:06.123'

Expected (Postgres):

Actual (Legend):

❌ date_literal__fractional_9_digits [Relation]

SQL (Postgres):

SELECT TIMESTAMP '1999-01-08 04:05:06.123456789' AS result FROM dates LIMIT 1

SQL (Legend, rewritten):

SELECT TIMESTAMP '1999-01-08 04:05:06.123456789' AS result FROM func('e2e::rel_dates') LIMIT 1

SQL (Generated, executed against DB):

select Timestamp'1999-01-08 04:05:06.123456789' as "result" from public.dates as "root" limit 1

Lambda (Pure expression):

|e2e::DateRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::DateRow[1]|$x.id,
     d: x: e2e::DateRow[1]|$x.d,
     ts: x: e2e::DateRow[1]|$x.ts,
     tsz: x: e2e::DateRow[1]|$x.tsz
   ]
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], d:StrictDate, ts:DateTime, tsz:DateTime)[1]|%1999-01-08T04:05:06.123456789+0000
   ]
)->meta::pure::functions::relation::limit(1)

Differences:

• Row 0, column 'result': expected '1999-01-08 04:05:06.123457' but got '1999-01-08 04:05:06.123'

Expected (Postgres):

Actual (Legend):

❌ json_extract_path__from_column [Relation]

SQL (Postgres):

SELECT JSON_EXTRACT_PATH(json_val, 'a', 'b', 'c') AS result FROM json_data WHERE id = 2

SQL (Legend, rewritten):

SELECT JSON_EXTRACT_PATH(json_val, 'a', 'b', 'c') AS result FROM func('e2e::rel_json_data') WHERE id = 2

SQL (Generated, executed against DB):

select jsonb_extract_path(cast(jsonb_extract_path(cast(jsonb_extract_path(cast("json_data_0".json_val as jsonb), Text'a') as jsonb), Text'b') as jsonb), Text'c') as "result" from public.json_data as "json_data_0" where "json_data_0".id = 2

Lambda (Pure expression):

|#>{e2e::TestDB.public.json_data}#->meta::pure::functions::relation::filter(
  x: (id:meta::pure::precisePrimitives::Int[1], json_val:meta::pure::metamodel::variant::Variant, jsonb_val:meta::pure::metamodel::variant::Variant, json_arr:meta::pure::metamodel::variant::Variant, jsonb_arr:meta::pure::metamodel::variant::Variant)[1]|$x.id == 2
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:meta::pure::precisePrimitives::Int[1], json_val:meta::pure::metamodel::variant::Variant, jsonb_val:meta::pure::metamodel::variant::Variant, json_arr:meta::pure::metamodel::variant::Variant, jsonb_arr:meta::pure::metamodel::variant::Variant)[1]|$x.json_val->meta::pure::functions::variant::navigation::get('a')->meta::pure::functions::variant::navigation::get('b')->meta::pure::functions::variant::navigation::get('c')
   ]
)

Differences:

• Row 0, column 'result': expected '"nested"' but got '""nested""'

Expected (Postgres):

Actual (Legend):

❌ array_position__anycompatiblearray_anycompatible__from_table [Relation]

SQL (Postgres):

SELECT ARRAY_POSITION(ARRAY[1,2,3], 2) AS result FROM numbers WHERE id = 1

SQL (Legend, rewritten):

SELECT ARRAY_POSITION(ARRAY[1, 2, 3], 2) AS result FROM func('e2e::rel_numbers') WHERE id = 1

SQL (Generated, executed against DB):

select (coalesce((select min(t.o) from jsonb_array_elements(cast(cast(jsonb_build_array(1,2,3) as JSONB) as jsonb)) with ordinality t(v, o) where t.v = to_jsonb(2)), 0) - 1) as "result" from public.numbers as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::NumberRow[1]|$x.id,
     int_val: x: e2e::NumberRow[1]|$x.intVal,
     float_val: x: e2e::NumberRow[1]|$x.floatVal,
     numeric_val: x: e2e::NumberRow[1]|$x.numericVal,
     small_val: x: e2e::NumberRow[1]|$x.smallVal,
     big_val: x: e2e::NumberRow[1]|$x.bigVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id == 1
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|[
    1,
    2,
    3
  ]->meta::pure::functions::collection::indexOf(2)
   ]
)

Differences:

• Row 0, column 'result': expected '2' but got '1'

Expected (Postgres):

Actual (Legend):

❌ op_div__int__truncates_toward_zero [TDS]

SQL (Postgres):

SELECT id, int_val / 5 AS result FROM numbers WHERE id = 9

SQL (Legend, rewritten):

SELECT id, int_val / 5 AS result FROM func('e2e::tds_numbers') WHERE id = 9

SQL (Generated, executed against DB):

select "root".id as "id", ((1.0 * "root".int_val) / 5) as "result" from public.numbers as "root" where "root".id = 9

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.intVal,
      'int_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.floatVal,
      'float_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.numericVal,
      'numeric_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.smallVal,
      'small_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.bigVal,
      'big_val'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 9
)->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getInteger('id'),
      'id'
    ),
    meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getInteger('int_val') / 5,
      'result'
    )
  ]
)

Differences:

• Row 0, column 'result': expected '1' but got '1.4'

Expected (Postgres):

Actual (Legend):

❌ op_div__int__truncates_toward_zero [Relation]

SQL (Postgres):

SELECT id, int_val / 5 AS result FROM numbers WHERE id = 9

SQL (Legend, rewritten):

SELECT id, int_val / 5 AS result FROM func('e2e::rel_numbers') WHERE id = 9

SQL (Generated, executed against DB):

select "root".id as "id", ((1.0 * "root".int_val) / 5) as "result" from public.numbers as "root" where "root".id = 9

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::NumberRow[1]|$x.id,
     int_val: x: e2e::NumberRow[1]|$x.intVal,
     float_val: x: e2e::NumberRow[1]|$x.floatVal,
     numeric_val: x: e2e::NumberRow[1]|$x.numericVal,
     small_val: x: e2e::NumberRow[1]|$x.smallVal,
     big_val: x: e2e::NumberRow[1]|$x.bigVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id == 9
)->meta::pure::functions::relation::project(
  ~[
     id: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id,
     result: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.int_val->meta::pure::functions::multiplicity::toOne() / 5
   ]
)

Differences:

• Row 0, column 'result': expected '1' but got '1.4'

Expected (Postgres):

Actual (Legend):

❌ op_div__negative__truncates_toward_zero [TDS]

SQL (Postgres):

SELECT id, int_val / 3 AS result FROM numbers WHERE id = 2

SQL (Legend, rewritten):

SELECT id, int_val / 3 AS result FROM func('e2e::tds_numbers') WHERE id = 2

SQL (Generated, executed against DB):

select "root".id as "id", ((1.0 * "root".int_val) / 3) as "result" from public.numbers as "root" where "root".id = 2

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.intVal,
      'int_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.floatVal,
      'float_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.numericVal,
      'numeric_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.smallVal,
      'small_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.bigVal,
      'big_val'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 2
)->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getInteger('id'),
      'id'
    ),
    meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getInteger('int_val') / 3,
      'result'
    )
  ]
)

Differences:

• Row 0, column 'result': expected '-3' but got '-3.3333333333333335'

Expected (Postgres):

Actual (Legend):

❌ op_div__negative__truncates_toward_zero [Relation]

SQL (Postgres):

SELECT id, int_val / 3 AS result FROM numbers WHERE id = 2

SQL (Legend, rewritten):

SELECT id, int_val / 3 AS result FROM func('e2e::rel_numbers') WHERE id = 2

SQL (Generated, executed against DB):

select "root".id as "id", ((1.0 * "root".int_val) / 3) as "result" from public.numbers as "root" where "root".id = 2

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::NumberRow[1]|$x.id,
     int_val: x: e2e::NumberRow[1]|$x.intVal,
     float_val: x: e2e::NumberRow[1]|$x.floatVal,
     numeric_val: x: e2e::NumberRow[1]|$x.numericVal,
     small_val: x: e2e::NumberRow[1]|$x.smallVal,
     big_val: x: e2e::NumberRow[1]|$x.bigVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id == 2
)->meta::pure::functions::relation::project(
  ~[
     id: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id,
     result: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.int_val->meta::pure::functions::multiplicity::toOne() / 3
   ]
)

Differences:

• Row 0, column 'result': expected '-3' but got '-3.3333333333333335'

Expected (Postgres):

Actual (Legend):

❌ op_mod__negative__basic [TDS]

SQL (Postgres):

SELECT id, int_val % 3 AS result FROM numbers WHERE id = 2

SQL (Legend, rewritten):

SELECT id, int_val % 3 AS result FROM func('e2e::tds_numbers') WHERE id = 2

SQL (Generated, executed against DB):

select "root".id as "id", mod(mod("root".int_val, 3) + 3, 3) as "result" from public.numbers as "root" where "root".id = 2

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.intVal,
      'int_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.floatVal,
      'float_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.numericVal,
      'numeric_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.smallVal,
      'small_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.bigVal,
      'big_val'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 2
)->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getInteger('id'),
      'id'
    ),
    meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getInteger('int_val')->meta::pure::functions::math::mod(3),
      'result'
    )
  ]
)

Differences:

• Row 0, column 'result': expected '-1' but got '2'

Expected (Postgres):

Actual (Legend):

❌ op_mod__negative__basic [Relation]

SQL (Postgres):

SELECT id, int_val % 3 AS result FROM numbers WHERE id = 2

SQL (Legend, rewritten):

SELECT id, int_val % 3 AS result FROM func('e2e::rel_numbers') WHERE id = 2

SQL (Generated, executed against DB):

select "root".id as "id", mod(mod("root".int_val, 3) + 3, 3) as "result" from public.numbers as "root" where "root".id = 2

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::NumberRow[1]|$x.id,
     int_val: x: e2e::NumberRow[1]|$x.intVal,
     float_val: x: e2e::NumberRow[1]|$x.floatVal,
     numeric_val: x: e2e::NumberRow[1]|$x.numericVal,
     small_val: x: e2e::NumberRow[1]|$x.smallVal,
     big_val: x: e2e::NumberRow[1]|$x.bigVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id == 2
)->meta::pure::functions::relation::project(
  ~[
     id: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id,
     result: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.int_val->meta::pure::functions::multiplicity::toOne()->meta::pure::functions::math::mod(3)
   ]
)

Differences:

• Row 0, column 'result': expected '-1' but got '2'

Expected (Postgres):

Actual (Legend):

❌ op_mod__numeric__basic [TDS]

SQL (Postgres):

SELECT id, numeric_val % 3 AS result FROM numbers WHERE id = 1

SQL (Legend, rewritten):

SELECT id, numeric_val % 3 AS result FROM func('e2e::tds_numbers') WHERE id = 1

SQL (Generated, executed against DB):

select "root".id as "id", mod(mod("root".numeric_val, 3) + 3, 3) as "result" from public.numbers as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.intVal,
      'int_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.floatVal,
      'float_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.numericVal,
      'numeric_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.smallVal,
      'small_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.bigVal,
      'big_val'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getInteger('id'),
      'id'
    ),
    meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getFloat('numeric_val')->meta::pure::functions::math::mod(3),
      'result'
    )
  ]
)

Differences:

• Row 0, column 'result': expected '0.67890' but got '0'

Expected (Postgres):

Actual (Legend):

❌ op_add__date_plus_int_days [TDS]

SQL (Postgres):

SELECT d + 5 AS result FROM dates WHERE id = 1

SQL (Legend, rewritten):

SELECT d + 5 AS result FROM func('e2e::tds_dates') WHERE id = 1

SQL (Generated, executed against DB):

select ("root".d + (INTERVAL '1 DAYS' * 5)) as "result" from public.dates as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::DateRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.d,
      'd'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.ts,
      'ts'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.tsz,
      'tsz'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getStrictDate('d')->meta::pure::functions::date::adjust(
        5,
        meta::pure::functions::date::DurationUnit.DAYS
      ),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected '2023-01-20' but got '2023-01-20 00:00:00.0'

Expected (Postgres):

Actual (Legend):

❌ op_add__date_plus_int_days [Relation]

SQL (Postgres):

SELECT d + 5 AS result FROM dates WHERE id = 1

SQL (Legend, rewritten):

SELECT d + 5 AS result FROM func('e2e::rel_dates') WHERE id = 1

SQL (Generated, executed against DB):

select ("root".d + (INTERVAL '1 DAYS' * 5)) as "result" from public.dates as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::DateRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::DateRow[1]|$x.id,
     d: x: e2e::DateRow[1]|$x.d,
     ts: x: e2e::DateRow[1]|$x.ts,
     tsz: x: e2e::DateRow[1]|$x.tsz
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], d:StrictDate, ts:DateTime, tsz:DateTime)[1]|$x.id == 1
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], d:StrictDate, ts:DateTime, tsz:DateTime)[1]|$x.d->meta::pure::functions::multiplicity::toOne()->meta::pure::functions::date::adjust(
    5,
    meta::pure::functions::date::DurationUnit.DAYS
  )
   ]
)

Differences:

• Row 0, column 'result': expected '2023-01-20' but got '2023-01-20 00:00:00.0'

Expected (Postgres):

Actual (Legend):

❌ op_sub__date_minus_int_days [TDS]

SQL (Postgres):

SELECT d - 5 AS result FROM dates WHERE id = 1

SQL (Legend, rewritten):

SELECT d - 5 AS result FROM func('e2e::tds_dates') WHERE id = 1

SQL (Generated, executed against DB):

select ("root".d + (INTERVAL '1 DAYS' * 5)) as "result" from public.dates as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::DateRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.d,
      'd'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.ts,
      'ts'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.tsz,
      'tsz'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getStrictDate('d')->meta::pure::functions::date::adjust(
        5,
        meta::pure::functions::date::DurationUnit.DAYS
      ),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected '2023-01-10' but got '2023-01-20 00:00:00.0'

Expected (Postgres):

Actual (Legend):

❌ op_sub__date_minus_int_days [Relation]

SQL (Postgres):

SELECT d - 5 AS result FROM dates WHERE id = 1

SQL (Legend, rewritten):

SELECT d - 5 AS result FROM func('e2e::rel_dates') WHERE id = 1

SQL (Generated, executed against DB):

select ("root".d + (INTERVAL '1 DAYS' * 5)) as "result" from public.dates as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::DateRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::DateRow[1]|$x.id,
     d: x: e2e::DateRow[1]|$x.d,
     ts: x: e2e::DateRow[1]|$x.ts,
     tsz: x: e2e::DateRow[1]|$x.tsz
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], d:StrictDate, ts:DateTime, tsz:DateTime)[1]|$x.id == 1
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], d:StrictDate, ts:DateTime, tsz:DateTime)[1]|$x.d->meta::pure::functions::multiplicity::toOne()->meta::pure::functions::date::adjust(
    5,
    meta::pure::functions::date::DurationUnit.DAYS
  )
   ]
)

Differences:

• Row 0, column 'result': expected '2023-01-10' but got '2023-01-20 00:00:00.0'

Expected (Postgres):

Actual (Legend):

❌ concat_op__txt_txt__from_table [TDS]

SQL (Postgres):

SELECT val || '-' || nullable_val AS result FROM strings ORDER BY 1

SQL (Legend, rewritten):

SELECT val || '-' || nullable_val AS result FROM func('e2e::tds_strings') ORDER BY 1

SQL (Generated, executed against DB):

select concat("root".val,'',Text'-','',"root".nullable_val) as "result" from public.strings as "root" order by "result"

Lambda (Pure expression):

|e2e::StringRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.val,
      'val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.nullableVal,
      'nullable_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.unicodeVal,
      'unicode_val'
    ),
    meta::pure::tds::col(
      x: e2e::StringRow[1]|$x.emptyVal,
      'empty_val'
    )
  ]
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getString('val') + '-' + $row.getString('nullable_val'),
      'result'
    )
)->meta::pure::tds::sort(
  meta::pure::tds::asc('result')
)

Differences:

• Row 1, column 'result': expected 'UPPERCASE-lowercase' but got '-'
• Row 2, column 'result': expected 'WORLD-test' but got 'MiXeD CaSe-'
• Row 3, column 'result': expected 'abcdefghij-ABCDEFGHIJ' but got 'UPPERCASE-lowercase'
• Row 4, column 'result': expected 'hello-world' but got 'WORLD-test'
• Row 5, column 'result': expected 'repeat-repeat' but got 'abcdefghij-ABCDEFGHIJ'
• Row 6, column 'result': expected 'special!@#$%-12345' but got 'hello-world'
• Row 7, column 'result': expected 'the quick brown fox-jumps over' but got 'repeat-repeat'
• Row 8, column 'result': expected 'null' but got 'special!@#$%-12345'
• Row 9, column 'result': expected 'null' but got 'the quick brown fox-jumps over'

Expected (Postgres):

Actual (Legend):

❌ concat_op__mixed_types__null_handling [TDS]

SQL (Postgres):

SELECT 'val=' || NULL || '-' || 42 AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT 'val=' || NULL || '-' || 42 AS result FROM func('e2e::tds_persons') WHERE id = 1

SQL (Generated, executed against DB):

select Text'val=-42' as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|'val=' + [] + '-' + meta::pure::functions::string::toString(42),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected 'null' but got 'val=-42'

Expected (Postgres):

Actual (Legend):

❌ eq__null_null [TDS]

SQL (Postgres):

SELECT NULL = NULL AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT NULL = NULL AS result FROM func('e2e::tds_persons') WHERE id = 1

SQL (Generated, executed against DB):

select Boolean'true' as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|[] ==
        [],
      'result'
    )
)

Differences:

• Row 0, column 'result': expected 'null' but got 'true'

Expected (Postgres):

Actual (Legend):

❌ neq__int__null [TDS]

SQL (Postgres):

SELECT id, int_val <> 42 AS result FROM numbers WHERE id = 5

SQL (Legend, rewritten):

SELECT id, int_val <> 42 AS result FROM func('e2e::tds_numbers') WHERE id = 5

SQL (Generated, executed against DB):

select "root".id as "id", "root".int_val is distinct from 42 as "result" from public.numbers as "root" where "root".id = 5

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.intVal,
      'int_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.floatVal,
      'float_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.numericVal,
      'numeric_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.smallVal,
      'small_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.bigVal,
      'big_val'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 5
)->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getInteger('id'),
      'id'
    ),
    meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getInteger('int_val') != 42,
      'result'
    )
  ]
)

Differences:

• Row 0, column 'result': expected 'null' but got 'true'

Expected (Postgres):

Actual (Legend):

❌ neq__int__null [Relation]

SQL (Postgres):

SELECT id, int_val <> 42 AS result FROM numbers WHERE id = 5

SQL (Legend, rewritten):

SELECT id, int_val <> 42 AS result FROM func('e2e::rel_numbers') WHERE id = 5

SQL (Generated, executed against DB):

select "root".id as "id", "root".int_val is distinct from 42 as "result" from public.numbers as "root" where "root".id = 5

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::NumberRow[1]|$x.id,
     int_val: x: e2e::NumberRow[1]|$x.intVal,
     float_val: x: e2e::NumberRow[1]|$x.floatVal,
     numeric_val: x: e2e::NumberRow[1]|$x.numericVal,
     small_val: x: e2e::NumberRow[1]|$x.smallVal,
     big_val: x: e2e::NumberRow[1]|$x.bigVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id == 5
)->meta::pure::functions::relation::project(
  ~[
     id: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id,
     result: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.int_val != 42
   ]
)

Differences:

• Row 0, column 'result': expected 'null' but got 'true'

Expected (Postgres):

Actual (Legend):

❌ lt__int__null [Relation]

SQL (Postgres):

SELECT id, int_val < 100 AS result FROM numbers WHERE id = 5

SQL (Legend, rewritten):

SELECT id, int_val < 100 AS result FROM func('e2e::rel_numbers') WHERE id = 5

SQL (Generated, executed against DB):

select "root".id as "id", ("root".int_val is not null and "root".int_val < 100) as "result" from public.numbers as "root" where "root".id = 5

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::NumberRow[1]|$x.id,
     int_val: x: e2e::NumberRow[1]|$x.intVal,
     float_val: x: e2e::NumberRow[1]|$x.floatVal,
     numeric_val: x: e2e::NumberRow[1]|$x.numericVal,
     small_val: x: e2e::NumberRow[1]|$x.smallVal,
     big_val: x: e2e::NumberRow[1]|$x.bigVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id == 5
)->meta::pure::functions::relation::project(
  ~[
     id: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id,
     result: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.int_val < 100
   ]
)

Differences:

• Row 0, column 'result': expected 'null' but got 'false'

Expected (Postgres):

Actual (Legend):

❌ gt__int__null [Relation]

SQL (Postgres):

SELECT id, int_val > 10 AS result FROM numbers WHERE id = 5

SQL (Legend, rewritten):

SELECT id, int_val > 10 AS result FROM func('e2e::rel_numbers') WHERE id = 5

SQL (Generated, executed against DB):

select "root".id as "id", ("root".int_val is not null and "root".int_val > 10) as "result" from public.numbers as "root" where "root".id = 5

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::NumberRow[1]|$x.id,
     int_val: x: e2e::NumberRow[1]|$x.intVal,
     float_val: x: e2e::NumberRow[1]|$x.floatVal,
     numeric_val: x: e2e::NumberRow[1]|$x.numericVal,
     small_val: x: e2e::NumberRow[1]|$x.smallVal,
     big_val: x: e2e::NumberRow[1]|$x.bigVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id == 5
)->meta::pure::functions::relation::project(
  ~[
     id: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id,
     result: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.int_val > 10
   ]
)

Differences:

• Row 0, column 'result': expected 'null' but got 'false'

Expected (Postgres):

Actual (Legend):

❌ neq__filter__int [TDS]

SQL (Postgres):

SELECT id, name FROM persons WHERE age <> 30 ORDER BY id

SQL (Legend, rewritten):

SELECT id, name FROM func('e2e::tds_persons') WHERE age <> 30 ORDER BY id

SQL (Generated, executed against DB):

select "root".id as "id", "root".name as "name" from public.persons as "root" where "root".age is distinct from 30 order by "id"

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('age') != 30
)->meta::pure::tds::restrict(
  [
    'id',
    'name'
  ]
)->meta::pure::tds::sort(
  meta::pure::tds::asc('id')
)

Differences:

• Row count mismatch: expected 8 but got 9

Expected (Postgres):

Actual (Legend):

❌ neq__filter__int [Relation]

SQL (Postgres):

SELECT id, name FROM persons WHERE age <> 30 ORDER BY id

SQL (Legend, rewritten):

SELECT id, name FROM func('e2e::rel_persons') WHERE age <> 30 ORDER BY id

SQL (Generated, executed against DB):

select "root".id as "id", "root".name as "name" from public.persons as "root" where "root".age is distinct from 30 order by "id"

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::Person[1]|$x.id,
     name: x: e2e::Person[1]|$x.name,
     age: x: e2e::Person[1]|$x.age,
     salary: x: e2e::Person[1]|$x.salary,
     hire_date: x: e2e::Person[1]|$x.hireDate,
     active: x: e2e::Person[1]|$x.active,
     dept_id: x: e2e::Person[1]|$x.deptId
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|$x.age != 30
)->meta::pure::functions::relation::select(
  ~[
     id,
     name
   ]
)->meta::pure::functions::relation::sort(
  ~id->meta::pure::functions::relation::ascending()
)

Differences:

• Row count mismatch: expected 8 but got 9

Expected (Postgres):

Actual (Legend):

❌ and__false_null [TDS]

SQL (Postgres):

SELECT (false AND CAST(NULL AS BOOLEAN)) AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT (false AND CAST(NULL AS BOOLEAN)) AS result FROM func('e2e::tds_persons') WHERE id = 1

SQL (Generated, executed against DB):

select null as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|[]->meta::pure::functions::lang::cast(@Boolean),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected 'false' but got 'null'

Expected (Postgres):

Actual (Legend):

❌ and__false_null [Relation]

SQL (Postgres):

SELECT (false AND CAST(NULL AS BOOLEAN)) AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT (false AND CAST(NULL AS BOOLEAN)) AS result FROM func('e2e::rel_persons') WHERE id = 1

SQL (Generated, executed against DB):

select null as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::Person[1]|$x.id,
     name: x: e2e::Person[1]|$x.name,
     age: x: e2e::Person[1]|$x.age,
     salary: x: e2e::Person[1]|$x.salary,
     hire_date: x: e2e::Person[1]|$x.hireDate,
     active: x: e2e::Person[1]|$x.active,
     dept_id: x: e2e::Person[1]|$x.deptId
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|$x.id == 1
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|[]->meta::pure::functions::lang::cast(@Boolean)
   ]
)

Differences:

• Row 0, column 'result': expected 'false' but got 'null'

Expected (Postgres):

Actual (Legend):

❌ or__true_null [TDS]

SQL (Postgres):

SELECT (true OR CAST(NULL AS BOOLEAN)) AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT (true OR CAST(NULL AS BOOLEAN)) AS result FROM func('e2e::tds_persons') WHERE id = 1

SQL (Generated, executed against DB):

select null as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|[]->meta::pure::functions::lang::cast(@Boolean),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected 'true' but got 'null'

Expected (Postgres):

Actual (Legend):

❌ or__true_null [Relation]

SQL (Postgres):

SELECT (true OR CAST(NULL AS BOOLEAN)) AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT (true OR CAST(NULL AS BOOLEAN)) AS result FROM func('e2e::rel_persons') WHERE id = 1

SQL (Generated, executed against DB):

select null as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::Person[1]|$x.id,
     name: x: e2e::Person[1]|$x.name,
     age: x: e2e::Person[1]|$x.age,
     salary: x: e2e::Person[1]|$x.salary,
     hire_date: x: e2e::Person[1]|$x.hireDate,
     active: x: e2e::Person[1]|$x.active,
     dept_id: x: e2e::Person[1]|$x.deptId
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|$x.id == 1
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|[]->meta::pure::functions::lang::cast(@Boolean)
   ]
)

Differences:

• Row 0, column 'result': expected 'true' but got 'null'

Expected (Postgres):

Actual (Legend):

❌ json_arrow_get_field [Relation]

SQL (Postgres):

SELECT json_val -> 'a' AS result FROM json_data WHERE id = 1

SQL (Legend, rewritten):

SELECT json_val -> 'a' AS result FROM func('e2e::rel_json_data') WHERE id = 1

SQL (Generated, executed against DB):

select jsonb_extract_path(cast("json_data_0".json_val as jsonb), Text'a') as "result" from public.json_data as "json_data_0" where "json_data_0".id = 1

Lambda (Pure expression):

|#>{e2e::TestDB.public.json_data}#->meta::pure::functions::relation::filter(
  x: (id:meta::pure::precisePrimitives::Int[1], json_val:meta::pure::metamodel::variant::Variant, jsonb_val:meta::pure::metamodel::variant::Variant, json_arr:meta::pure::metamodel::variant::Variant, jsonb_arr:meta::pure::metamodel::variant::Variant)[1]|$x.id == 1
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:meta::pure::precisePrimitives::Int[1], json_val:meta::pure::metamodel::variant::Variant, jsonb_val:meta::pure::metamodel::variant::Variant, json_arr:meta::pure::metamodel::variant::Variant, jsonb_arr:meta::pure::metamodel::variant::Variant)[1]|$x.json_val->meta::pure::functions::variant::navigation::get('a')
   ]
)

Differences:

• Row 0, column 'result': expected '1' but got '"1"'

Expected (Postgres):

Actual (Legend):

❌ jsonb_arrow_get_field [Relation]

SQL (Postgres):

SELECT jsonb_val -> 'b' AS result FROM json_data WHERE id = 1

SQL (Legend, rewritten):

SELECT jsonb_val -> 'b' AS result FROM func('e2e::rel_json_data') WHERE id = 1

SQL (Generated, executed against DB):

select jsonb_extract_path(cast("json_data_0".jsonb_val as jsonb), Text'b') as "result" from public.json_data as "json_data_0" where "json_data_0".id = 1

Lambda (Pure expression):

|#>{e2e::TestDB.public.json_data}#->meta::pure::functions::relation::filter(
  x: (id:meta::pure::precisePrimitives::Int[1], json_val:meta::pure::metamodel::variant::Variant, jsonb_val:meta::pure::metamodel::variant::Variant, json_arr:meta::pure::metamodel::variant::Variant, jsonb_arr:meta::pure::metamodel::variant::Variant)[1]|$x.id == 1
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:meta::pure::precisePrimitives::Int[1], json_val:meta::pure::metamodel::variant::Variant, jsonb_val:meta::pure::metamodel::variant::Variant, json_arr:meta::pure::metamodel::variant::Variant, jsonb_arr:meta::pure::metamodel::variant::Variant)[1]|$x.jsonb_val->meta::pure::functions::variant::navigation::get('b')
   ]
)

Differences:

• Row 0, column 'result': expected '"hello"' but got '""hello""'

Expected (Postgres):

Actual (Legend):

❌ json_arrow_get_index [Relation]

SQL (Postgres):

SELECT json_arr -> 0 AS result FROM json_data WHERE id = 1

SQL (Legend, rewritten):

SELECT json_arr -> 0 AS result FROM func('e2e::rel_json_data') WHERE id = 1

SQL (Generated, executed against DB):

select (cast("json_data_0".json_arr as jsonb)->0) as "result" from public.json_data as "json_data_0" where "json_data_0".id = 1

Lambda (Pure expression):

|#>{e2e::TestDB.public.json_data}#->meta::pure::functions::relation::filter(
  x: (id:meta::pure::precisePrimitives::Int[1], json_val:meta::pure::metamodel::variant::Variant, jsonb_val:meta::pure::metamodel::variant::Variant, json_arr:meta::pure::metamodel::variant::Variant, jsonb_arr:meta::pure::metamodel::variant::Variant)[1]|$x.id == 1
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:meta::pure::precisePrimitives::Int[1], json_val:meta::pure::metamodel::variant::Variant, jsonb_val:meta::pure::metamodel::variant::Variant, json_arr:meta::pure::metamodel::variant::Variant, jsonb_arr:meta::pure::metamodel::variant::Variant)[1]|$x.json_arr->meta::pure::functions::variant::navigation::get(0)
   ]
)

Differences:

• Row 0, column 'result': expected '1' but got '"1"'

Expected (Postgres):

Actual (Legend):

❌ jsonb_arrow_get_index [Relation]

SQL (Postgres):

SELECT jsonb_arr -> 1 AS result FROM json_data WHERE id = 1

SQL (Legend, rewritten):

SELECT jsonb_arr -> 1 AS result FROM func('e2e::rel_json_data') WHERE id = 1

SQL (Generated, executed against DB):

select (cast("json_data_0".jsonb_arr as jsonb)->1) as "result" from public.json_data as "json_data_0" where "json_data_0".id = 1

Lambda (Pure expression):

|#>{e2e::TestDB.public.json_data}#->meta::pure::functions::relation::filter(
  x: (id:meta::pure::precisePrimitives::Int[1], json_val:meta::pure::metamodel::variant::Variant, jsonb_val:meta::pure::metamodel::variant::Variant, json_arr:meta::pure::metamodel::variant::Variant, jsonb_arr:meta::pure::metamodel::variant::Variant)[1]|$x.id == 1
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:meta::pure::precisePrimitives::Int[1], json_val:meta::pure::metamodel::variant::Variant, jsonb_val:meta::pure::metamodel::variant::Variant, json_arr:meta::pure::metamodel::variant::Variant, jsonb_arr:meta::pure::metamodel::variant::Variant)[1]|$x.jsonb_arr->meta::pure::functions::variant::navigation::get(1)
   ]
)

Differences:

• Row 0, column 'result': expected '2' but got '"2"'

Expected (Postgres):

Actual (Legend):

❌ array_gt [TDS]

SQL (Postgres):

SELECT ARRAY[1,3] > ARRAY[1,2] AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT ARRAY[1, 3] > ARRAY[1, 2] AS result FROM func('e2e::tds_persons') WHERE id = 1

SQL (Generated, executed against DB):

select Boolean'false' as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|[
        1,
        3
      ] >
        [
        1,
        2
      ],
      'result'
    )
)

Differences:

• Row 0, column 'result': expected 'true' but got 'false'

Expected (Postgres):

Actual (Legend):

❌ anycompatible_concat_scalar_array [TDS]

SQL (Postgres):

SELECT 4 || ARRAY[1,2,3] AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT 4 || ARRAY[1, 2, 3] AS result FROM func('e2e::tds_persons') WHERE id = 1

SQL (Generated, executed against DB):

select Text'41' as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|meta::pure::functions::string::toString(4) + [
        1,
        2,
        3
      ]->meta::pure::functions::string::toString(),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected '{4,1,2,3}' but got '41'

Expected (Postgres):

Actual (Legend):

❌ anycompatible_concat_array_scalar [TDS]

SQL (Postgres):

SELECT ARRAY[1,2,3] || 4 AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT ARRAY[1, 2, 3] || 4 AS result FROM func('e2e::tds_persons') WHERE id = 1

SQL (Generated, executed against DB):

select Text'14' as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|[
        1,
        2,
        3
      ]->meta::pure::functions::string::toString() + meta::pure::functions::string::toString(4),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected '{1,2,3,4}' but got '14'

Expected (Postgres):

Actual (Legend):

❌ anycompatible_concat_array_array [TDS]

SQL (Postgres):

SELECT ARRAY[1,2] || ARRAY[3,4] AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT ARRAY[1, 2] || ARRAY[3, 4] AS result FROM func('e2e::tds_persons') WHERE id = 1

SQL (Generated, executed against DB):

select Text'13' as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|[
        1,
        2
      ]->meta::pure::functions::string::toString() + [
        3,
        4
      ]->meta::pure::functions::string::toString(),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected '{1,2,3,4}' but got '13'

Expected (Postgres):

Actual (Legend):

❌ between__int__null [TDS]

SQL (Postgres):

SELECT id, int_val BETWEEN 0 AND 100 AS result FROM numbers WHERE id = 5

SQL (Legend, rewritten):

SELECT id, int_val BETWEEN 0 AND 100 AS result FROM func('e2e::tds_numbers') WHERE id = 5

SQL (Generated, executed against DB):

select "root".id as "id", (("root".int_val is not null and "root".int_val >= 0) and ("root".int_val is not null and "root".int_val <= 100)) as "result" from public.numbers as "root" where "root".id = 5

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.intVal,
      'int_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.floatVal,
      'float_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.numericVal,
      'numeric_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.smallVal,
      'small_val'
    ),
    meta::pure::tds::col(
      x: e2e::NumberRow[1]|$x.bigVal,
      'big_val'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 5
)->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getInteger('id'),
      'id'
    ),
    meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getInteger('int_val')->meta::pure::functions::boolean::between(
        0,
        100
      ),
      'result'
    )
  ]
)

Differences:

• Row 0, column 'result': expected 'null' but got 'false'

Expected (Postgres):

Actual (Legend):

❌ between__int__null [Relation]

SQL (Postgres):

SELECT id, int_val BETWEEN 0 AND 100 AS result FROM numbers WHERE id = 5

SQL (Legend, rewritten):

SELECT id, int_val BETWEEN 0 AND 100 AS result FROM func('e2e::rel_numbers') WHERE id = 5

SQL (Generated, executed against DB):

select "root".id as "id", ((("root".int_val is not null and 0 is not null) and "root".int_val >= 0) and (("root".int_val is not null and 100 is not null) and "root".int_val <= 100)) as "result" from public.numbers as "root" where "root".id = 5

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::NumberRow[1]|$x.id,
     int_val: x: e2e::NumberRow[1]|$x.intVal,
     float_val: x: e2e::NumberRow[1]|$x.floatVal,
     numeric_val: x: e2e::NumberRow[1]|$x.numericVal,
     small_val: x: e2e::NumberRow[1]|$x.smallVal,
     big_val: x: e2e::NumberRow[1]|$x.bigVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id == 5
)->meta::pure::functions::relation::project(
  ~[
     id: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id,
     result: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.int_val->meta::pure::functions::boolean::between(
    0,
    100
  )
   ]
)

Differences:

• Row 0, column 'result': expected 'null' but got 'false'

Expected (Postgres):

Actual (Legend):

❌ is_distinct_from__int__one_null [Relation]

SQL (Postgres):

SELECT id, int_val IS DISTINCT FROM 42 AS result FROM numbers WHERE id = 5

SQL (Legend, rewritten):

SELECT id, int_val IS DISTINCT FROM 42 AS result FROM func('e2e::rel_numbers') WHERE id = 5

SQL (Generated, executed against DB):

select "root".id as "id", not (("root".int_val is null and 42 is null) or "root".int_val = 42) as "result" from public.numbers as "root" where "root".id = 5

Lambda (Pure expression):

|e2e::NumberRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::NumberRow[1]|$x.id,
     int_val: x: e2e::NumberRow[1]|$x.intVal,
     float_val: x: e2e::NumberRow[1]|$x.floatVal,
     numeric_val: x: e2e::NumberRow[1]|$x.numericVal,
     small_val: x: e2e::NumberRow[1]|$x.smallVal,
     big_val: x: e2e::NumberRow[1]|$x.bigVal
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id == 5
)->meta::pure::functions::relation::project(
  ~[
     id: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|$x.id,
     result: x: (id:Integer[1], int_val:Integer, float_val:Float, numeric_val:Float, small_val:Integer, big_val:Integer)[1]|!(($x.int_val->meta::pure::functions::collection::isEmpty() &&
    meta::pure::functions::collection::isEmpty(42)) ||
    ($x.int_val == 42))
   ]
)

Differences:

• Row 0, column 'result': expected 'true' but got 'null'

Expected (Postgres):

Actual (Legend):

❌ to_char_token__FF1 [TDS]

SQL (Postgres):

SELECT to_char(TIMESTAMP '2024-06-15 13:45:22.123456', 'FF1') AS result

Differences:

• Row 0, column 'result': expected '1' but got 'FF1'

Expected (Postgres):

Actual (Legend):

❌ to_char_token__FF1 [Relation]

SQL (Postgres):

SELECT to_char(TIMESTAMP '2024-06-15 13:45:22.123456', 'FF1') AS result

Differences:

• Row 0, column 'result': expected '1' but got 'FF1'

Expected (Postgres):

Actual (Legend):

❌ to_char_token__FF6 [TDS]

SQL (Postgres):

SELECT to_char(TIMESTAMP '2024-06-15 13:45:22.123456', 'FF6') AS result

Differences:

• Row 0, column 'result': expected '123456' but got 'FF6'

Expected (Postgres):

Actual (Legend):

❌ to_char_token__FF6 [Relation]

SQL (Postgres):

SELECT to_char(TIMESTAMP '2024-06-15 13:45:22.123456', 'FF6') AS result

Differences:

• Row 0, column 'result': expected '123456' but got 'FF6'

Expected (Postgres):

Actual (Legend):

❌ to_char_token__TZH [TDS]

SQL (Postgres):

SELECT to_char(TIMESTAMPTZ '2024-06-15 13:45:22+02', 'TZH') AS result

Differences:

• Row 0, column 'result': expected '+00' but got 'GMTH'

Expected (Postgres):

Actual (Legend):

❌ to_char_token__TZH [Relation]

SQL (Postgres):

SELECT to_char(TIMESTAMPTZ '2024-06-15 13:45:22+02', 'TZH') AS result

Differences:

• Row 0, column 'result': expected '+00' but got 'GMTH'

Expected (Postgres):

Actual (Legend):

❌ to_char_token__TZM [TDS]

SQL (Postgres):

SELECT to_char(TIMESTAMPTZ '2024-06-15 13:45:22+02', 'TZM') AS result

Differences:

• Row 0, column 'result': expected '00' but got 'GMTM'

Expected (Postgres):

Actual (Legend):

❌ to_char_token__TZM [Relation]

SQL (Postgres):

SELECT to_char(TIMESTAMPTZ '2024-06-15 13:45:22+02', 'TZM') AS result

Differences:

• Row 0, column 'result': expected '00' but got 'GMTM'

Expected (Postgres):

Actual (Legend):

❌ subquery_quant_all_empty_null_value [Relation]

SQL (Postgres):

SELECT p.name FROM persons p WHERE p.age > ALL (SELECT p2.age FROM persons p2 WHERE p2.id > 100) ORDER BY 1

SQL (Legend, rewritten):

SELECT p.name FROM func('e2e::rel_persons') p WHERE p.age > ALL(SELECT p2.age FROM func('e2e::rel_persons') p2 WHERE p2.id > 100) ORDER BY 1

SQL (Generated, executed against DB):

select "root".name as "name" from public.persons as "root" where (("root".age is not null and "root".age > all (select "persons_1".age as "age" from public.persons as "persons_1" where "persons_1".age is not null and "persons_1".id > 100)) and not exists(select 1 from public.persons as "persons_2" where "persons_2".id > 100 and "persons_2".age is null)) order by "name"

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::Person[1]|$x.id,
     name: x: e2e::Person[1]|$x.name,
     age: x: e2e::Person[1]|$x.age,
     salary: x: e2e::Person[1]|$x.salary,
     hire_date: x: e2e::Person[1]|$x.hireDate,
     active: x: e2e::Person[1]|$x.active,
     dept_id: x: e2e::Person[1]|$x.deptId
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|$x.age->meta::pure::functions::relation::greaterThanAll(
    e2e::Person.all()->meta::pure::functions::relation::project(
      ~[
         id: x: e2e::Person[1]|$x.id,
         name: x: e2e::Person[1]|$x.name,
         age: x: e2e::Person[1]|$x.age,
         salary: x: e2e::Person[1]|$x.salary,
         hire_date: x: e2e::Person[1]|$x.hireDate,
         active: x: e2e::Person[1]|$x.active,
         dept_id: x: e2e::Person[1]|$x.deptId
       ]
    )->meta::pure::functions::relation::filter(
      e: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|$e.id > 100
    )->meta::pure::functions::relation::select(
      ~[
         age
       ]
    )
  ) &&
    !e2e::Person.all()->meta::pure::functions::relation::project(
    ~[
       id: x: e2e::Person[1]|$x.id,
       name: x: e2e::Person[1]|$x.name,
       age: x: e2e::Person[1]|$x.age,
       salary: x: e2e::Person[1]|$x.salary,
       hire_date: x: e2e::Person[1]|$x.hireDate,
       active: x: e2e::Person[1]|$x.active,
       dept_id: x: e2e::Person[1]|$x.deptId
     ]
  )->meta::pure::functions::relation::filter(
    e: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|$e.id > 100
  )->meta::pure::functions::relation::select(
    ~[
       age
     ]
  )->meta::pure::functions::relation::exists(
    e: (age:Integer)[1]|$e.age->meta::pure::functions::collection::isEmpty()
  )
)->meta::pure::functions::relation::select(
  ~[
     name
   ]
)->meta::pure::functions::relation::sort(
  ~name->meta::pure::functions::relation::ascending()
)

Differences:

• Row count mismatch: expected 10 but got 9

Expected (Postgres):

Actual (Legend):

❌ null_equals_null [TDS]

SQL (Postgres):

SELECT (NULL = NULL) AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT (NULL = NULL) AS result FROM func('e2e::tds_persons') WHERE id = 1

SQL (Generated, executed against DB):

select Boolean'true' as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|[] ==
        [],
      'result'
    )
)

Differences:

• Row 0, column 'result': expected 'null' but got 'true'

Expected (Postgres):

Actual (Legend):

❌ null_not_equals [TDS]

SQL (Postgres):

SELECT (NULL <> 1) AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT (NULL <> 1) AS result FROM func('e2e::tds_persons') WHERE id = 1

SQL (Generated, executed against DB):

select Boolean'true' as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|[] != 1,
      'result'
    )
)

Differences:

• Row 0, column 'result': expected 'null' but got 'true'

Expected (Postgres):

Actual (Legend):

❌ null_concat [TDS]

SQL (Postgres):

SELECT name || ' age=' || CAST(age AS TEXT) AS result FROM persons ORDER BY 1

SQL (Legend, rewritten):

SELECT name || ' age=' || CAST(age AS TEXT) AS result FROM func('e2e::tds_persons') ORDER BY 1

SQL (Generated, executed against DB):

select concat("root".name,'',Text' age=','',cast("root".age as varchar)) as "result" from public.persons as "root" order by "result"

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getString('name') + ' age=' + $row.getInteger('age')->meta::pure::functions::string::toString(),
      'result'
    )
)->meta::pure::tds::sort(
  meta::pure::tds::asc('result')
)

Differences:

• Row 6, column 'result': expected 'Hank age=50' but got 'Grace age='
• Row 7, column 'result': expected 'Ivy age=22' but got 'Hank age=50'
• Row 8, column 'result': expected 'Jack age=38' but got 'Ivy age=22'
• Row 9, column 'result': expected 'null' but got 'Jack age=38'

Expected (Postgres):

Actual (Legend):

❌ null_concat [Relation]

SQL (Postgres):

SELECT name || ' age=' || CAST(age AS TEXT) AS result FROM persons ORDER BY 1

SQL (Legend, rewritten):

SELECT name || ' age=' || CAST(age AS TEXT) AS result FROM func('e2e::rel_persons') ORDER BY 1

SQL (Generated, executed against DB):

select case when "root".name is null then null else concat("root".name, Text' age=', cast("root".age as varchar)) end as "result" from public.persons as "root" order by "result"

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::Person[1]|$x.id,
     name: x: e2e::Person[1]|$x.name,
     age: x: e2e::Person[1]|$x.age,
     salary: x: e2e::Person[1]|$x.salary,
     hire_date: x: e2e::Person[1]|$x.hireDate,
     active: x: e2e::Person[1]|$x.active,
     dept_id: x: e2e::Person[1]|$x.deptId
   ]
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|if(
    $x.name->meta::pure::functions::collection::isEmpty(),
    |[],
    |$x.name->meta::pure::functions::multiplicity::toOne() + ' age=' + $x.age->meta::pure::functions::multiplicity::toOne()->meta::pure::functions::string::toString()
  )
   ]
)->meta::pure::functions::relation::sort(
  ~result->meta::pure::functions::relation::ascending()
)

Differences:

• Row 6, column 'result': expected 'Hank age=50' but got 'Grace age='
• Row 7, column 'result': expected 'Ivy age=22' but got 'Hank age=50'
• Row 8, column 'result': expected 'Jack age=38' but got 'Ivy age=22'
• Row 9, column 'result': expected 'null' but got 'Jack age=38'

Expected (Postgres):

Actual (Legend):

❌ where_not_between [TDS]

SQL (Postgres):

SELECT name, salary FROM persons WHERE salary NOT BETWEEN 40000 AND 60000 ORDER BY 1

SQL (Legend, rewritten):

SELECT name, salary FROM func('e2e::tds_persons') WHERE salary NOT BETWEEN 40000 AND 60000 ORDER BY 1

SQL (Generated, executed against DB):

select "root".name as "name", "root".salary as "salary" from public.persons as "root" where not (("root".salary is not null and "root".salary >= 40000) and ("root".salary is not null and "root".salary <= 60000)) order by "name"

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|!$row.getFloat('salary')->meta::pure::functions::boolean::between(
    40000,
    60000
  )
)->meta::pure::tds::restrict(
  [
    'name',
    'salary'
  ]
)->meta::pure::tds::sort(
  meta::pure::tds::asc('name')
)

Differences:

• Row count mismatch: expected 6 but got 7

Expected (Postgres):

Actual (Legend):

❌ where_not_between [Relation]

SQL (Postgres):

SELECT name, salary FROM persons WHERE salary NOT BETWEEN 40000 AND 60000 ORDER BY 1

SQL (Legend, rewritten):

SELECT name, salary FROM func('e2e::rel_persons') WHERE salary NOT BETWEEN 40000 AND 60000 ORDER BY 1

SQL (Generated, executed against DB):

select "root".name as "name", "root".salary as "salary" from public.persons as "root" where not (("root".salary is not null and "root".salary >= 40000) and ("root".salary is not null and "root".salary <= 60000)) order by "name"

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::Person[1]|$x.id,
     name: x: e2e::Person[1]|$x.name,
     age: x: e2e::Person[1]|$x.age,
     salary: x: e2e::Person[1]|$x.salary,
     hire_date: x: e2e::Person[1]|$x.hireDate,
     active: x: e2e::Person[1]|$x.active,
     dept_id: x: e2e::Person[1]|$x.deptId
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|!$x.salary->meta::pure::functions::boolean::between(
    40000,
    60000
  )
)->meta::pure::functions::relation::select(
  ~[
     name,
     salary
   ]
)->meta::pure::functions::relation::sort(
  ~name->meta::pure::functions::relation::ascending()
)

Differences:

• Row count mismatch: expected 6 but got 7

Expected (Postgres):

Actual (Legend):

❌ where_not_in_list [TDS]

SQL (Postgres):

SELECT name, dept_id FROM persons WHERE dept_id NOT IN (1, 2) ORDER BY 1

SQL (Legend, rewritten):

SELECT name, dept_id FROM func('e2e::tds_persons') WHERE dept_id NOT IN (1, 2) ORDER BY 1

SQL (Generated, executed against DB):

select "root".name as "name", "root".dept_id as "dept_id" from public.persons as "root" where ("root".dept_id not in (1, 2) OR "root".dept_id is null) order by "name"

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|!$row.getInteger('dept_id')->meta::pure::functions::collection::in(
    [
      1,
      2
    ]
  )
)->meta::pure::tds::restrict(
  [
    'name',
    'dept_id'
  ]
)->meta::pure::tds::sort(
  meta::pure::tds::asc('name')
)

Differences:

• Row count mismatch: expected 3 but got 4

Expected (Postgres):

Actual (Legend):

❌ where_not_in_list [Relation]

SQL (Postgres):

SELECT name, dept_id FROM persons WHERE dept_id NOT IN (1, 2) ORDER BY 1

SQL (Legend, rewritten):

SELECT name, dept_id FROM func('e2e::rel_persons') WHERE dept_id NOT IN (1, 2) ORDER BY 1

SQL (Generated, executed against DB):

select "root".name as "name", "root".dept_id as "dept_id" from public.persons as "root" where ("root".dept_id not in (1, 2) OR "root".dept_id is null) order by "name"

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::Person[1]|$x.id,
     name: x: e2e::Person[1]|$x.name,
     age: x: e2e::Person[1]|$x.age,
     salary: x: e2e::Person[1]|$x.salary,
     hire_date: x: e2e::Person[1]|$x.hireDate,
     active: x: e2e::Person[1]|$x.active,
     dept_id: x: e2e::Person[1]|$x.deptId
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|!$x.dept_id->meta::pure::functions::multiplicity::toOne()->meta::pure::functions::collection::in(
    [
      1,
      2
    ]
  )
)->meta::pure::functions::relation::select(
  ~[
     name,
     dept_id
   ]
)->meta::pure::functions::relation::sort(
  ~name->meta::pure::functions::relation::ascending()
)

Differences:

• Row count mismatch: expected 3 but got 4

Expected (Postgres):

Actual (Legend):

❌ where_not_compound [Relation]

SQL (Postgres):

SELECT name FROM persons WHERE NOT (dept_id = 1 AND salary > 50000) ORDER BY 1

SQL (Legend, rewritten):

SELECT name FROM func('e2e::rel_persons') WHERE NOT (dept_id = 1 AND salary > 50000) ORDER BY 1

SQL (Generated, executed against DB):

select "root".name as "name" from public.persons as "root" where not ("root".dept_id = 1 and ("root".salary is not null and "root".salary > 50000)) order by "name"

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::Person[1]|$x.id,
     name: x: e2e::Person[1]|$x.name,
     age: x: e2e::Person[1]|$x.age,
     salary: x: e2e::Person[1]|$x.salary,
     hire_date: x: e2e::Person[1]|$x.hireDate,
     active: x: e2e::Person[1]|$x.active,
     dept_id: x: e2e::Person[1]|$x.deptId
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|!(($x.dept_id == 1) &&
    ($x.salary > 50000))
)->meta::pure::functions::relation::select(
  ~[
     name
   ]
)->meta::pure::functions::relation::sort(
  ~name->meta::pure::functions::relation::ascending()
)

Differences:

• Row count mismatch: expected 7 but got 8

Expected (Postgres):

Actual (Legend):

❌ bool_null_and_false [TDS]

SQL (Postgres):

SELECT (NULL AND FALSE) AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT (NULL AND FALSE) AS result FROM func('e2e::tds_persons') WHERE id = 1

SQL (Generated, executed against DB):

select null as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|[]->meta::pure::functions::lang::cast(@Boolean),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected 'false' but got 'null'

Expected (Postgres):

Actual (Legend):

❌ bool_null_and_false [Relation]

SQL (Postgres):

SELECT (NULL AND FALSE) AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT (NULL AND FALSE) AS result FROM func('e2e::rel_persons') WHERE id = 1

SQL (Generated, executed against DB):

select null as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::Person[1]|$x.id,
     name: x: e2e::Person[1]|$x.name,
     age: x: e2e::Person[1]|$x.age,
     salary: x: e2e::Person[1]|$x.salary,
     hire_date: x: e2e::Person[1]|$x.hireDate,
     active: x: e2e::Person[1]|$x.active,
     dept_id: x: e2e::Person[1]|$x.deptId
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|$x.id == 1
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|[]->meta::pure::functions::lang::cast(@Boolean)
   ]
)

Differences:

• Row 0, column 'result': expected 'false' but got 'null'

Expected (Postgres):

Actual (Legend):

❌ bool_null_or_true [TDS]

SQL (Postgres):

SELECT (NULL OR TRUE) AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT (NULL OR TRUE) AS result FROM func('e2e::tds_persons') WHERE id = 1

SQL (Generated, executed against DB):

select null as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id') == 1
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|[]->meta::pure::functions::lang::cast(@Boolean),
      'result'
    )
)

Differences:

• Row 0, column 'result': expected 'true' but got 'null'

Expected (Postgres):

Actual (Legend):

❌ bool_null_or_true [Relation]

SQL (Postgres):

SELECT (NULL OR TRUE) AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT (NULL OR TRUE) AS result FROM func('e2e::rel_persons') WHERE id = 1

SQL (Generated, executed against DB):

select null as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::Person[1]|$x.id,
     name: x: e2e::Person[1]|$x.name,
     age: x: e2e::Person[1]|$x.age,
     salary: x: e2e::Person[1]|$x.salary,
     hire_date: x: e2e::Person[1]|$x.hireDate,
     active: x: e2e::Person[1]|$x.active,
     dept_id: x: e2e::Person[1]|$x.deptId
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|$x.id == 1
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|[]->meta::pure::functions::lang::cast(@Boolean)
   ]
)

Differences:

• Row 0, column 'result': expected 'true' but got 'null'

Expected (Postgres):

Actual (Legend):

❌ star_multiple_tables [TDS]

SQL (Postgres):

SELECT p.*, d.* FROM persons p JOIN departments d ON p.dept_id = d.id WHERE p.id <= 3 ORDER BY p.id

SQL (Legend, rewritten):

SELECT p.*, d.* FROM func('e2e::tds_persons') p JOIN func('e2e::tds_departments') d ON p.dept_id = d.id WHERE p.id <= 3 ORDER BY p.id

SQL (Generated, executed against DB):

select "persons_0"."id_p" as "id", "persons_0"."name_p" as "name", "persons_0"."age_p" as "age", "persons_0"."salary_p" as "salary", "persons_0"."hire_date_p" as "hire_date", "persons_0"."active_p" as "active", "persons_0"."dept_id_p" as "dept_id", "persons_0"."budget_d" as "budget", "persons_0"."created_at_d" as "created_at" from (select "persons_1"."id_p" as "id_p", "persons_1"."name_p" as "name_p", "persons_1"."age_p" as "age_p", "persons_1"."salary_p" as "salary_p", "persons_1"."hire_date_p" as "hire_date_p", "persons_1"."active_p" as "active_p", "persons_1"."dept_id_p" as "dept_id_p", "persons_1"."budget_d" as "budget_d", "persons_1"."created_at_d" as "created_at_d" from (select * from (select "persons_3"."id" as "id_p", "persons_3"."name" as "name_p", "persons_3"."age" as "age_p", "persons_3"."salary" as "salary_p", "persons_3"."hire_date" as "hire_date_p", "persons_3"."active" as "active_p", "persons_3"."dept_id" as "dept_id_p" from (select "root".id as "id", "root".name as "name", "root".age as "age", "root".salary as "salary", "root".hire_date as "hire_date", "root".active as "active", "root".dept_id as "dept_id" from public.persons as "root") as "persons_3") as "persons_2" inner join (select "departments_1"."id" as "id_d", "departments_1"."name" as "name_d", "departments_1"."budget" as "budget_d", "departments_1"."created_at" as "created_at_d" from (select "root".id as "id", "root".name as "name", "root".budget as "budget", "root".created_at as "created_at" from public.departments as "root") as "departments_1") as "departments_0" on ("persons_2"."dept_id_p" = "departments_0"."id_d")) as "persons_1" where "persons_1"."id_p" <= 3 order by "id_p") as "persons_0"

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.name,
      'name'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.age,
      'age'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.salary,
      'salary'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.hireDate,
      'hire_date'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.active,
      'active'
    ),
    meta::pure::tds::col(
      x: e2e::Person[1]|$x.deptId,
      'dept_id'
    )
  ]
)->meta::pure::tds::renameColumns(
  [
    'id'->meta::pure::functions::collection::pair('id_p'),
    'name'->meta::pure::functions::collection::pair('name_p'),
    'age'->meta::pure::functions::collection::pair('age_p'),
    'salary'->meta::pure::functions::collection::pair('salary_p'),
    'hire_date'->meta::pure::functions::collection::pair('hire_date_p'),
    'active'->meta::pure::functions::collection::pair('active_p'),
    'dept_id'->meta::pure::functions::collection::pair('dept_id_p')
  ]
)->meta::pure::tds::join(
  e2e::Department.all()->meta::pure::tds::project(
    [
      meta::pure::tds::col(
        x: e2e::Department[1]|$x.id,
        'id'
      ),
      meta::pure::tds::col(
        x: e2e::Department[1]|$x.name,
        'name'
      ),
      meta::pure::tds::col(
        x: e2e::Department[1]|$x.budget,
        'budget'
      ),
      meta::pure::tds::col(
        x: e2e::Department[1]|$x.createdAt,
        'created_at'
      )
    ]
  )->meta::pure::tds::renameColumns(
    [
      'id'->meta::pure::functions::collection::pair('id_d'),
      'name'->meta::pure::functions::collection::pair('name_d'),
      'budget'->meta::pure::functions::collection::pair('budget_d'),
      'created_at'->meta::pure::functions::collection::pair('created_at_d')
    ]
  ),
  meta::relational::metamodel::join::JoinType.INNER,
  {row1: meta::pure::tds::TDSRow[1], row2: meta::pure::tds::TDSRow[1]|$row1.getInteger('dept_id_p') ==
    $row2.getInteger('id_d')  }
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getInteger('id_p') <= 3
)->meta::pure::tds::sort(
  meta::pure::tds::asc('id_p')
)->meta::pure::tds::restrict(
  [
    'id_p',
    'name_p',
    'age_p',
    'salary_p',
    'hire_date_p',
    'active_p',
    'dept_id_p',
    'budget_d',
    'created_at_d'
  ]
)->meta::pure::tds::renameColumns(
  [
    'id_p'->meta::pure::functions::collection::pair('id'),
    'name_p'->meta::pure::functions::collection::pair('name'),
    'age_p'->meta::pure::functions::collection::pair('age'),
    'salary_p'->meta::pure::functions::collection::pair('salary'),
    'hire_date_p'->meta::pure::functions::collection::pair('hire_date'),
    'active_p'->meta::pure::functions::collection::pair('active'),
    'dept_id_p'->meta::pure::functions::collection::pair('dept_id'),
    'budget_d'->meta::pure::functions::collection::pair('budget'),
    'created_at_d'->meta::pure::functions::collection::pair('created_at')
  ]
)

Differences:

• Column count mismatch: expected 11 but got 9

Expected (Postgres):

Actual (Legend):

❌ star_multiple_tables [Relation]

SQL (Postgres):

SELECT p.*, d.* FROM persons p JOIN departments d ON p.dept_id = d.id WHERE p.id <= 3 ORDER BY p.id

SQL (Legend, rewritten):

SELECT p.*, d.* FROM func('e2e::rel_persons') p JOIN func('e2e::rel_departments') d ON p.dept_id = d.id WHERE p.id <= 3 ORDER BY p.id

SQL (Generated, executed against DB):

select "persons_0"."id_p" as "id", "persons_0"."name_p" as "name", "persons_0"."age_p" as "age", "persons_0"."salary_p" as "salary", "persons_0"."hire_date_p" as "hire_date", "persons_0"."active_p" as "active", "persons_0"."dept_id_p" as "dept_id", "persons_0"."budget_d" as "budget", "persons_0"."created_at_d" as "created_at" from (select "persons_1"."id_p" as "id_p", "persons_1"."name_p" as "name_p", "persons_1"."age_p" as "age_p", "persons_1"."salary_p" as "salary_p", "persons_1"."hire_date_p" as "hire_date_p", "persons_1"."active_p" as "active_p", "persons_1"."dept_id_p" as "dept_id_p", "persons_1"."budget_d" as "budget_d", "persons_1"."created_at_d" as "created_at_d" from (select * from (select "persons_3"."id" as "id_p", "persons_3"."name" as "name_p", "persons_3"."age" as "age_p", "persons_3"."salary" as "salary_p", "persons_3"."hire_date" as "hire_date_p", "persons_3"."active" as "active_p", "persons_3"."dept_id" as "dept_id_p" from (select "root".id as "id", "root".name as "name", "root".age as "age", "root".salary as "salary", "root".hire_date as "hire_date", "root".active as "active", "root".dept_id as "dept_id" from public.persons as "root") as "persons_3") as "persons_2" inner join (select "departments_1"."id" as "id_d", "departments_1"."name" as "name_d", "departments_1"."budget" as "budget_d", "departments_1"."created_at" as "created_at_d" from (select "root".id as "id", "root".name as "name", "root".budget as "budget", "root".created_at as "created_at" from public.departments as "root") as "departments_1") as "departments_0" on ("persons_2"."dept_id_p" = "departments_0"."id_d")) as "persons_1" where "persons_1"."id_p" <= 3 order by "id_p") as "persons_0"

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::Person[1]|$x.id,
     name: x: e2e::Person[1]|$x.name,
     age: x: e2e::Person[1]|$x.age,
     salary: x: e2e::Person[1]|$x.salary,
     hire_date: x: e2e::Person[1]|$x.hireDate,
     active: x: e2e::Person[1]|$x.active,
     dept_id: x: e2e::Person[1]|$x.deptId
   ]
)->meta::pure::functions::relation::rename(
  ~id,
  ~id_p
)->meta::pure::functions::relation::rename(
  ~name,
  ~name_p
)->meta::pure::functions::relation::rename(
  ~age,
  ~age_p
)->meta::pure::functions::relation::rename(
  ~salary,
  ~salary_p
)->meta::pure::functions::relation::rename(
  ~hire_date,
  ~hire_date_p
)->meta::pure::functions::relation::rename(
  ~active,
  ~active_p
)->meta::pure::functions::relation::rename(
  ~dept_id,
  ~dept_id_p
)->meta::pure::functions::relation::join(
  e2e::Department.all()->meta::pure::functions::relation::project(
    ~[
       id: x: e2e::Department[1]|$x.id,
       name: x: e2e::Department[1]|$x.name,
       budget: x: e2e::Department[1]|$x.budget,
       created_at: x: e2e::Department[1]|$x.createdAt
     ]
  )->meta::pure::functions::relation::rename(
    ~id,
    ~id_d
  )->meta::pure::functions::relation::rename(
    ~name,
    ~name_d
  )->meta::pure::functions::relation::rename(
    ~budget,
    ~budget_d
  )->meta::pure::functions::relation::rename(
    ~created_at,
    ~created_at_d
  ),
  meta::pure::functions::relation::JoinKind.INNER,
  {row1: (id_p:Integer[1], name_p:String, age_p:Integer, salary_p:Float, hire_date_p:StrictDate, active_p:Boolean, dept_id_p:Integer)[1], row2: (id_d:Integer[1], name_d:String, budget_d:Float, created_at_d:DateTime)[1]|$row1.dept_id_p ==
    $row2.id_d  }
)->meta::pure::functions::relation::filter(
  x: (id_p:Integer[1], name_p:String, age_p:Integer, salary_p:Float, hire_date_p:StrictDate, active_p:Boolean, dept_id_p:Integer, id_d:Integer[1], name_d:String, budget_d:Float, created_at_d:DateTime)[1]|$x.id_p <= 3
)->meta::pure::functions::relation::sort(
  ~id_p->meta::pure::functions::relation::ascending()
)->meta::pure::functions::relation::select(
  ~[
     id_p,
     name_p,
     age_p,
     salary_p,
     hire_date_p,
     active_p,
     dept_id_p,
     budget_d,
     created_at_d
   ]
)->meta::pure::functions::relation::rename(
  ~id_p,
  ~id
)->meta::pure::functions::relation::rename(
  ~name_p,
  ~name
)->meta::pure::functions::relation::rename(
  ~age_p,
  ~age
)->meta::pure::functions::relation::rename(
  ~salary_p,
  ~salary
)->meta::pure::functions::relation::rename(
  ~hire_date_p,
  ~hire_date
)->meta::pure::functions::relation::rename(
  ~active_p,
  ~active
)->meta::pure::functions::relation::rename(
  ~dept_id_p,
  ~dept_id
)->meta::pure::functions::relation::rename(
  ~budget_d,
  ~budget
)->meta::pure::functions::relation::rename(
  ~created_at_d,
  ~created_at
)

Differences:

• Column count mismatch: expected 11 but got 9

Expected (Postgres):

Actual (Legend):

❌ schema_information_tables [TDS]

SQL (Postgres):

SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' ORDER BY 1

Differences:

• Row count mismatch: expected 8 but got 0

Expected (Postgres):

Actual (Legend):

❌ schema_information_tables [Relation]

SQL (Postgres):

SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' ORDER BY 1

Differences:

• Row count mismatch: expected 8 but got 0

Expected (Postgres):

Actual (Legend):

❌ schema_information_columns [TDS]

SQL (Postgres):

SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = 'persons' ORDER BY 1

Differences:

• Row count mismatch: expected 7 but got 0

Expected (Postgres):

Actual (Legend):

❌ schema_information_columns [Relation]

SQL (Postgres):

SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = 'persons' ORDER BY 1

Differences:

• Row count mismatch: expected 7 but got 0

Expected (Postgres):

Actual (Legend):

❌ json_extract_array_index [Relation]

SQL (Postgres):

SELECT '[10,20,30]'::jsonb -> 1 AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT '[10,20,30]'::jsonb -> 1 AS result FROM func('e2e::rel_persons') WHERE id = 1

SQL (Generated, executed against DB):

select (cast(cast(Text'[10,20,30]' as JSONB) as jsonb)->1) as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::Person[1]|$x.id,
     name: x: e2e::Person[1]|$x.name,
     age: x: e2e::Person[1]|$x.age,
     salary: x: e2e::Person[1]|$x.salary,
     hire_date: x: e2e::Person[1]|$x.hireDate,
     active: x: e2e::Person[1]|$x.active,
     dept_id: x: e2e::Person[1]|$x.deptId
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|$x.id == 1
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|meta::pure::functions::variant::convert::fromJson('[10,20,30]')->meta::pure::functions::variant::navigation::get(1)
   ]
)

Differences:

• Row 0, column 'result': expected '20' but got '"20"'

Expected (Postgres):

Actual (Legend):

❌ json_extract_array_negative_index [Relation]

SQL (Postgres):

SELECT '[10,20,30]'::jsonb -> -1 AS result FROM persons WHERE id = 1

SQL (Legend, rewritten):

SELECT '[10,20,30]'::jsonb -> -1 AS result FROM func('e2e::rel_persons') WHERE id = 1

SQL (Generated, executed against DB):

select (cast(cast(Text'[10,20,30]' as JSONB) as jsonb)->-1) as "result" from public.persons as "root" where "root".id = 1

Lambda (Pure expression):

|e2e::Person.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::Person[1]|$x.id,
     name: x: e2e::Person[1]|$x.name,
     age: x: e2e::Person[1]|$x.age,
     salary: x: e2e::Person[1]|$x.salary,
     hire_date: x: e2e::Person[1]|$x.hireDate,
     active: x: e2e::Person[1]|$x.active,
     dept_id: x: e2e::Person[1]|$x.deptId
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|$x.id == 1
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], name:String, age:Integer, salary:Float, hire_date:StrictDate, active:Boolean, dept_id:Integer)[1]|meta::pure::functions::variant::convert::fromJson('[10,20,30]')->meta::pure::functions::variant::navigation::get(
    -1
  )
   ]
)

Differences:

• Row 0, column 'result': expected '30' but got '"30"'

Expected (Postgres):

Actual (Legend):

❌ interval_compound_literal [TDS]

SQL (Postgres):

SELECT d + INTERVAL '1 year 2 months 3 days' AS result FROM dates WHERE d IS NOT NULL ORDER BY 1

SQL (Legend, rewritten):

SELECT d + INTERVAL '1 year 2 months 3 days' AS result FROM func('e2e::tds_dates') WHERE d IS NOT NULL ORDER BY 1

SQL (Generated, executed against DB):

select ((("root".d + (INTERVAL '1 YEARS' * 1)) + (INTERVAL '1 MONTHS' * 2)) + (INTERVAL '1 DAYS' * 3)) as "result" from public.dates as "root" where "root".d is not null order by "result"

Lambda (Pure expression):

|e2e::DateRow.all()->meta::pure::tds::project(
  [
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.id,
      'id'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.d,
      'd'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.ts,
      'ts'
    ),
    meta::pure::tds::col(
      x: e2e::DateRow[1]|$x.tsz,
      'tsz'
    )
  ]
)->meta::pure::tds::filter(
  row: meta::pure::tds::TDSRow[1]|$row.getStrictDate('d')->meta::pure::functions::collection::isNotEmpty()
)->meta::pure::tds::project(
  meta::pure::tds::col(
      row: meta::pure::tds::TDSRow[1]|$row.getStrictDate('d')->meta::pure::functions::date::adjust(
        1,
        meta::pure::functions::date::DurationUnit.YEARS
      )->meta::pure::functions::date::adjust(
        2,
        meta::pure::functions::date::DurationUnit.MONTHS
      )->meta::pure::functions::date::adjust(
        3,
        meta::pure::functions::date::DurationUnit.DAYS
      ),
      'result'
    )
)->meta::pure::tds::sort(
  meta::pure::tds::asc('result')
)

Differences:

• Row 3, column 'result': expected '2021-05-02 00:00:00.0' but got '2021-05-01 00:00:00.0'

Expected (Postgres):

Actual (Legend):

❌ interval_compound_literal [Relation]

SQL (Postgres):

SELECT d + INTERVAL '1 year 2 months 3 days' AS result FROM dates WHERE d IS NOT NULL ORDER BY 1

SQL (Legend, rewritten):

SELECT d + INTERVAL '1 year 2 months 3 days' AS result FROM func('e2e::rel_dates') WHERE d IS NOT NULL ORDER BY 1

SQL (Generated, executed against DB):

select ((("root".d + (INTERVAL '1 YEARS' * 1)) + (INTERVAL '1 MONTHS' * 2)) + (INTERVAL '1 DAYS' * 3)) as "result" from public.dates as "root" where "root".d is not null order by "result"

Lambda (Pure expression):

|e2e::DateRow.all()->meta::pure::functions::relation::project(
  ~[
     id: x: e2e::DateRow[1]|$x.id,
     d: x: e2e::DateRow[1]|$x.d,
     ts: x: e2e::DateRow[1]|$x.ts,
     tsz: x: e2e::DateRow[1]|$x.tsz
   ]
)->meta::pure::functions::relation::filter(
  x: (id:Integer[1], d:StrictDate, ts:DateTime, tsz:DateTime)[1]|$x.d->meta::pure::functions::collection::isNotEmpty()
)->meta::pure::functions::relation::project(
  ~[
     result: x: (id:Integer[1], d:StrictDate, ts:DateTime, tsz:DateTime)[1]|$x.d->meta::pure::functions::multiplicity::toOne()->meta::pure::functions::date::adjust(
    1,
    meta::pure::functions::date::DurationUnit.YEARS
  )->meta::pure::functions::date::adjust(
    2,
    meta::pure::functions::date::DurationUnit.MONTHS
  )->meta::pure::functions::date::adjust(
    3,
    meta::pure::functions::date::DurationUnit.DAYS
  )
   ]
)->meta::pure::functions::relation::sort(
  ~result->meta::pure::functions::relation::ascending()
)

Differences:

• Row 3, column 'result': expected '2021-05-02 00:00:00.0' but got '2021-05-01 00:00:00.0'

Expected (Postgres):

Actual (Legend):