--
-- Error model: how Ruby exceptions and PostgreSQL errors interact, what is
-- preserved when a database error is caught, and what is not.
--
-- A specific exception class's message is preserved when it propagates out.
CREATE FUNCTION es_custom() RETURNS int LANGUAGE plruby AS $$
    raise ArgumentError, 'custom failure'
$$;
SELECT es_custom();
ERROR:  custom failure
CONTEXT:  PL/Ruby function "es_custom"
-- A caught database error: it is a StandardError, its message names the
-- offending object, its SQLSTATE is exposed, and the session keeps working
-- afterwards.
CREATE FUNCTION es_caught() RETURNS text LANGUAGE plruby AS $$
    begin
        spi_exec('select * from missing_relation_xyz')
        'no error'
    rescue => e
        "std=#{e.is_a?(StandardError)} names_it=#{e.message.include?('missing_relation_xyz')} sqlstate=#{e.sqlstate}"
    end
$$;
SELECT es_caught();
               es_caught               
---------------------------------------
 std=true names_it=true sqlstate=42P01
(1 row)

-- The SQLSTATE reflects the error class (division_by_zero here).  A
-- PLRuby::Error not backed by a database error (elog) has a nil sqlstate,
-- and an ordinary Ruby exception has no sqlstate method at all.
CREATE FUNCTION es_sqlstate() RETURNS text LANGUAGE plruby AS $$
    db = begin
             spi_exec('select 1 / 0')
             'no error'
         rescue => e
             e.sqlstate
         end
    pl = begin
             elog('ERROR', 'synthetic')
         rescue PLRuby::Error => e
             e.sqlstate.inspect
         end
    rb = begin
             raise 'plain ruby error'
         rescue => e
             e.respond_to?(:sqlstate) ? 'has method' : 'no method'
         end
    "db=#{db} elog=#{pl} ruby=#{rb}"
$$;
SELECT es_sqlstate();
           es_sqlstate            
----------------------------------
 db=22012 elog=nil ruby=no method
(1 row)

-- An ensure block runs on both the success and the rescue path.
CREATE FUNCTION es_ensure(boolean) RETURNS text LANGUAGE plruby AS $$
    log = []
    r = begin
            raise 'boom' if args[0]
            'ok'
        rescue
            'rescued'
        ensure
            log << 'ensured'
        end
    "#{r}:#{log.join}"
$$;
SELECT es_ensure(false);
 es_ensure  
------------
 ok:ensured
(1 row)

SELECT es_ensure(true);
    es_ensure    
-----------------
 rescued:ensured
(1 row)

-- pg_raise can attach DETAIL, HINT, and a specific SQLSTATE...
CREATE FUNCTION es_structured() RETURNS void LANGUAGE plruby AS $$
    pg_raise('ERROR', 'order rejected',
             detail: 'order 42 exceeds the credit limit',
             hint: 'raise the limit or split the order',
             sqlstate: 'P0001')
$$;
SELECT es_structured();
ERROR:  order rejected
DETAIL:  order 42 exceeds the credit limit
HINT:  raise the limit or split the order
CONTEXT:  PL/Ruby function "es_structured"
-- ...and a caller that rescues the resulting database error sees all three.
CREATE FUNCTION es_catch_structured() RETURNS text LANGUAGE plruby AS $$
    begin
        spi_exec('select es_structured()')
        'no error'
    rescue PLRuby::Error => e
        "state=#{e.sqlstate} detail=#{e.detail} hint=#{e.hint}"
    end
$$;
SELECT es_catch_structured();
                                     es_catch_structured                                      
----------------------------------------------------------------------------------------------
 state=P0001 detail=order 42 exceeds the credit limit hint=raise the limit or split the order
(1 row)

-- Non-error levels emit the fields directly.
CREATE FUNCTION es_notice_fields() RETURNS void LANGUAGE plruby AS $$
    pg_raise('NOTICE', 'heads up', detail: 'the details', hint: 'the hint')
$$;
SELECT es_notice_fields();
NOTICE:  heads up
DETAIL:  the details
HINT:  the hint
 es_notice_fields 
------------------
 
(1 row)

-- An invalid sqlstate is rejected at the call.
CREATE FUNCTION es_badstate() RETURNS void LANGUAGE plruby AS $$
    pg_raise('ERROR', 'nope', sqlstate: 'abc')
$$;
SELECT es_badstate();
ERROR:  pg_raise: invalid sqlstate "abc"
CONTEXT:  PL/Ruby function "es_badstate"
-- pg_raise and elog both reject an unknown level with a PL/Ruby error.
CREATE FUNCTION es_badraise() RETURNS void LANGUAGE plruby AS $$
    pg_raise('BOGUS', 'nope')
$$;
SELECT es_badraise();
ERROR:  pg_raise: incorrect log level "BOGUS"
CONTEXT:  PL/Ruby function "es_badraise"
CREATE FUNCTION es_badelog() RETURNS void LANGUAGE plruby AS $$
    elog('BOGUS', 'nope')
$$;
SELECT es_badelog();
ERROR:  elog: unrecognized level "BOGUS"
CONTEXT:  PL/Ruby function "es_badelog"