expr.out

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
SET extra_float_digits = 0;
LOAD 'postgraph';
SET search_path TO postgraph;
set timezone TO 'GMT';
SELECT * FROM create_graph('expr');
NOTICE:  graph "expr" has been created
 create_graph 
--------------
 
(1 row)

SET bytea_output = 'hex';
SELECT tobytea('"abc \153\154\155 \052\251\124"');
         tobytea          
--------------------------
 \x616263206b6c6d202aa954
(1 row)

SELECT tobytea('"\xDEADBEEF"');
  tobytea   
------------
 \xdeadbeef
(1 row)

SET bytea_output = 'escape';
SELECT tobytea('"\xDEADBEEF"');
     tobytea      
------------------
 \336\255\276\357
(1 row)

SELECT tobytea('"abc \153\154\155 \052\251\124"');
    tobytea     
----------------
 abc klm *\251T
(1 row)

SELECT '{"Hello", "World"}'::text[]::gtype;
       gtype        
--------------------
 ["Hello", "World"]
(1 row)

SELECT '{1, 2, 3, 4, 5, 6}'::int2[]::gtype;
       gtype        
--------------------
 [1, 2, 3, 4, 5, 6]
(1 row)

SELECT '{1, 2, 3, 4, 5, 6}'::int4[]::gtype;
       gtype        
--------------------
 [1, 2, 3, 4, 5, 6]
(1 row)

SELECT '{1, 2, 3, 4, 5, 6}'::int8[]::gtype;
       gtype        
--------------------
 [1, 2, 3, 4, 5, 6]
(1 row)

SELECT '{1.0, 2, 3.0, 4, 5, 6}'::float4[]::gtype;
             gtype              
--------------------------------
 [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
(1 row)

SELECT '{1.0, 2, 3.0, 4, 5, 6}'::float8[]::gtype;
             gtype              
--------------------------------
 [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
(1 row)

SELECT '{1.0, 2, 3.0, 4, 5, 6}'::numeric[]::gtype;
                                    gtype                                     
------------------------------------------------------------------------------
 [1.0::numeric, 2::numeric, 3.0::numeric, 4::numeric, 5::numeric, 6::numeric]
(1 row)

SELECT '{true, false, true, true, false}'::boolean[]::gtype;
              gtype               
----------------------------------
 [true, false, true, true, false]
(1 row)

SELECT '{"12/17/1997 07:37:16.00+00", "1/25/2015 17:45:32.21+00"}'::timestamp[]::gtype;
                          gtype                          
---------------------------------------------------------
 [Wed Dec 17 07:37:16 1997, Sun Jan 25 17:45:32.21 2015]
(1 row)

SELECT '{"12/17/1997 07:37:16.00+04", "1/25/2015 17:45:32.21+08"}'::timestamptz[]::gtype;
                              gtype                              
-----------------------------------------------------------------
 [Wed Dec 17 03:37:16 1997 GMT, Sun Jan 25 09:45:32.21 2015 GMT]
(1 row)

SELECT '{"12/17/1997", "1/25/2015"}'::date[]::gtype;
          gtype           
--------------------------
 [12-17-1997, 01-25-2015]
(1 row)

SELECT '{"07:37:16.00+00", "17:45:32.21+00"}'::time[]::gtype;
            gtype            
-----------------------------
 ["07:37:16", "17:45:32.21"]
(1 row)

SELECT '{"07:37:16.00+04", "17:45:32.21+08"}'::timetz[]::gtype;
               gtype               
-----------------------------------
 ["07:37:16+04", "17:45:32.21+08"]
(1 row)

SELECT '{"5 Days", "1 Month", "2 Years Ago"}'::interval[]::gtype;
               gtype                
------------------------------------
 [@ 5 days, @ 1 mon, @ 2 years ago]
(1 row)

SET bytea_output = 'hex';
SELECT * FROM cypher('expr', $$RETURN sha224('Hello World') $$) AS r(c gtype);
                             c                              
------------------------------------------------------------
 \xc4890faffdb0105d991a461e668e276685401b02eab1ef4372795047
(1 row)

SELECT * FROM cypher('expr', $$RETURN sha224('Hello World 2') $$) AS r(c gtype);
                             c                              
------------------------------------------------------------
 \xff841f4e7beffb759ae2c7d428cf8fad219a249b48ac8620e69f8df1
(1 row)

SELECT * FROM cypher('expr', $$RETURN sha256('Hello World') $$) AS r(c gtype);
                                 c                                  
--------------------------------------------------------------------
 \xa591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e
(1 row)

SELECT * FROM cypher('expr', $$RETURN sha256('Hello World 2') $$) AS r(c gtype);
                                 c                                  
--------------------------------------------------------------------
 \x3df75539dda4c512db688b3f1d86184c0d7b99cbea1eb87dec8385a2651ac1f3
(1 row)

SELECT * FROM cypher('expr', $$RETURN sha384('Hello World') $$) AS r(c gtype);
                                                 c                                                  
----------------------------------------------------------------------------------------------------
 \x99514329186b2f6ae4a1329e7ee6c610a729636335174ac6b740f9028396fcc803d0e93863a7c3d90f86beee782f4f3f
(1 row)

SELECT * FROM cypher('expr', $$RETURN sha384('Hello World 2') $$) AS r(c gtype);
                                                 c                                                  
----------------------------------------------------------------------------------------------------
 \x87a6de8a25ff6e5d661683e5cd91a81a9394aec5476f84ba32d4c84cf1fd57630fad47f781c0cb1e4515b7ea6cdca456
(1 row)

SELECT * FROM cypher('expr', $$RETURN sha512('Hello World') $$) AS r(c gtype);
                                                                 c                                                                  
------------------------------------------------------------------------------------------------------------------------------------
 \x2c74fd17edafd80e8447b0d46741ee243b7eb74dd2149a0ab1b9246fb30382f27e853d8585719e0e67cbda0daa8f51671064615d645ae27acb15bfb1447f459b
(1 row)

SELECT * FROM cypher('expr', $$RETURN sha512('Hello World 2') $$) AS r(c gtype);
                                                                 c                                                                  
------------------------------------------------------------------------------------------------------------------------------------
 \x1fc232dacda45b1598d0b77c52d2f6819b03eb5b10297e23b8741ae426b8503d0e263d50b8466fcfd4511327744e5b536372da7178f7d69f8f5d47aacef8f09e
(1 row)

SELECT * FROM cypher('expr', $$RETURN md5('Hello World') $$) AS r(c gtype);
                 c                  
------------------------------------
 "b10a8db164e0754105b7a99be72e3fe5"
(1 row)

SELECT * FROM cypher('expr', $$RETURN md5('Hello World 2') $$) AS r(c gtype);
                 c                  
------------------------------------
 "4c24aac86aa49adce486631bf365098f"
(1 row)

--
-- map literal
--
-- empty map
SELECT * FROM cypher('expr', $$RETURN {}$$) AS r(c gtype);
 c  
----
 {}
(1 row)

-- map of scalar values
SELECT * FROM cypher('expr', $$ RETURN {s: 's', i: 1, f: 1.0, b: true, z: null} $$) AS r(c gtype);
                         c                          
----------------------------------------------------
 {"b": true, "f": 1.0, "i": 1, "s": "s", "z": null}
(1 row)

-- nested maps
SELECT * FROM cypher('expr', $$ RETURN {s: {s: 's'}, t: {i: 1, e: {f: 1.0}, s: {a: {b: true}}}, z: null} $$) AS r(c gtype);
                                           c                                           
---------------------------------------------------------------------------------------
 {"s": {"s": "s"}, "t": {"e": {"f": 1.0}, "i": 1, "s": {"a": {"b": true}}}, "z": null}
(1 row)

--
-- parameter
--
PREPARE cypher_parameter(gtype) AS SELECT * FROM cypher('expr', $$ RETURN $var $$, $1) AS t(i gtype);
EXECUTE cypher_parameter('{"var": 1}');
 i 
---
 1
(1 row)

PREPARE cypher_parameter_object(gtype) AS SELECT * FROM cypher('expr', $$ RETURN $var.innervar $$, $1) AS t(i gtype);
EXECUTE cypher_parameter_object('{"var": {"innervar": 1}}');
 i 
---
 1
(1 row)

PREPARE cypher_parameter_array(gtype) AS SELECT * FROM cypher('expr', $$ RETURN $var[$indexvar] $$, $1) AS t(i gtype);
EXECUTE cypher_parameter_array('{"var": [1, 2, 3], "indexvar": 1}');
 i 
---
 2
(1 row)

-- missing parameter
PREPARE cypher_parameter_missing_argument(gtype) AS SELECT * FROM cypher('expr', $$ RETURN $var, $missingvar $$, $1) AS t(i gtype, j gtype);
EXECUTE cypher_parameter_missing_argument('{"var": 1}');
 i | j 
---+---
 1 | 
(1 row)

-- invalid parameter
PREPARE cypher_parameter_invalid_argument(gtype) AS SELECT * FROM cypher('expr', $$ RETURN $var $$, $1) AS t(i gtype);
EXECUTE cypher_parameter_invalid_argument('[1]');
 i 
---
 
(1 row)

-- missing parameters argument
PREPARE cypher_missing_params_argument(int) AS SELECT $1, * FROM cypher('expr', $$ RETURN $var $$) AS t(i gtype);
ERROR:  parameters argument is missing from cypher() function call
LINE 1: ...nt) AS SELECT $1, * FROM cypher('expr', $$ RETURN $var $$) A...
                                                             ^
SELECT * FROM cypher('expr', $$ RETURN $var $$) AS t(i gtype);
ERROR:  parameters argument is missing from cypher() function call
LINE 1: SELECT * FROM cypher('expr', $$ RETURN $var $$) AS t(i gtype...
                                               ^
--
-- String operators
--
-- String LHS + String RHS
SELECT * FROM cypher('expr', $$RETURN 'str' + 'str'$$) AS r(c gtype);
    c     
----------
 "strstr"
(1 row)

-- String LHS + Integer RHS
SELECT * FROM cypher('expr', $$RETURN 'str' + 1$$) AS r(c gtype);
   c    
--------
 "str1"
(1 row)

-- String LHS + Float RHS
SELECT * FROM cypher('expr', $$RETURN 'str' + 1.0$$) AS r(c gtype);
   c    
--------
 "str1"
(1 row)

-- Integer LHS + String LHS
SELECT * FROM cypher('expr', $$RETURN 1 + 'str'$$) AS r(c gtype);
   c    
--------
 "1str"
(1 row)

-- Float LHS + String RHS
SELECT * FROM cypher('expr', $$RETURN 1.0 + 'str'$$) AS r(c gtype);
   c    
--------
 "1str"
(1 row)

--
-- Test transform logic for operators
--
SELECT * FROM cypher('expr', $$ RETURN (-(3 * 2 - 4.0) ^ ((10 / 5) + 1)) % -3 $$) AS r(result gtype);
 result 
--------
 -2.0
(1 row)

--
-- a bunch of comparison operators
--
SELECT * FROM cypher('expr', $$ RETURN 1 = 1.0 $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN 1 > -1.0 $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN -1.0 < 1 $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN "aaa" < "z" $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN "z" > "aaa" $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN false = false $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ("string" < true) $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN true < 1 $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN (1 + 1.0) = (7 % 5) $$) AS r(result boolean);
 result 
--------
 t
(1 row)

-- IS NULL
SELECT * FROM cypher('expr', $$ RETURN null IS NULL $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN 1 IS NULL $$) AS r(result boolean);
 result 
--------
 f
(1 row)

-- IS NOT NULL
SELECT * FROM cypher('expr', $$ RETURN 1 IS NOT NULL $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN null IS NOT NULL $$) AS r(result boolean);
 result 
--------
 f
(1 row)

-- NOT
SELECT * FROM cypher('expr', $$ RETURN NOT false $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN NOT true $$) AS r(result boolean);
 result 
--------
 f
(1 row)

-- AND
SELECT * FROM cypher('expr', $$ RETURN true AND true $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN true AND false $$) AS r(result boolean);
 result 
--------
 f
(1 row)

SELECT * FROM cypher('expr', $$ RETURN false AND true $$) AS r(result boolean);
 result 
--------
 f
(1 row)

SELECT * FROM cypher('expr', $$ RETURN false AND false $$) AS r(result boolean);
 result 
--------
 f
(1 row)

-- OR
SELECT * FROM cypher('expr', $$ RETURN true OR true $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN true OR false $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN false OR true $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN false OR false $$) AS r(result boolean);
 result 
--------
 f
(1 row)

-- The ONE test on operator precedence...
SELECT * FROM cypher('expr', $$ RETURN NOT ((true OR false) AND (false OR true)) $$) AS r(result boolean);
 result 
--------
 f
(1 row)

-- XOR
SELECT * FROM cypher('expr', $$ RETURN true XOR true $$) AS r(result boolean);
 result 
--------
 f
(1 row)

SELECT * FROM cypher('expr', $$ RETURN true XOR false $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN false XOR true $$) AS r(result boolean);
 result 
--------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN false XOR false $$) AS r(result boolean);
 result 
--------
 f
(1 row)

--
-- Test indirection transform logic for object.property, object["property"],
-- and array[element]
--
SELECT * FROM cypher('expr', $$ RETURN [ 1, { bool: true, int: 3, array: [ 9, 11, { boom: false, float: 3.14 }, 13 ] }, 5, 7, 9 ][1].array[2]["float"] $$) AS r(result gtype);
 result 
--------
 3.14
(1 row)

--
-- Test STARTS WITH, ENDS WITH, and CONTAINS transform logic
--
-- true
SELECT * FROM cypher('expr', $$ RETURN "abcdefghijklmnopqrstuvwxyz" STARTS WITH "abcd" $$) AS r(result gtype);
 result 
--------
 true
(1 row)

SELECT * FROM cypher('expr', $$ RETURN "abcdefghijklmnopqrstuvwxyz" ENDS WITH "wxyz" $$) AS r(result gtype);
 result 
--------
 true
(1 row)

SELECT * FROM cypher('expr', $$ RETURN "abcdefghijklmnopqrstuvwxyz" CONTAINS "klmn" $$) AS r(result gtype);
 result 
--------
 true
(1 row)

SELECT * FROM cypher('expr', $$ RETURN "abcdefghijklmnopqrstuvwxyz" STARTS WITH "bcde" $$) AS r(result gtype);
 result 
--------
 false
(1 row)

SELECT * FROM cypher('expr', $$ RETURN "abcdefghijklmnopqrstuvwxyz" ENDS WITH "vwxy" $$) AS r(result gtype);
 result 
--------
 false
(1 row)

SELECT * FROM cypher('expr', $$ RETURN "abcdefghijklmnopqrstuvwxyz" CONTAINS "klmo" $$) AS r(result gtype);
 result 
--------
 false
(1 row)

SELECT * FROM cypher('expr', $$ RETURN "abcdefghijklmnopqrstuvwxyz" STARTS WITH NULL $$) AS r(result gtype);
 result 
--------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN "abcdefghijklmnopqrstuvwxyz" ENDS WITH NULL $$) AS r(result gtype);
 result 
--------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN "abcdefghijklmnopqrstuvwxyz" CONTAINS NULL $$) AS r(result gtype);
 result 
--------
 
(1 row)

--
--Coearce to Postgres 3 int types (smallint, int, bigint)
--
SELECT create_graph('type_coercion');
NOTICE:  graph "type_coercion" has been created
 create_graph 
--------------
 
(1 row)

SELECT * FROM cypher('type_coercion', $$ RETURN NULL $$) AS (i bigint);
 i 
---
  
(1 row)

SELECT * FROM cypher('type_coercion', $$ RETURN 1 $$) AS (i smallint);
 i 
---
 1
(1 row)

SELECT * FROM cypher('type_coercion', $$ RETURN 1 $$) AS (i int);
 i 
---
 1
(1 row)

SELECT * FROM cypher('type_coercion', $$ RETURN 1 $$) AS (i bigint);
 i 
---
 1
(1 row)

SELECT * FROM cypher('type_coercion', $$ RETURN 1.0 $$) AS (i bigint);
 i 
---
 1
(1 row)

SELECT * FROM cypher('type_coercion', $$ RETURN 1.0::numeric $$) AS (i bigint);
 i 
---
 1
(1 row)

SELECT * FROM cypher('type_coercion', $$ RETURN '1' $$) AS (i bigint);
 i 
---
 1
(1 row)

--Invalid String Format
SELECT * FROM cypher('type_coercion', $$ RETURN '1.0' $$) AS (i bigint);
ERROR:  invalid input syntax for type bigint: "1.0"
-- Casting to ints that will cause overflow
SELECT * FROM cypher('type_coercion', $$ RETURN 10000000000000000000 $$) AS (i smallint);
ERROR:  smallint out of range
SELECT * FROM cypher('type_coercion', $$ RETURN 10000000000000000000 $$) AS (i int);
ERROR:  integer out of range
--Invalid types
SELECT * FROM cypher('type_coercion', $$ RETURN true $$) AS (i bigint);
ERROR:  cannot cast gtype boolean to type int8
SELECT * FROM cypher('type_coercion', $$ RETURN {key: 1} $$) AS (i bigint);
ERROR:  cannot cast non-scalar gtype to int8
SELECT * FROM cypher('type_coercion', $$ RETURN [1] $$) AS (i bigint);
ERROR:  cannot cast non-scalar gtype to int8
--
-- typecasting '::'
--
-- gtype int
SELECT * FROM cypher('expr', $$ RETURN 0.0::int $$) AS r(result gtype);
 result 
--------
 0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN 0.0::integer $$) AS r(result gtype);
 result 
--------
 0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN '0'::int $$) AS r(result gtype);
 result 
--------
 0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN '0'::integer $$) AS r(result gtype);
 result 
--------
 0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN 0.0::numeric::int $$) AS r(result gtype);
 result 
--------
 0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN 2.71::int $$) AS r(result gtype);
 result 
--------
 3
(1 row)

SELECT * FROM cypher('expr', $$ RETURN 2.71::numeric::int $$) AS r(result gtype);
 result 
--------
 3
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ([0, {one: 1.0, pie: 3.1415927, e: 2::numeric}, 2, null][1].one)::int $$) AS r(result gtype);
 result 
--------
 1
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ([0, {one: 1.0::int, pie: 3.1415927, e: 2.718281::numeric}, 2, null][1].one) $$) AS r(result gtype);
 result 
--------
 1
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ([0, {one: 1::float, pie: 3.1415927, e: 2.718281::numeric}, 2, null][1].one)::int $$) AS r(result gtype);
 result 
--------
 1
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ([0, {one: 1, pie: 3.1415927, e: 2.718281::numeric}, 2, null][3])::int $$) AS r(result gtype);
 result 
--------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN '0.0'::int $$) AS r(result gtype);
ERROR:  invalid input syntax for type bigint: "0.0"
SELECT * FROM cypher('expr', $$ RETURN '1.5'::int $$) AS r(result gtype);
ERROR:  invalid input syntax for type bigint: "1.5"
SELECT * FROM cypher('expr', $$ RETURN 'NaN'::float::int $$) AS r(result gtype);
ERROR:  bigint out of range
SELECT * FROM cypher('expr', $$ RETURN 'infinity'::float::int $$) AS r(result gtype);
ERROR:  bigint out of range
-- to gtype numeric
SELECT * FROM cypher('expr', $$ RETURN 0::numeric $$) AS r(result gtype);
   result   
------------
 0::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN 2.71::numeric $$) AS r(result gtype);
    result     
---------------
 2.71::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN '2.71'::numeric $$) AS r(result gtype);
    result     
---------------
 2.71::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ((1 + 2.71) * 3)::numeric $$) AS r(result gtype);
     result     
----------------
 11.13::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ([0, {one: 1, pie: 3.1415927, e: 2.718281::numeric}, 2, null][1].pie)::numeric $$) AS r(result gtype);
       result       
--------------------
 3.1415927::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ([0, {one: 1, pie: 3.1415927, e: 2.718281::numeric}, 2, null][1].e) $$) AS r(result gtype);
      result       
-------------------
 2.718281::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ([0, {one: 1, pie: 3.1415927, e: 2.718281::numeric}, 2, null][1].e)::numeric $$) AS r(result gtype);
      result       
-------------------
 2.718281::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ([0, {one: 1, pie: 3.1415927, e: 2.718281::numeric}, 2, null][3])::numeric $$) AS r(result gtype);
 result 
--------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ([0, {one: 1, pie: 3.1415927, e: 2.718281::numeric}, 2::numeric, null]) $$) AS r(result gtype);
                                   result                                    
-----------------------------------------------------------------------------
 [0, {"e": 2.718281::numeric, "one": 1, "pie": 3.1415927}, 2::numeric, null]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ('2:71'::numeric)::numeric $$) AS r(result gtype);
ERROR:  invalid input syntax for type numeric: "2:71"
SELECT * FROM cypher('expr', $$ RETURN ('inf'::numeric)::numeric $$) AS r(result gtype);
      result       
-------------------
 Infinity::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ('infinity'::numeric)::numeric $$) AS r(result gtype);
      result       
-------------------
 Infinity::numeric
(1 row)

-- to gtype float
SELECT * FROM cypher('expr', $$ RETURN 0::float $$) AS r(result gtype);
 result 
--------
 0.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN '2.71'::float $$) AS r(result gtype);
 result 
--------
 2.71
(1 row)

SELECT * FROM cypher('expr', $$ RETURN 2.71::float $$) AS r(result gtype);
 result 
--------
 2.71
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ([0, {one: 1, pie: 3.1415927, e: 2::numeric}, 2, null][1].one)::float $$) AS r(result gtype);
 result 
--------
 1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ([0, {one: 1::float, pie: 3.1415927, e: 2.718281::numeric}, 2, null][1].one) $$) AS r(result gtype);
 result 
--------
 1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ([0, {one: 1::float, pie: 3.1415927, e: 2.718281::numeric}, 2, null][1].one)::float $$) AS r(result gtype);
 result 
--------
 1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ([0, {one: 1, pie: 3.1415927, e: 2.718281::numeric}, 2, null][3])::float $$) AS r(result gtype);
 result 
--------
 
(1 row)

-- Float
SELECT * FROM cypher('expr', $$ RETURN 'NaN'::float $$) AS r(result gtype);
 result 
--------
 NaN
(1 row)

SELECT * FROM cypher('expr', $$ RETURN 'inf'::float $$) AS r(result gtype);
  result  
----------
 Infinity
(1 row)

SELECT * FROM cypher('expr', $$ RETURN '-inf'::float $$) AS r(result gtype);
  result   
-----------
 -Infinity
(1 row)

SELECT * FROM cypher('expr', $$ RETURN 'infinity'::float $$) AS r(result gtype);
  result  
----------
 Infinity
(1 row)

SELECT * FROM cypher('expr', $$ RETURN '-infinity'::float $$) AS r(result gtype);
  result   
-----------
 -Infinity
(1 row)

SELECT * FROM cypher('expr', $$ RETURN null::float $$) AS r(result gtype);
 result 
--------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN '2:71'::float $$) AS r(result gtype);
ERROR:  invalid input syntax for type double precision: "2:71"
SELECT * FROM cypher('expr', $$ RETURN 'infi'::float $$) AS r(result gtype);
ERROR:  invalid input syntax for type double precision: "infi"
-- size() of a string
SELECT * FROM cypher('expr', $$ RETURN size('12345') $$) AS (size gtype);
 size 
------
 5
(1 row)

SELECT * FROM cypher('expr', $$ RETURN size("1234567890") $$) AS (size gtype);
 size 
------
 10
(1 row)

-- coalesce
SELECT * FROM cypher('expr', $$ RETURN coalesce(null, 1, null, null) $$) AS (coalesce gtype);
 coalesce 
----------
 1
(1 row)

SELECT * FROM cypher('expr', $$ RETURN coalesce(null, -3.14, null, null) $$) AS (coalesce gtype);
 coalesce 
----------
 -3.14
(1 row)

SELECT * FROM cypher('expr', $$ RETURN coalesce(null, "string", null, null) $$) AS (coalesce gtype);
 coalesce 
----------
 "string"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN coalesce(null, null, null, []) $$) AS (coalesce gtype);
 coalesce 
----------
 []
(1 row)

SELECT * FROM cypher('expr', $$ RETURN coalesce(null, null, null, {}) $$) AS (coalesce gtype);
 coalesce 
----------
 {}
(1 row)

SELECT * FROM cypher('expr', $$ RETURN coalesce(null) $$) AS (coalesce gtype);
 coalesce 
----------
 
(1 row)

-- toBoolean
SELECT * FROM cypher('expr', $$ RETURN toBoolean(true) $$) AS (toBoolean gtype);
 toboolean 
-----------
 true
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toBoolean(false) $$) AS (toBoolean gtype);
 toboolean 
-----------
 false
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toBoolean("true") $$) AS (toBoolean gtype);
 toboolean 
-----------
 true
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toBoolean("false") $$) AS (toBoolean gtype);
 toboolean 
-----------
 false
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toBoolean("falze") $$) AS (toBoolean gtype);
ERROR:  cannot cast gtype string to type boolean
SELECT * FROM cypher('expr', $$ RETURN toBoolean(null) $$) AS (toBoolean gtype);
 toboolean 
-----------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toBoolean(1) $$) AS (toBoolean gtype);
ERROR:  cannot cast gtype integer to type boolean
-- toFloat
SELECT * FROM cypher('expr', $$ RETURN toFloat(1) $$) AS (toFloat gtype);
 tofloat 
---------
 1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toFloat(1.2) $$) AS (toFloat gtype);
 tofloat 
---------
 1.2
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toFloat("1") $$) AS (toFloat gtype);
 tofloat 
---------
 1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toFloat("1.2") $$) AS (toFloat gtype);
 tofloat 
---------
 1.2
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toFloat("1.2"::numeric) $$) AS (toFloat gtype);
 tofloat 
---------
 1.2
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toFloat("falze") $$) AS (toFloat gtype);
ERROR:  invalid input syntax for type double precision: "falze"
SELECT * FROM cypher('expr', $$ RETURN toFloat(null) $$) AS (toFloat gtype);
 tofloat 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toFloat(true) $$) AS (toFloat gtype);
ERROR:  cannot cast gtype boolean to type float8
-- toInteger
SELECT * FROM cypher('expr', $$ RETURN toInteger(1) $$) AS (toInteger gtype);
 tointeger 
-----------
 1
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toInteger(1.2) $$) AS (toInteger gtype);
 tointeger 
-----------
 1
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toInteger("1") $$) AS (toInteger gtype);
 tointeger 
-----------
 1
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toInteger("1.2") $$) AS (toInteger gtype);
ERROR:  invalid input syntax for type bigint: "1.2"
SELECT * FROM cypher('expr', $$ RETURN toInteger("1.2"::numeric) $$) AS (toInteger gtype);
 tointeger 
-----------
 1
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toInteger("falze") $$) AS (toInteger gtype);
ERROR:  invalid input syntax for type bigint: "falze"
SELECT * FROM cypher('expr', $$ RETURN toInteger(null) $$) AS (toInteger gtype);
 tointeger 
-----------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toInteger(true) $$) AS (toInteger gtype);
ERROR:  cannot cast gtype boolean to type int8
-- toString
SELECT * FROM cypher('expr', $$ RETURN toString(3) $$) AS (results gtype);
 results 
---------
 "3"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toString(3.14) $$) AS (results gtype);
 results 
---------
 "3.14"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toString(3.14::float) $$) AS (results gtype);
 results 
---------
 "3.14"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toString(3.14::numeric) $$) AS (results gtype);
 results 
---------
 "3.14"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toString(true) $$) AS (results gtype);
 results 
---------
 "true"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toString(false) $$) AS (results gtype);
 results 
---------
 "false"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toString('a string') $$) AS (results gtype);
  results   
------------
 "a string"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toString(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

-- reverse
SELECT * FROM cypher('expr', $$ RETURN reverse("gnirts a si siht") $$) AS (results gtype);
      results       
--------------------
 "this is a string"
(1 row)

SELECT * FROM reverse('"gnirts a si siht"'::gtype);
      reverse       
--------------------
 "this is a string"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN reverse(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN reverse([4923, 'abc', 521, NULL, 487]) $$) AS (u gtype);
               u               
-------------------------------
 [487, null, 521, "abc", 4923]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN reverse([4923]) $$) AS (u gtype);
   u    
--------
 [4923]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN reverse([4923, 257]) $$) as (u gtype);
      u      
-------------
 [257, 4923]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN reverse([4923, 257, null]) $$) as (u gtype);
         u         
-------------------
 [null, 257, 4923]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN reverse([4923, 257, 'tea']) $$) as (u gtype);
         u          
--------------------
 ["tea", 257, 4923]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN reverse([[1, 4, 7], 4923, [1, 2, 3], 'abc', 521, NULL, 487, ['fgt', 7, 10]]) $$) as (u gtype);
                                  u                                  
---------------------------------------------------------------------
 [["fgt", 7, 10], 487, null, 521, "abc", [1, 2, 3], 4923, [1, 4, 7]]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN reverse([4923, 257, {test1: "key"}]) $$) as (u gtype);
               u               
-------------------------------
 [{"test1": "key"}, 257, 4923]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN reverse([4923, 257, {test2: [1, 2, 3]}]) $$) as (u gtype);
                 u                 
-----------------------------------
 [{"test2": [1, 2, 3]}, 257, 4923]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN reverse(true) $$) AS (results gtype);
 results 
---------
 "eurt"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN reverse(3.14) $$) AS (results gtype);
 results 
---------
 "41.3"
(1 row)

-- toUpper
SELECT * FROM cypher('expr', $$ RETURN toUpper('to uppercase') $$) AS (toUpper gtype);
    toupper     
----------------
 "TO UPPERCASE"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toUpper(null) $$) AS (toUpper gtype);
 toupper 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toUpper('') $$) AS (toUpper gtype);
 toupper 
---------
 ""
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toUpper(true) $$) AS (toUpper gtype);
 toupper 
---------
 "TRUE"
(1 row)

-- toLower
SELECT * FROM cypher('expr', $$ RETURN toLower('TO LOWERCASE') $$) AS (toLower gtype);
    tolower     
----------------
 "to lowercase"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toLower(null) $$) AS (toLower gtype);
 tolower 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN toLower(true) $$) AS (toLower gtype);
 tolower 
---------
 "true"
(1 row)

-- lTrim
SELECT * FROM cypher('expr', $$ RETURN lTrim("  string   ") $$) AS (results gtype);
   results   
-------------
 "string   "
(1 row)

SELECT * FROM cypher('expr', $$ RETURN lTrim(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN lTrim(true) $$) AS (results gtype);
 results 
---------
 "true"
(1 row)

-- rtrim
SELECT * FROM cypher('expr', $$ RETURN rTrim("  string   ") $$) AS (results gtype);
  results   
------------
 "  string"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN rTrim(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN rTrim(true) $$) AS (results gtype);
 results 
---------
 "true"
(1 row)

-- trim
SELECT * FROM cypher('expr', $$ RETURN trim("  string   ") $$) AS (results gtype);
 results  
----------
 "string"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN trim(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN trim(true) $$) AS (results gtype);
 results 
---------
 "true"
(1 row)

-- left
SELECT * FROM cypher('expr', $$ RETURN left("123456789", 1) $$) AS (results gtype);
 results 
---------
 "1"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN left("123456789", 3) $$) AS (results gtype);
 results 
---------
 "123"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN left("123456789", 0) $$) AS (results gtype);
 results 
---------
 ""
(1 row)

SELECT * FROM cypher('expr', $$ RETURN left(null, 1) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN left(null, null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN left("123456789", null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN left("123456789", -1) $$) AS (results gtype);
  results   
------------
 "12345678"
(1 row)

--right
SELECT * FROM cypher('expr', $$ RETURN right("123456789", 1) $$) AS (results gtype);
 results 
---------
 "9"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN right("123456789", 3) $$) AS (results gtype);
 results 
---------
 "789"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN right("123456789", 0) $$) AS (results gtype);
 results 
---------
 ""
(1 row)

SELECT * FROM cypher('expr', $$ RETURN right(null, 1) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN right(null, null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN right("123456789", null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN right("123456789", -1) $$) AS (results gtype);
  results   
------------
 "23456789"
(1 row)

-- substring
SELECT * FROM cypher('expr', $$ RETURN substring("0123456789", 0, 1) $$) AS (results gtype);
 results 
---------
 ""
(1 row)

SELECT * FROM cypher('expr', $$ RETURN substring("0123456789", 1, 3) $$) AS (results gtype);
 results 
---------
 "012"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN substring("0123456789", 3) $$) AS (results gtype);
  results   
------------
 "23456789"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN substring("0123456789", 0) $$) AS (results gtype);
   results    
--------------
 "0123456789"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN substring(null, null, null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN substring(null, null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN substring(null, 1) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN substring("123456789", null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN substring("123456789", 0, -1) $$) AS (results gtype);
ERROR:  negative substring length not allowed
SELECT * FROM cypher('expr', $$ RETURN substring("123456789", -1) $$) AS (results gtype);
   results   
-------------
 "123456789"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN substring("123456789") $$) AS (results gtype);
ERROR:  function postgraph.substring(gtype) does not exist
LINE 1: SELECT * FROM cypher('expr', $$ RETURN substring("123456789"...
                                               ^
HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
-- split
SELECT * FROM cypher('expr', $$ RETURN split("a,b,c,d,e,f", ",") $$) AS (results gtype);
            results             
--------------------------------
 ["a", "b", "c", "d", "e", "f"]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN split("a,b,c,d,e,f", "") $$) AS (results gtype);
                         results                         
---------------------------------------------------------
 ["a", ",", "b", ",", "c", ",", "d", ",", "e", ",", "f"]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN split("a,b,c,d,e,f", " ") $$) AS (results gtype);
     results     
-----------------
 ["a,b,c,d,e,f"]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN split("a,b,cd  e,f", " ") $$) AS (results gtype);
        results        
-----------------------
 ["a,b,cd", "", "e,f"]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN split("a,b,cd  e,f", "  ") $$) AS (results gtype);
      results      
-------------------
 ["a,b,cd", "e,f"]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN split("a,b,c,d,e,f", "c,") $$) AS (results gtype);
      results      
-------------------
 ["a,b,", "d,e,f"]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN split(null, null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN split("a,b,c,d,e,f", null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN split(null, ",") $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN split(123456789, ",") $$) AS (results gtype);
    results    
---------------
 ["123456789"]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN split("a,b,c,d,e,f", -1) $$) AS (results gtype);
     results     
-----------------
 ["a,b,c,d,e,f"]
(1 row)

SELECT * FROM cypher('expr', $$ RETURN split("a,b,c,d,e,f") $$) AS (results gtype);
ERROR:  function postgraph.split(gtype) does not exist
LINE 1: SELECT * FROM cypher('expr', $$ RETURN split("a,b,c,d,e,f") ...
                                               ^
HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
-- replace
SELECT * FROM cypher('expr', $$ RETURN replace("Hello", "lo", "p") $$) AS (results gtype);
 results 
---------
 "Help"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN replace("Hello", "hello", "Good bye") $$) AS (results gtype);
 results 
---------
 "Hello"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN replace("abcabcabc", "abc", "a") $$) AS (results gtype);
 results 
---------
 "aaa"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN replace("abcabcabc", "ab", "") $$) AS (results gtype);
 results 
---------
 "ccc"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN replace("ababab", "ab", "ab") $$) AS (results gtype);
 results  
----------
 "ababab"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN replace(null, null, null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN replace("Hello", null, null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN replace("Hello", "", null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN replace("", "", "") $$) AS (results gtype);
 results 
---------
 ""
(1 row)

SELECT * FROM cypher('expr', $$ RETURN replace("Hello", "Hello", "") $$) AS (results gtype);
 results 
---------
 ""
(1 row)

SELECT * FROM cypher('expr', $$ RETURN replace("", "Hello", "Mellow") $$) AS (results gtype);
 results 
---------
 ""
(1 row)

SELECT * FROM cypher('expr', $$ RETURN replace("Hello") $$) AS (results gtype);
ERROR:  function postgraph.replace(gtype) does not exist
LINE 1: SELECT * FROM cypher('expr', $$ RETURN replace("Hello") $$) ...
                                               ^
HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
SELECT * FROM cypher('expr', $$ RETURN replace("Hello", null) $$) AS (results gtype);
ERROR:  function postgraph.replace(gtype, gtype) does not exist
LINE 1: SELECT * FROM cypher('expr', $$ RETURN replace("Hello", null...
                                               ^
HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
SELECT * FROM cypher('expr', $$ RETURN replace("Hello", "e", 1) $$) AS (results gtype);
 results 
---------
 "H1llo"
(1 row)

SELECT * FROM cypher('expr', $$ RETURN replace("Hello", 1, "e") $$) AS (results gtype);
 results 
---------
 "Hello"
(1 row)

-- initCap
SELECT * FROM cypher('expr', $$ RETURN initCap("hello world") $$) AS (results gtype);
    results    
---------------
 "Hello World"
(1 row)

-- sin
SELECT sin::gtype = results FROM cypher('expr', $$ RETURN sin(3.1415) $$) AS (results gtype), sin(3.1415);
 ?column? 
----------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN sin(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN sin("0") $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

-- cos
SELECT cos::gtype = results FROM cypher('expr', $$ RETURN cos(3.1415) $$) AS (results gtype), cos(3.1415);
 ?column? 
----------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN cos(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN cos("0") $$) AS (results gtype);
 results 
---------
 1.0
(1 row)

-- tan
SELECT tan::gtype = results FROM cypher('expr', $$ RETURN tan(3.1415) $$) AS (results gtype), tan(3.1415);
 ?column? 
----------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN tan(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN tan("0") $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

-- cot
SELECT cot::gtype = results FROM cypher('expr', $$ RETURN cot(3.1415) $$) AS (results gtype), cot(3.1415);
 ?column? 
----------
 t
(1 row)

SELECT * FROM cypher('expr', $$ RETURN cot(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN cot("0") $$) AS (results gtype);
 results  
----------
 Infinity
(1 row)

-- asin
SELECT * FROM cypher('expr', $$ RETURN asin(1)*2 $$) AS (results gtype);
     results      
------------------
 3.14159265358979
(1 row)

SELECT * FROM cypher('expr', $$ RETURN asin(1.1) $$) AS (results gtype);
ERROR:  input is out of range
SELECT * FROM cypher('expr', $$ RETURN asin(-1.1) $$) AS (results gtype);
ERROR:  input is out of range
SELECT * FROM cypher('expr', $$ RETURN asin(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN asin("0") $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

-- acos
SELECT * FROM cypher('expr', $$ RETURN acos(0)*2 $$) AS (results gtype);
     results      
------------------
 3.14159265358979
(1 row)

SELECT * FROM cypher('expr', $$ RETURN acos(1.1) $$) AS (results gtype);
ERROR:  input is out of range
SELECT * FROM cypher('expr', $$ RETURN acos(-1.1) $$) AS (results gtype);
ERROR:  input is out of range
SELECT * FROM cypher('expr', $$ RETURN acos(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN acos("0") $$) AS (results gtype);
     results     
-----------------
 1.5707963267949
(1 row)

-- atan
SELECT * FROM cypher('expr', $$ RETURN atan(1)*4 $$) AS (results gtype);
     results      
------------------
 3.14159265358979
(1 row)

SELECT * FROM cypher('expr', $$ RETURN atan(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN atan("0") $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

-- atan2
SELECT * FROM cypher('expr', $$ RETURN atan2(1, 1)*4 $$) AS (results gtype);
     results      
------------------
 3.14159265358979
(1 row)

SELECT * FROM cypher('expr', $$ RETURN atan2(null, null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN atan2(null, 1) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN atan2(1, null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN atan2("0", 1) $$) AS (results gtype);
     results     
-----------------
 1.5707963267949
(1 row)

SELECT * FROM cypher('expr', $$ RETURN atan2(0, "1") $$) AS (results gtype);
     results     
-----------------
 1.5707963267949
(1 row)

-- pi
SELECT * FROM cypher('expr', $$ RETURN pi() $$) AS (results gtype);
     results      
------------------
 3.14159265358979
(1 row)

SELECT * FROM cypher('expr', $$ RETURN sin(pi()) $$) AS (results gtype);
       results        
----------------------
 1.22464679914735e-16
(1 row)

SELECT * FROM cypher('expr', $$ RETURN sin(pi()/4) $$) AS (results gtype);
      results      
-------------------
 0.707106781186547
(1 row)

SELECT * FROM cypher('expr', $$ RETURN cos(pi()) $$) AS (results gtype);
 results 
---------
 -1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN cos(pi()/2) $$) AS (results gtype);
       results        
----------------------
 6.12323399573677e-17
(1 row)

SELECT * FROM cypher('expr', $$ RETURN sin(pi()/2) $$) AS (results gtype);
 results 
---------
 1.0
(1 row)

-- radians
SELECT * FROM cypher('expr', $$ RETURN radians(0) $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN radians(360)$$) AS (results gtype);
     results      
------------------
 6.28318530717959
(1 row)

SELECT * FROM cypher('expr', $$ RETURN radians(180)$$) AS (results gtype);
     results      
------------------
 3.14159265358979
(1 row)

SELECT * FROM cypher('expr', $$ RETURN radians(90)$$) AS (results gtype);
     results     
-----------------
 1.5707963267949
(1 row)

SELECT * FROM cypher('expr', $$ RETURN radians(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN radians("1") $$) AS (results gtype);
      results       
--------------------
 0.0174532925199433
(1 row)

-- degrees
SELECT * FROM cypher('expr', $$ RETURN degrees(0) $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN degrees(2*pi()) $$) AS (results gtype);
 results 
---------
 360.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN degrees(pi()) $$) AS (results gtype);
 results 
---------
 180.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN degrees(pi()/2) $$) AS (results gtype);
 results 
---------
 90.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN degrees(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN degrees("1") $$) AS (results gtype);
     results      
------------------
 57.2957795130823
(1 row)

--sinh
SELECT results FROM cypher('expr', $$ RETURN sinh(3.1415) $$) AS (results gtype);
     results      
------------------
 11.5476653707437
(1 row)

SELECT results FROM cypher('expr', $$ RETURN sinh(pi()) $$) AS (results gtype);
     results      
------------------
 11.5487393572577
(1 row)

SELECT results FROM cypher('expr', $$ RETURN sinh(0) $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

SELECT results FROM cypher('expr', $$ RETURN sinh(1) $$) AS (results gtype);
     results     
-----------------
 1.1752011936438
(1 row)

--cosh
SELECT results FROM cypher('expr', $$ RETURN cosh(3.1415) $$) AS (results gtype);
     results      
------------------
 11.5908832931176
(1 row)

SELECT results FROM cypher('expr', $$ RETURN cosh(pi()) $$) AS (results gtype);
     results      
------------------
 11.5919532755215
(1 row)

SELECT results FROM cypher('expr', $$ RETURN cosh(0) $$) AS (results gtype);
 results 
---------
 1.0
(1 row)

SELECT results FROM cypher('expr', $$ RETURN cosh(1) $$) AS (results gtype);
     results      
------------------
 1.54308063481524
(1 row)

--tanh
SELECT results FROM cypher('expr', $$ RETURN tanh(3.1415) $$) AS (results gtype);
      results      
-------------------
 0.996271386633702
(1 row)

SELECT results FROM cypher('expr', $$ RETURN tanh(pi()) $$) AS (results gtype);
     results      
------------------
 0.99627207622075
(1 row)

SELECT results FROM cypher('expr', $$ RETURN tanh(0) $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

SELECT results FROM cypher('expr', $$ RETURN tanh(1) $$) AS (results gtype);
      results      
-------------------
 0.761594155955765
(1 row)

--asinh
SELECT results FROM cypher('expr', $$ RETURN asinh(3.1415) $$) AS (results gtype);
     results      
------------------
 1.86226763975997
(1 row)

SELECT results FROM cypher('expr', $$ RETURN asinh(pi()) $$) AS (results gtype);
     results      
------------------
 1.86229574331085
(1 row)

SELECT results FROM cypher('expr', $$ RETURN asinh(0) $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

SELECT results FROM cypher('expr', $$ RETURN asinh(1) $$) AS (results gtype);
      results      
-------------------
 0.881373587019543
(1 row)

--acosh
SELECT results FROM cypher('expr', $$ RETURN acosh(3.1415) $$) AS (results gtype);
     results      
------------------
 1.81149516122582
(1 row)

SELECT results FROM cypher('expr', $$ RETURN acosh(pi()) $$) AS (results gtype);
     results      
------------------
 1.81152627246085
(1 row)

SELECT results FROM cypher('expr', $$ RETURN acosh(0) $$) AS (results gtype);
ERROR:  input is out of range
SELECT results FROM cypher('expr', $$ RETURN acosh(1) $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

--atanh
SELECT results FROM cypher('expr', $$ RETURN atanh(3.1415) $$) AS (results gtype);
ERROR:  input is out of range
SELECT results FROM cypher('expr', $$ RETURN atanh(pi()) $$) AS (results gtype);
ERROR:  input is out of range
SELECT results FROM cypher('expr', $$ RETURN atanh(0) $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

SELECT results FROM cypher('expr', $$ RETURN atanh(1) $$) AS (results gtype);
 results  
----------
 Infinity
(1 row)

-- abs
SELECT * FROM cypher('expr', $$ RETURN abs(0) $$) AS (results gtype);
 results 
---------
 0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN abs(10) $$) AS (results gtype);
 results 
---------
 10
(1 row)

SELECT * FROM cypher('expr', $$ RETURN abs(-10) $$) AS (results gtype);
 results 
---------
 10
(1 row)

SELECT * FROM cypher('expr', $$ RETURN abs(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

-- ceil
SELECT * FROM cypher('expr', $$ RETURN ceil(0) $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ceil(1) $$) AS (results gtype);
 results 
---------
 1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ceil(-1) $$) AS (results gtype);
 results 
---------
 -1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ceil(1.01) $$) AS (results gtype);
 results 
---------
 2.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ceil(-1.01) $$) AS (results gtype);
 results 
---------
 -1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ceiling(-1.01) $$) AS (results gtype);
 results 
---------
 -1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ceil(-1.01::numeric) $$) AS (results gtype);
   results   
-------------
 -1::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ceil("1") $$) AS (results gtype);
 results 
---------
 1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN ceil(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

-- floor
SELECT * FROM cypher('expr', $$ RETURN floor(0) $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN floor(1) $$) AS (results gtype);
 results 
---------
 1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN floor(-1) $$) AS (results gtype);
 results 
---------
 -1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN floor(1.01) $$) AS (results gtype);
 results 
---------
 1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN floor(-1.01) $$) AS (results gtype);
 results 
---------
 -2.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN floor(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN floor("1") $$) AS (results gtype);
 results 
---------
 1.0
(1 row)

-- round
SELECT * FROM cypher('expr', $$ RETURN round(0) $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN round(4.49999999) $$) AS (results gtype);
 results 
---------
 4.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN round(4.5) $$) AS (results gtype);
 results 
---------
 4.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN round(-4.49999999) $$) AS (results gtype);
 results 
---------
 -4.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN round(-4.5) $$) AS (results gtype);
 results 
---------
 -4.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN round(7.4163, 3) $$) AS (results gtype);
    results     
----------------
 7.416::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN round(7.416343479, 8) $$) AS (results gtype);
       results       
---------------------
 7.41634348::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN round(7.416343479, NULL) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN round("1") $$) AS (results gtype);
 results 
---------
 1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN round(NULL, 7) $$) AS (results gtype);
 results 
---------
 
(1 row)

SELECT * FROM cypher('expr', $$ RETURN round(7, 2) $$) AS (results gtype);
    results    
---------------
 7.00::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN round(7.4342, 2.1123) $$) AS (results gtype);
    results    
---------------
 7.43::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN round(NULL, NULL) $$) AS (results gtype);
 results 
---------
 
(1 row)

-- sign
SELECT * FROM cypher('expr', $$ RETURN sign(10) $$) AS (results gtype);
 results 
---------
 1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN sign(-10) $$) AS (results gtype);
 results 
---------
 -1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN sign(0) $$) AS (results gtype);
 results 
---------
 0.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN sign("1") $$) AS (results gtype);
 results 
---------
 1.0
(1 row)

SELECT * FROM cypher('expr', $$ RETURN sign(null) $$) AS (results gtype);
 results 
---------
 
(1 row)

-- gcd
SELECT * FROM cypher('expr', $$ RETURN gcd(10, 5) $$) AS (results gtype);
 results 
---------
 5
(1 row)

SELECT * FROM cypher('expr', $$ RETURN gcd(10.0, 5.0) $$) AS (results gtype);
  results   
------------
 5::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN gcd(10.0, 5) $$) AS (results gtype);
  results   
------------
 5::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN gcd(10, 5::numeric) $$) AS (results gtype);
  results   
------------
 5::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN gcd('10', 5) $$) AS (results gtype);
 results 
---------
 5
(1 row)

-- lcm
SELECT * FROM cypher('expr', $$ RETURN lcm(10, 5) $$) AS (results gtype);
 results 
---------
 10
(1 row)

SELECT * FROM cypher('expr', $$ RETURN lcm(10.0, 5.0) $$) AS (results gtype);
   results   
-------------
 10::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN lcm(10.0, 5) $$) AS (results gtype);
   results   
-------------
 10::numeric
(1 row)

SELECT * FROM cypher('expr', $$ RETURN lcm('10', 5) $$) AS (results gtype);
 results 
---------
 10
(1 row)

SELECT * FROM cypher('expr', $$ RETURN lcm(10::numeric, '5') $$) AS (results gtype);
   results   
-------------
 10::numeric
(1 row)

-- rand() - should select 0 rows as rand() is in [0,1)
SELECT 1 FROM cypher('expr', $$ RETURN rand() $$) AS (result int) WHERE result >= 1 or result < 0;
 ?column? 
----------
(0 rows)

-- log (ln) 
SELECT * from cypher('expr', $$ RETURN log(2.718281828459045) $$) as (result gtype);
 result 
--------
 1.0
(1 row)

SELECT * from cypher('expr', $$ RETURN log(10) $$) as (result gtype);
      result      
------------------
 2.30258509299405
(1 row)

SELECT * from cypher('expr', $$ RETURN log(null) $$) as (result gtype);
 result 
--------
 
(1 row)

SELECT * from cypher('expr', $$ RETURN log(0) $$) as (result gtype);
ERROR:  cannot take logarithm of zero
SELECT * from cypher('expr', $$ RETURN log(-1) $$) as (result gtype);
ERROR:  cannot take logarithm of a negative number
-- log10
SELECT * from cypher('expr', $$ RETURN log10(10) $$) as (result gtype);
 result 
--------
 1.0
(1 row)

SELECT * from cypher('expr', $$ RETURN log10(null) $$) as (result gtype);
 result 
--------
 
(1 row)

SELECT * from cypher('expr', $$ RETURN log10(0) $$) as (result gtype);
ERROR:  cannot take logarithm of zero
SELECT * from cypher('expr', $$ RETURN log10(-1) $$) as (result gtype);
ERROR:  cannot take logarithm of a negative number
-- e
SELECT * from cypher('expr', $$ RETURN e() $$) as (result gtype);
      result      
------------------
 2.71828182845905
(1 row)

SELECT * from cypher('expr', $$ RETURN log(e()) $$) as (result gtype);
 result 
--------
 1.0
(1 row)

-- exp
SELECT * from cypher('expr', $$ RETURN exp(1) $$) as (result gtype);
      result      
------------------
 2.71828182845905
(1 row)

SELECT * from cypher('expr', $$ RETURN exp(0) $$) as (result gtype);
 result 
--------
 1.0
(1 row)

SELECT * from cypher('expr', $$ RETURN exp(null) $$) as (result gtype);
 result 
--------
 
(1 row)

SELECT * from cypher('expr', $$ RETURN exp("1") $$) as (result gtype);
      result      
------------------
 2.71828182845905
(1 row)

-- sqrt()
SELECT * from cypher('expr', $$ RETURN sqrt(25) $$) as (result gtype);
 result 
--------
 5.0
(1 row)

SELECT * from cypher('expr', $$ RETURN sqrt(1) $$) as (result gtype);
 result 
--------
 1.0
(1 row)

SELECT * from cypher('expr', $$ RETURN sqrt(0) $$) as (result gtype);
 result 
--------
 0.0
(1 row)

SELECT * from cypher('expr', $$ RETURN sqrt(-1) $$) as (result gtype);
ERROR:  cannot take square root of a negative number
SELECT * from cypher('expr', $$ RETURN sqrt(null) $$) as (result gtype);
 result 
--------
 
(1 row)

SELECT * from cypher('expr', $$ RETURN sqrt("1") $$) as (result gtype);
 result 
--------
 1.0
(1 row)

-- cbrt()
SELECT * from cypher('expr', $$ RETURN cbrt(125) $$) as (result gtype);
 result 
--------
 5.0
(1 row)

SELECT * from cypher('expr', $$ RETURN cbrt(1) $$) as (result gtype);
 result 
--------
 1.0
(1 row)

SELECT * from cypher('expr', $$ RETURN cbrt(0) $$) as (result gtype);
 result 
--------
 0.0
(1 row)

SELECT * from cypher('expr', $$ RETURN cbrt(-1) $$) as (result gtype);
 result 
--------
 -1.0
(1 row)

SELECT * from cypher('expr', $$ RETURN cbrt(null) $$) as (result gtype);
 result 
--------
 
(1 row)

SELECT * from cypher('expr', $$ RETURN cbrt("1") $$) as (result gtype);
 result 
--------
 1.0
(1 row)

-- factorial
SELECT * FROM cypher('expr', $$ RETURN factorial(10) $$) AS (results gtype);
     results      
------------------
 3628800::numeric
(1 row)

--CASE
SELECT create_graph('case_statement');
NOTICE:  graph "case_statement" has been created
 create_graph 
--------------
 
(1 row)

SELECT * FROM cypher('case_statement', $$CREATE ({i: 1, j: null})$$) AS (result gtype);
 result 
--------
(0 rows)

SELECT * FROM cypher('case_statement', $$CREATE ({i: 'a', j: 'b'})$$) AS (result gtype);
 result 
--------
(0 rows)

SELECT * FROM cypher('case_statement', $$CREATE ({i: 0, j: 1})$$) AS (result gtype);
 result 
--------
(0 rows)

SELECT * FROM cypher('case_statement', $$CREATE ({i: true, j: false})$$) AS (result gtype);
 result 
--------
(0 rows)

SELECT * FROM cypher('case_statement', $$CREATE ({i: [], j: [0,1,2]})$$) AS (result gtype);
 result 
--------
(0 rows)

SELECT * FROM cypher('case_statement', $$CREATE ({i: {}, j: {i:1}})$$) AS (result gtype);
 result 
--------
(0 rows)

SELECT * from cypher('expr', $$ RETURN 'test' LIKE 'test' $$) as (result boolean);
 result 
--------
 t
(1 row)

SELECT * from cypher('expr', $$ RETURN 'test' NOT LIKE 'test' $$) as (result boolean);
 result 
--------
 f
(1 row)

SELECT * from cypher('expr', $$ RETURN 'TEST' ILIKE 'test' $$) as (result boolean);
 result 
--------
 t
(1 row)

SELECT * from cypher('expr', $$ RETURN 'TEST' NOT ILIKE 'test' $$) as (result boolean);
 result 
--------
 f
(1 row)

--CASE WHEN condition THEN result END
SELECT * FROM cypher('case_statement', $$
	MATCH (n)
	RETURN n.i, n.j, CASE
    WHEN null THEN 'should not return me'
		WHEN n.i = 1 THEN 'i is 1'
		WHEN n.j = 'b' THEN 'j is b'
    WHEN n.i = 0 AND n.j = 1 THEN '0 AND 1'
    WHEN n.i = true OR n.j = true THEN 'i or j true'
		ELSE 'default'
	END
$$ ) AS (i gtype, j gtype, case_statement gtype);
  i   |     j     | case_statement 
------+-----------+----------------
 1    |           | "i is 1"
 "a"  | "b"       | "j is b"
 0    | 1         | "0 AND 1"
 true | false     | "i or j true"
 []   | [0, 1, 2] | "default"
 {}   | {"i": 1}  | "default"
(6 rows)

--CASE expression WHEN value THEN result END
SELECT * FROM cypher('case_statement', $$
	MATCH (n)
	RETURN n.j, CASE n.j
    WHEN null THEN 'should not return me'
    WHEN 'b' THEN 'b'
    WHEN 1 THEN 1
    WHEN false THEN false
    WHEN [0,1,2] THEN [0,1,2]
    WHEN {i:1} THEN {i:1}
		ELSE 'not a or b'
	END
$$ ) AS (j gtype, case_statement gtype);
     j     | case_statement 
-----------+----------------
           | "not a or b"
 "b"       | "b"
 1         | 1
 false     | false
 [0, 1, 2] | [0, 1, 2]
 {"i": 1}  | {"i": 1}
(6 rows)

--
-- Cleanup
--
SELECT * FROM drop_graph('case_statement', true);
NOTICE:  drop cascades to 2 other objects
DETAIL:  drop cascades to table case_statement._ag_label_vertex
drop cascades to table case_statement._ag_label_edge
NOTICE:  graph "case_statement" has been dropped
 drop_graph 
------------
 
(1 row)

SELECT * FROM drop_graph('type_coercion', true);
NOTICE:  drop cascades to 2 other objects
DETAIL:  drop cascades to table type_coercion._ag_label_vertex
drop cascades to table type_coercion._ag_label_edge
NOTICE:  graph "type_coercion" has been dropped
 drop_graph 
------------
 
(1 row)

SELECT * FROM drop_graph('expr', true);
NOTICE:  drop cascades to 2 other objects
DETAIL:  drop cascades to table expr._ag_label_vertex
drop cascades to table expr._ag_label_edge
NOTICE:  graph "expr" has been dropped
 drop_graph 
------------
 
(1 row)

--
-- End of tests
--