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