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              :         HV *ret_hash;
      28           57 :         int limit = 0;
      29              :         char *query;
      30              :     CODE:
      31           57 :         if (items > 2)
      32            0 :             croak("Usage: spi_exec_query(query, limit) "
      33              :                   "or spi_exec_query(query)");
      34           57 :         if (items == 2)
      35            0 :             limit = SvIV(ST(1));
      36           57 :         query = sv2cstr(sv);
      37           57 :         ret_hash = plperl_spi_exec(query, limit);
      38           51 :         pfree(query);
      39           51 :         RETVAL = newRV_noinc((SV*) ret_hash);
      40              :     OUTPUT:
      41              :         RETVAL
      42              : 
      43              : void
      44              : spi_return_next(rv)
      45              :     SV *rv;
      46              :     CODE:
      47           87 :         plperl_return_next(rv);
      48              : 
      49              : SV *
      50              : spi_spi_query(sv)
      51              :     SV *sv;
      52              :     CODE:
      53            9 :         char* query = sv2cstr(sv);
      54            9 :         RETVAL = plperl_spi_query(query);
      55            9 :         pfree(query);
      56              :     OUTPUT:
      57              :         RETVAL
      58              : 
      59              : SV *
      60              : spi_spi_fetchrow(sv)
      61              :     SV* sv;
      62              :     CODE:
      63           36 :         char* cursor = sv2cstr(sv);
      64           36 :         RETVAL = plperl_spi_fetchrow(cursor);
      65           36 :         pfree(cursor);
      66              :     OUTPUT:
      67              :         RETVAL
      68              : 
      69              : SV*
      70              : spi_spi_prepare(sv, ...)
      71              :     SV* sv;
      72              :     CODE:
      73              :         int i;
      74              :         SV** argv;
      75            8 :         char* query = sv2cstr(sv);
      76            8 :         if (items < 1)
      77            0 :             Perl_croak(aTHX_ "Usage: spi_prepare(query, ...)");
      78            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            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              :     CODE:
      93            6 :         HV *attr = NULL;
      94            6 :         int i, offset = 1, argc;
      95              :         SV ** argv;
      96            6 :         char *query = sv2cstr(sv);
      97            6 :         if ( items < 1)
      98            0 :             Perl_croak(aTHX_ "Usage: spi_exec_prepared(query, [\\%%attr,] "
      99              :                        "[\\@bind_values])");
     100            6 :         if ( items > 1 && SvROK( ST( 1)) && SvTYPE( SvRV( ST( 1))) == SVt_PVHV)
     101              :         {
     102            2 :             attr = ( HV*) SvRV(ST(1));
     103            2 :             offset++;
     104              :         }
     105            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            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              :         SV ** argv;
     122            2 :         char *query = sv2cstr(sv);
     123            2 :         if ( items < 1)
     124            0 :             Perl_croak(aTHX_ "Usage: spi_query_prepared(query, "
     125              :                        "[\\@bind_values])");
     126            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            2 :         pfree(query);
     132              :     OUTPUT:
     133              :         RETVAL
     134              : 
     135              : void
     136              : spi_spi_freeplan(sv)
     137              :     SV *sv;
     138              :     CODE:
     139            5 :         char *query = sv2cstr(sv);
     140            5 :         plperl_spi_freeplan(query);
     141            5 :         pfree(query);
     142              : 
     143              : void
     144              : spi_spi_cursor_close(sv)
     145              :     SV *sv;
     146              :     CODE:
     147            1 :         char *cursor = sv2cstr(sv);
     148            1 :         plperl_spi_cursor_close(cursor);
     149            1 :         pfree(cursor);
     150              : 
     151              : void
     152              : spi_spi_commit()
     153              :     CODE:
     154           25 :         plperl_spi_commit();
     155              : 
     156              : void
     157              : spi_spi_rollback()
     158              :     CODE:
     159           17 :         plperl_spi_rollback();
     160              : 
     161              : BOOT:
     162           23 :     items = 0;  /* avoid 'unused variable' warning */