view release on metacpan or  search on metacpan

dbd/dbd.xs.in  view on Meta::CPAN

MODULE = DBD::~~dbd_driver~~	PACKAGE = DBD::~~dbd_driver~~

double
constant(name, arg)
    char* name
    char* arg
  CODE:
    RETVAL = mymsql_constant(name, arg);
  OUTPUT:
    RETVAL

#if defined(DBD_MSQL) && defined(IDX_TYPE) && defined(HAVE_STRPTIME)

char*
unixtimetodate(package = Package, clock)
    time_t clock
  PROTOTYPE: $$
  CODE:
    RETVAL = msqlUnixTimeToDate(clock);
  OUTPUT:
    RETVAL

char*
unixtimetotime(package = Package, clock)
    time_t clock
  PROTOTYPE: $$
  CODE:
    RETVAL = msqlUnixTimeToTime(clock);
  OUTPUT:
    RETVAL

time_t
datetounixtime(package = Package, clock)
    char* clock
  PROTOTYPE: $$
  CODE:
    RETVAL = msqlDateToUnixTime(clock);
  OUTPUT:
    RETVAL

time_t
timetounixtime(package = Package, clock)
    char* clock
  PROTOTYPE: $$
  CODE:
    RETVAL = msqlTimeToUnixTime(clock);
  OUTPUT:
    RETVAL

#endif /* defined(DBD_MSQL) && defined(IDX_TYPE) && defined(HAVE_STRPTIME) */


MODULE = DBD::~~dbd_driver~~	PACKAGE = DBD::~~dbd_driver~~::dr

void
_ListDBs(drh, host, port=NULL)
    SV *        drh
    char *	host
    char *      port
  PPCODE:
{
#if defined(DBD_MYSQL)
    MYSQL mysql;
    dbh_t sock = &mysql;
#elif defined(DBD_MSQL)
    dbh_t sock;
#endif
    if (MyConnect(&sock,NULL,host,port,NULL,NULL,NULL,NULL)) {
        result_t res;
        row_t cur;
        res = MyListDbs(sock);
        if (!res) {
            do_error(drh, MyErrno(sock, JW_ERR_LIST_DB), MyError(sock));
        } else {
            EXTEND(sp, MyNumRows(res));
	    while ((cur = MyFetchRow(res))) {
	        PUSHs(sv_2mortal((SV*)newSVpv(cur[0], strlen(cur[0]))));
	    }
	    MyFreeResult(res);
        }
        MyClose(sock);
    }
}


void
_admin_internal(drh,dbh,command,dbname=NULL,host=NULL,port=NULL,user=NULL,password=NULL)
    SV* drh
    SV* dbh
    char* command
    char* dbname
    char* host
    char* port
    char* user
    char* password
  PPCODE:
    {
        dbh_t sock;
	int result;
#if defined(DBD_MYSQL)
	MYSQL mysql;
	sock = &mysql;
#endif

	/*
	 *  Connect to the database, if required.
	 */
	if (SvOK(dbh)) {
	    D_imp_dbh(dbh);
	    sock = imp_dbh->svsock;
	} else {
	    if (!MyConnect(&sock,NULL,host,port,user,password,NULL,NULL)) {
	        do_error(drh, MyErrno(sock, JW_ERR_CONNECT), MyError(sock));
		XSRETURN_NO;
	    }
       }
 
       if (strEQ(command, "shutdown")) {
	   result = MyShutdown(sock);
       } else if (strEQ(command, "reload")) {
	   result = MyReload(sock);
       } else if (strEQ(command, "createdb")) {
#ifdef MyCreateDb
	   result = MyCreateDb(sock, dbname);
#else
	   char* buffer = malloc(strlen(dbname)+50);
	   if (buffer == NULL) {
	     do_error(drh, JW_ERR_MEM, "Out of memory");
	     XSRETURN_NO;
	   } else {
	     strcpy(buffer, "CREATE DATABASE ");
	     strcat(buffer, dbname);
	     result = mysql_query(sock, buffer);
	     free(buffer);
	   }
#endif
       } else if (strEQ(command, "dropdb")) {
#ifdef MyDropDb
          result = MyDropDb(sock, dbname);
#else
	   char* buffer = malloc(strlen(dbname)+50);
	   if (buffer == NULL) {
	     do_error(drh, JW_ERR_MEM, "Out of memory");
	     XSRETURN_NO;
	   } else {
	     strcpy(buffer, "DROP DATABASE ");
	     strcat(buffer, dbname);
	     result = mysql_query(sock, buffer);
	     free(buffer);
	   }
#endif
       } else {
	  croak("Unknown command: %s", command);
       }
#if defined(DBD_MYSQL)
       if (result) {
#elif defined(DBD_MSQL)
       if (result < 0) {
#endif
	   do_error(SvOK(dbh) ? dbh : drh, MyErrno(sock, JW_ERR_LIST_DB),
		    MyError(sock));
	   result = 0;
       } else {
	   result = 1;
       }
       if (SvOK(dbh)) {
	   MyClose(sock);
       }
       if (result) { XSRETURN_YES; } else { XSRETURN_NO; }
   }


MODULE = DBD::~~dbd_driver~~    PACKAGE = DBD::~~dbd_driver~~::db


void
type_info_all(dbh)
    SV* dbh
  PPCODE:
    {
/* 	static AV* types = NULL; */
/* 	if (!types) { */
/* 	    D_imp_dbh(dbh); */
/* 	    if (!(types = dbd_db_type_info_all(dbh, imp_dbh))) { */
/* 	        croak("Cannot create types array (out of memory?)"); */
/* 	    } */
/* 	} */
/* 	ST(0) = sv_2mortal(newRV_inc((SV*) types)); */
        D_imp_dbh(dbh);
	ST(0) = sv_2mortal(newRV_noinc((SV*) dbd_db_type_info_all(dbh,
								  imp_dbh)));
	XSRETURN(1);
    }


#if defined(DBD_MYSQL)

void
_InsertID(dbh)
    SV *	dbh
  CODE:
    D_imp_dbh(dbh);
    char buf[64];
    SV* sv = perl_get_sv("DBD::mysql::QUIET", FALSE);
    MYSQL *sock = (MYSQL*) imp_dbh->svsock;
    if (!sv  ||  !SvTRUE(sv)) {  /* 1.21_07 */
        warn("This method is deprecated. Use $dbh->{'mysql_insertid'}.");
    }
    sprintf(buf, "%lu", mysql_insert_id(sock));
    ST(0) = sv_2mortal(newSVpv(buf, strlen(buf)));

#endif

void
_ListDBs(dbh)
    SV*	dbh
  PPCODE:
    D_imp_dbh(dbh);
    result_t res;
    row_t cur;
    res = MyListDbs(imp_dbh->svsock);
    if (!res  &&  (!MyReconnect(imp_dbh->svsock, dbh)
		   ||  !(res = MyListDbs(imp_dbh->svsock)))) {
        do_error(dbh, MyErrno(imp_dbh->svsock, JW_ERR_LIST_DB),
		 MyError(imp_dbh->svsock));
    } else {
        EXTEND(sp, MyNumRows(res));
	while ((cur = MyFetchRow(res))) {
	    PUSHs(sv_2mortal((SV*)newSVpv(cur[0], strlen(cur[0]))));
	}
	MyFreeResult(res);
    }


void
_ListTables(dbh)
    SV *	dbh
    PPCODE:
    D_imp_dbh(dbh);
    result_t res;
    row_t cur;
    res = MyListTables(imp_dbh->svsock);
    if (!res  &&  (!MyReconnect(imp_dbh->svsock, dbh)
		   ||  !(res = MyListTables(imp_dbh->svsock)))) {
        do_error(dbh, MyErrno(imp_dbh->svsock, JW_ERR_LIST_TABLES),
		 MyError(imp_dbh->svsock));
    } else {
        while ((cur = MyFetchRow(res))) {
            XPUSHs(sv_2mortal((SV*)newSVpv( cur[0], strlen(cur[0]))));
        }
        MyFreeResult(res);
    }
 

void
do(dbh, statement, attr=Nullsv, ...)
    SV *        dbh
    SV *	statement
    SV *        attr
  PROTOTYPE: $$;$@      
  CODE:
{
    D_imp_dbh(dbh);
    struct imp_sth_ph_st* params = NULL;
    int numParams = 0;
    result_t cda = NULL;
    int retval;

    if (items > 3) {
       	/*  Handle binding supplied values to placeholders	     */
	/*  Assume user has passed the correct number of parameters  */
	int i;
	numParams = items-3;
	Newz(0, params, sizeof(*params)*numParams, struct imp_sth_ph_st);
	for (i = 0;  i < numParams;  i++) {
	    params[i].value = ST(i+3);
	    params[i].type = SQL_VARCHAR;
	}
    }
    retval = dbd_st_internal_execute(dbh, statement, attr, numParams,
				     params, &cda, imp_dbh->svsock, 0);
    Safefree(params);
    if (cda) {
	MyFreeResult(cda);
    }
    /* remember that dbd_st_execute must return <= -2 for error	*/
    if (retval == 0)		/* ok with no rows affected	*/
	XST_mPV(0, "0E0");	/* (true but zero)		*/
    else if (retval < -1)	/* -1 == unknown number of rows	*/
	XST_mUNDEF(0);		/* <= -2 means error   		*/
    else
	XST_mIV(0, retval);	/* typically 1, rowcount or -1	*/
}


SV*
ping(dbh)
    SV* dbh;
  PROTOTYPE: $
  CODE:
    {
        int result;
	D_imp_dbh(dbh);
#if defined(DBD_MYSQL)
	result = (mysql_ping(imp_dbh->svsock) == 0);
	if (!result  &&  MyReconnect(imp_dbh->svsock, dbh)) {
	    result = (mysql_ping(imp_dbh->svsock) == 0);
	}
#elif defined(DBD_MSQL)
	result = TRUE;
#endif
	RETVAL = boolSV(result);
    }
  OUTPUT:
    RETVAL



void
quote(dbh, str, type=NULL)
    SV* dbh
    SV* str
    SV* type
  PROTOTYPE: $$;$
  PPCODE:
    {
        SV* quoted = dbd_db_quote(dbh, str, type);
	ST(0) = quoted ? sv_2mortal(quoted) : str;
	XSRETURN(1);
    }


#if defined(DBD_MSQL) && defined(IDX_TYPE)

void
getsequenceinfo(dbh, table)
    SV* dbh
    char* table
  PROTOTYPE: $$
  PPCODE:
  {
    m_seq* seq;
    D_imp_dbh(dbh);
    seq = msqlGetSequenceInfo(imp_dbh->svsock, table);
    if (!seq) {
        do_error(dbh, MyErrno(sock, JW_ERR_SEQUENCE), MyError(sock));
	XSRETURN_UNDEF;
    } else {
        EXTEND(sp, 2);
	ST(0) = sv_2mortal(newSViv(seq->step));
	ST(1) = sv_2mortal(newSViv(seq->value));
	XSRETURN(2);
	Safefree(seq);
    }
  }

#endif /* defined(DBD_MSQL) && defined(IDX_TYPE) */

MODULE = DBD::~~dbd_driver~~    PACKAGE = DBD::~~dbd_driver~~::st

int
dataseek(sth, pos)
    SV* sth
    int pos
  PROTOTYPE: $$
  CODE:
{
    D_imp_sth(sth);
    if (imp_sth->cda) {
        MyDataSeek(imp_sth->cda, pos);
	RETVAL = 1;
    } else {
        RETVAL = 0;
	do_error(sth, JW_ERR_NOT_ACTIVE, "Statement not active");
    }
}
  OUTPUT:
    RETVAL


void
rows(sth)
    SV* sth
  CODE:
    D_imp_sth(sth);
    char buf[64];
    sprintf(buf, "%lu", imp_sth->row_num);
    ST(0) = sv_2mortal(newSVpvn(buf, strlen(buf)));