LCOV - code coverage report
Current view: top level - src/pl/plperl - SPI.xs (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 54 59 91.5 %
Date: 2019-11-13 22:07:24 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : /**********************************************************************
       2             :  * PostgreSQL::InServer::SPI
       3             :  *
       4             :  * SPI interface for plperl.
       5             :  *
       6             :  *    src/pl/plperl/SPI.xs
       7             :  *
       8             :  **********************************************************************/
       9             : 
      10             : /* this must be first: */
      11             : #include "postgres.h"
      12             : 
      13             : /* perl stuff */
      14             : #define PG_NEED_PERL_XSUB_H
      15             : #include "plperl.h"
      16             : #include "plperl_helpers.h"
      17             : 
      18             : 
      19             : MODULE = PostgreSQL::InServer::SPI PREFIX = spi_
      20             : 
      21             : PROTOTYPES: ENABLE
      22             : VERSIONCHECK: DISABLE
      23             : 
      24             : SV*
      25             : spi_spi_exec_query(sv, ...)
      26             :     SV* sv;
      27             :     PREINIT:
      28             :         HV *ret_hash;
      29         100 :         int limit = 0;
      30             :         char *query;
      31             :     CODE:
      32         100 :         if (items > 2)
      33           0 :             croak("Usage: spi_exec_query(query, limit) "
      34             :                   "or spi_exec_query(query)");
      35         100 :         if (items == 2)
      36           0 :             limit = SvIV(ST(1));
      37         100 :         query = sv2cstr(sv);
      38         100 :         ret_hash = plperl_spi_exec(query, limit);
      39          88 :         pfree(query);
      40          88 :         RETVAL = newRV_noinc((SV*) ret_hash);
      41             :     OUTPUT:
      42             :         RETVAL
      43             : 
      44             : void
      45             : spi_return_next(rv)
      46             :     SV *rv;
      47             :     CODE:
      48         174 :         plperl_return_next(rv);
      49             : 
      50             : SV *
      51             : spi_spi_query(sv)
      52             :     SV *sv;
      53             :     CODE:
      54          18 :         char* query = sv2cstr(sv);
      55          18 :         RETVAL = plperl_spi_query(query);
      56          18 :         pfree(query);
      57             :     OUTPUT:
      58             :         RETVAL
      59             : 
      60             : SV *
      61             : spi_spi_fetchrow(sv)
      62             :     SV* sv;
      63             :     CODE:
      64          72 :         char* cursor = sv2cstr(sv);
      65          72 :         RETVAL = plperl_spi_fetchrow(cursor);
      66          72 :         pfree(cursor);
      67             :     OUTPUT:
      68             :         RETVAL
      69             : 
      70             : SV*
      71             : spi_spi_prepare(sv, ...)
      72             :     SV* sv;
      73             :     CODE:
      74             :         int i;
      75             :         SV** argv;
      76          16 :         char* query = sv2cstr(sv);
      77          16 :         if (items < 1)
      78           0 :             Perl_croak(aTHX_ "Usage: spi_prepare(query, ...)");
      79          16 :         argv = ( SV**) palloc(( items - 1) * sizeof(SV*));
      80          32 :         for ( i = 1; i < items; i++)
      81          16 :             argv[i - 1] = ST(i);
      82          16 :         RETVAL = plperl_spi_prepare(query, items - 1, argv);
      83          14 :         pfree( argv);
      84          14 :         pfree(query);
      85             :     OUTPUT:
      86             :         RETVAL
      87             : 
      88             : SV*
      89             : spi_spi_exec_prepared(sv, ...)
      90             :     SV* sv;
      91             :     PREINIT:
      92             :         HV *ret_hash;
      93             :     CODE:
      94          12 :         HV *attr = NULL;
      95          12 :         int i, offset = 1, argc;
      96             :         SV ** argv;
      97          12 :         char *query = sv2cstr(sv);
      98          12 :         if ( items < 1)
      99           0 :             Perl_croak(aTHX_ "Usage: spi_exec_prepared(query, [\\%%attr,] "
     100             :                        "[\\@bind_values])");
     101          12 :         if ( items > 1 && SvROK( ST( 1)) && SvTYPE( SvRV( ST( 1))) == SVt_PVHV)
     102             :         {
     103           4 :             attr = ( HV*) SvRV(ST(1));
     104           4 :             offset++;
     105             :         }
     106          12 :         argc = items - offset;
     107          12 :         argv = ( SV**) palloc( argc * sizeof(SV*));
     108          20 :         for ( i = 0; offset < items; offset++, i++)
     109           8 :             argv[i] = ST(offset);
     110          12 :         ret_hash = plperl_spi_exec_prepared(query, attr, argc, argv);
     111          12 :         RETVAL = newRV_noinc((SV*)ret_hash);
     112          12 :         pfree( argv);
     113          12 :         pfree(query);
     114             :     OUTPUT:
     115             :         RETVAL
     116             : 
     117             : SV*
     118             : spi_spi_query_prepared(sv, ...)
     119             :     SV * sv;
     120             :     CODE:
     121             :         int i;
     122             :         SV ** argv;
     123           4 :         char *query = sv2cstr(sv);
     124           4 :         if ( items < 1)
     125           0 :             Perl_croak(aTHX_ "Usage: spi_query_prepared(query, "
     126             :                        "[\\@bind_values])");
     127           4 :         argv = ( SV**) palloc(( items - 1) * sizeof(SV*));
     128          10 :         for ( i = 1; i < items; i++)
     129           6 :             argv[i - 1] = ST(i);
     130           4 :         RETVAL = plperl_spi_query_prepared(query, items - 1, argv);
     131           4 :         pfree( argv);
     132           4 :         pfree(query);
     133             :     OUTPUT:
     134             :         RETVAL
     135             : 
     136             : void
     137             : spi_spi_freeplan(sv)
     138             :     SV *sv;
     139             :     CODE:
     140          10 :         char *query = sv2cstr(sv);
     141          10 :         plperl_spi_freeplan(query);
     142          10 :         pfree(query);
     143             : 
     144             : void
     145             : spi_spi_cursor_close(sv)
     146             :     SV *sv;
     147             :     CODE:
     148           2 :         char *cursor = sv2cstr(sv);
     149           2 :         plperl_spi_cursor_close(cursor);
     150           2 :         pfree(cursor);
     151             : 
     152             : void
     153             : spi_spi_commit()
     154             :     CODE:
     155          46 :         plperl_spi_commit();
     156             : 
     157             : void
     158             : spi_spi_rollback()
     159             :     CODE:
     160          34 :         plperl_spi_rollback();
     161             : 
     162             : BOOT:
     163          32 :     items = 0;  /* avoid 'unused variable' warning */

Generated by: LCOV version 1.13