Permalink
Fetching contributors…
Cannot retrieve contributors at this time
executable file 935 lines (831 sloc) 22.1 KB
/* Hej, Emacs, this is -*- C -*- mode!
$Id$
Copyright (c) 2003 Rudolf Lippan
Copyright (c) 1997-2003 Jochen Wiedmann
You may distribute under the terms of either the GNU General Public
License or the Artistic License, as specified in the Perl README file.
*/
#include "dbdimp.h"
#include "constants.h"
#include <errno.h>
#include <string.h>
#if MYSQL_ASYNC
# define ASYNC_CHECK_XS(h)\
if(imp_dbh->async_query_in_flight) {\
do_error(h, 2000, "Calling a synchronous function on an asynchronous handle", "HY000");\
XSRETURN_UNDEF;\
}
#else
# define ASYNC_CHECK_XS(h)
#endif
DBISTATE_DECLARE;
MODULE = DBD::mysql PACKAGE = DBD::mysql
INCLUDE: mysql.xsi
MODULE = DBD::mysql PACKAGE = DBD::mysql
double
constant(name, arg)
char* name
char* arg
CODE:
RETVAL = mysql_constant(name, arg);
OUTPUT:
RETVAL
MODULE = DBD::mysql PACKAGE = DBD::mysql::dr
void
_ListDBs(drh, host=NULL, port=NULL, user=NULL, password=NULL)
SV * drh
char * host
char * port
char * user
char * password
PPCODE:
{
MYSQL mysql;
MYSQL* sock = mysql_dr_connect(drh, &mysql, NULL, host, port, user, password,
NULL, NULL);
if (sock != NULL)
{
MYSQL_ROW cur;
MYSQL_RES* res = mysql_list_dbs(sock, NULL);
if (!res)
{
do_error(drh, mysql_errno(sock), mysql_error(sock), mysql_sqlstate(sock));
}
else
{
EXTEND(sp, mysql_num_rows(res));
while ((cur = mysql_fetch_row(res)))
{
PUSHs(sv_2mortal((SV*)newSVpv(cur[0], strlen(cur[0]))));
}
mysql_free_result(res);
}
mysql_close(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:
{
MYSQL mysql;
int retval;
MYSQL* sock;
/*
* Connect to the database, if required.
*/
if (SvOK(dbh)) {
D_imp_dbh(dbh);
sock = imp_dbh->pmysql;
}
else
{
sock = mysql_dr_connect(drh, &mysql, NULL, host, port, user, password, NULL, NULL);
if (sock == NULL)
{
do_error(drh, mysql_errno(&mysql), mysql_error(&mysql),
mysql_sqlstate(&mysql));
XSRETURN_NO;
}
}
if (strEQ(command, "shutdown"))
#if MYSQL_VERSION_ID < 40103
retval = mysql_shutdown(sock);
#else
retval = mysql_shutdown(sock, SHUTDOWN_DEFAULT);
#endif
else if (strEQ(command, "reload"))
retval = mysql_reload(sock);
else if (strEQ(command, "createdb"))
{
#if MYSQL_VERSION_ID < 40000
retval = mysql_create_db(sock, dbname);
#else
char* buffer = malloc(strlen(dbname)+50);
if (buffer == NULL)
{
do_error(drh, JW_ERR_MEM, "Out of memory" ,NULL);
XSRETURN_NO;
}
else
{
strcpy(buffer, "CREATE DATABASE ");
strcat(buffer, dbname);
retval = mysql_real_query(sock, buffer, strlen(buffer));
free(buffer);
}
#endif
}
else if (strEQ(command, "dropdb"))
{
#if MYSQL_VERSION_ID < 40000
retval = mysql_drop_db(sock, dbname);
#else
char* buffer = malloc(strlen(dbname)+50);
if (buffer == NULL)
{
do_error(drh, JW_ERR_MEM, "Out of memory" ,NULL);
XSRETURN_NO;
}
else
{
strcpy(buffer, "DROP DATABASE ");
strcat(buffer, dbname);
retval = mysql_real_query(sock, buffer, strlen(buffer));
free(buffer);
}
#endif
}
else
{
croak("Unknown command: %s", command);
}
if (retval)
{
do_error(SvOK(dbh) ? dbh : drh, mysql_errno(sock),
mysql_error(sock) ,mysql_sqlstate(sock));
}
if (SvOK(dbh))
{
mysql_close(sock);
}
if (retval)
XSRETURN_NO;
else
XSRETURN_YES;
}
MODULE = DBD::mysql PACKAGE = DBD::mysql::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);
ASYNC_CHECK_XS(dbh);
ST(0) = sv_2mortal(newRV_noinc((SV*) dbd_db_type_info_all(dbh,
imp_dbh)));
XSRETURN(1);
}
void
_ListDBs(dbh)
SV* dbh
PPCODE:
D_imp_dbh(dbh);
ASYNC_CHECK_XS(dbh);
MYSQL_RES* res = mysql_list_dbs(imp_dbh->pmysql, NULL);
MYSQL_ROW cur;
if (!res &&
(!mysql_db_reconnect(dbh) ||
!(res = mysql_list_dbs(imp_dbh->pmysql, NULL))))
{
do_error(dbh, mysql_errno(imp_dbh->pmysql),
mysql_error(imp_dbh->pmysql), mysql_sqlstate(imp_dbh->pmysql));
}
else
{
EXTEND(sp, mysql_num_rows(res));
while ((cur = mysql_fetch_row(res)))
{
PUSHs(sv_2mortal((SV*)newSVpv(cur[0], strlen(cur[0]))));
}
mysql_free_result(res);
}
void
do(dbh, statement, attr=Nullsv, ...)
SV * dbh
SV * statement
SV * attr
PROTOTYPE: $$;$@
CODE:
{
D_imp_dbh(dbh);
int num_params= 0;
int retval;
struct imp_sth_ph_st* params= NULL;
MYSQL_RES* result= NULL;
SV* async = NULL;
#if MYSQL_VERSION_ID >= MULTIPLE_RESULT_SET_VERSION
int next_result_rc;
#endif
#if MYSQL_VERSION_ID >= SERVER_PREPARE_VERSION
STRLEN slen;
char *str_ptr, *statement_ptr, *buffer;
int has_binded;
int col_type= MYSQL_TYPE_STRING;
int buffer_is_null= 0;
int buffer_length= slen;
int buffer_type= 0;
int param_type= SQL_VARCHAR;
int use_server_side_prepare= 0;
MYSQL_STMT *stmt= NULL;
MYSQL_BIND *bind= NULL;
imp_sth_phb_t *fbind= NULL;
#endif
ASYNC_CHECK_XS(dbh);
#if MYSQL_VERSION_ID >= MULTIPLE_RESULT_SET_VERSION
while (mysql_next_result(imp_dbh->pmysql)==0)
{
MYSQL_RES* res = mysql_use_result(imp_dbh->pmysql);
if (res)
mysql_free_result(res);
}
#endif
#if MYSQL_VERSION_ID >= SERVER_PREPARE_VERSION
/*
* Globaly enabled using of server side prepared statement
* for dbh->do() statements. It is possible to force driver
* to use server side prepared statement mechanism by adding
* 'mysql_server_prepare' attribute to do() method localy:
* $dbh->do($stmt, {mysql_server_prepared=>1});
*/
use_server_side_prepare = imp_dbh->use_server_side_prepare;
if (attr)
{
SV** svp;
DBD_ATTRIBS_CHECK("do", dbh, attr);
svp = DBD_ATTRIB_GET_SVP(attr, "mysql_server_prepare", 20);
use_server_side_prepare = (svp) ?
SvTRUE(*svp) : imp_dbh->use_server_side_prepare;
svp = DBD_ATTRIB_GET_SVP(attr, "async", 5);
async = (svp) ? *svp : &PL_sv_no;
}
if (DBIc_DBISTATE(imp_dbh)->debug >= 2)
PerlIO_printf(DBIc_LOGPIO(imp_dbh),
"mysql.xs do() use_server_side_prepare %d, async %d\n",
use_server_side_prepare, SvTRUE(async));
hv_store((HV*)SvRV(dbh), "Statement", 9, SvREFCNT_inc(statement), 0);
if(SvTRUE(async)) {
#if MYSQL_ASYNC
use_server_side_prepare = FALSE; /* for now */
imp_dbh->async_query_in_flight = imp_dbh;
#else
do_error(dbh, 2000,
"Async support was not built into this version of DBD::mysql", "HY000");
XSRETURN_UNDEF;
#endif
}
if (use_server_side_prepare)
{
str_ptr= SvPV(statement, slen);
stmt= mysql_stmt_init(imp_dbh->pmysql);
if ((mysql_stmt_prepare(stmt, str_ptr, strlen(str_ptr))) &&
(!mysql_db_reconnect(dbh) ||
(mysql_stmt_prepare(stmt, str_ptr, strlen(str_ptr)))))
{
/*
For commands that are not supported by server side prepared
statement mechanism lets try to pass them through regular API
*/
if (mysql_stmt_errno(stmt) == ER_UNSUPPORTED_PS)
{
use_server_side_prepare= 0;
}
else
{
do_error(dbh, mysql_stmt_errno(stmt), mysql_stmt_error(stmt)
,mysql_stmt_sqlstate(stmt));
retval=-2;
}
mysql_stmt_close(stmt);
stmt= NULL;
}
else
{
/*
'items' is the number of arguments passed to XSUB, supplied
by xsubpp compiler, as listed in manpage for perlxs
*/
if (items > 3)
{
/*
Handle binding supplied values to placeholders assume user has
passed the correct number of parameters
*/
int i;
num_params= items - 3;
/*num_params = mysql_stmt_param_count(stmt);*/
Newz(0, params, sizeof(*params)*num_params, struct imp_sth_ph_st);
Newz(0, bind, (unsigned int) num_params, MYSQL_BIND);
Newz(0, fbind, (unsigned int) num_params, imp_sth_phb_t);
for (i = 0; i < num_params; i++)
{
int defined= 0;
params[i].value= ST(i+3);
if (params[i].value)
{
if (SvMAGICAL(params[i].value))
mg_get(params[i].value);
if (SvOK(params[i].value))
defined= 1;
}
if (defined)
{
buffer= SvPV(params[i].value, slen);
buffer_is_null= 0;
buffer_length= slen;
}
else
{
buffer= NULL;
buffer_is_null= 1;
buffer_length= 0;
}
/*
if this statement has a result set, field types will be
correctly identified. If there is no result set, such as
with an INSERT, fields will not be defined, and all
buffer_type will default to MYSQL_TYPE_VAR_STRING
*/
col_type= (stmt->fields) ? stmt->fields[i].type : MYSQL_TYPE_STRING;
switch (col_type) {
#if MYSQL_VERSION_ID > 50003
case MYSQL_TYPE_NEWDECIMAL:
#endif
case MYSQL_TYPE_DECIMAL:
param_type= SQL_DECIMAL;
buffer_type= MYSQL_TYPE_DOUBLE;
break;
case MYSQL_TYPE_DOUBLE:
param_type= SQL_DOUBLE;
buffer_type= MYSQL_TYPE_DOUBLE;
break;
case MYSQL_TYPE_FLOAT:
buffer_type= MYSQL_TYPE_DOUBLE;
param_type= SQL_FLOAT;
break;
case MYSQL_TYPE_SHORT:
buffer_type= MYSQL_TYPE_DOUBLE;
param_type= SQL_FLOAT;
break;
case MYSQL_TYPE_TINY:
buffer_type= MYSQL_TYPE_DOUBLE;
param_type= SQL_FLOAT;
break;
case MYSQL_TYPE_LONG:
buffer_type= MYSQL_TYPE_LONG;
param_type= SQL_BIGINT;
break;
case MYSQL_TYPE_INT24:
case MYSQL_TYPE_YEAR:
buffer_type= MYSQL_TYPE_LONG;
param_type= SQL_INTEGER;
break;
case MYSQL_TYPE_LONGLONG:
/* perl handles long long as double
* so we'll set this to string */
buffer_type= MYSQL_TYPE_STRING;
param_type= SQL_VARCHAR;
break;
case MYSQL_TYPE_NEWDATE:
case MYSQL_TYPE_DATE:
buffer_type= MYSQL_TYPE_STRING;
param_type= SQL_DATE;
break;
case MYSQL_TYPE_TIME:
buffer_type= MYSQL_TYPE_STRING;
param_type= SQL_TIME;
break;
case MYSQL_TYPE_TIMESTAMP:
buffer_type= MYSQL_TYPE_STRING;
param_type= SQL_TIMESTAMP;
break;
case MYSQL_TYPE_VAR_STRING:
case MYSQL_TYPE_STRING:
case MYSQL_TYPE_DATETIME:
buffer_type= MYSQL_TYPE_STRING;
param_type= SQL_VARCHAR;
break;
case MYSQL_TYPE_BLOB:
buffer_type= MYSQL_TYPE_BLOB;
param_type= SQL_BINARY;
break;
case MYSQL_TYPE_GEOMETRY:
buffer_type= MYSQL_TYPE_BLOB;
param_type= SQL_BINARY;
break;
default:
buffer_type= MYSQL_TYPE_STRING;
param_type= SQL_VARCHAR;
break;
}
bind[i].buffer_type = buffer_type;
bind[i].buffer_length= buffer_length;
bind[i].buffer= buffer;
fbind[i].length= buffer_length;
fbind[i].is_null= buffer_is_null;
params[i].type= param_type;
}
has_binded= 0;
}
retval = mysql_st_internal_execute41(dbh,
num_params,
&result,
stmt,
bind,
&has_binded);
if (bind)
Safefree(bind);
if (fbind)
Safefree(fbind);
if(mysql_stmt_close(stmt))
{
fprintf(stderr, "\n failed while closing the statement");
fprintf(stderr, "\n %s", mysql_stmt_error(stmt));
}
}
}
if (! use_server_side_prepare)
{
#endif
if (items > 3)
{
/* Handle binding supplied values to placeholders */
/* Assume user has passed the correct number of parameters */
int i;
num_params= items-3;
Newz(0, params, sizeof(*params)*num_params, struct imp_sth_ph_st);
for (i= 0; i < num_params; i++)
{
params[i].value= ST(i+3);
params[i].type= SQL_VARCHAR;
}
}
retval = mysql_st_internal_execute(dbh, statement, attr, num_params,
params, &result, imp_dbh->pmysql, 0);
#if MYSQL_VERSION_ID >=SERVER_PREPARE_VERSION
}
#endif
if (params)
Safefree(params);
if (result)
{
mysql_free_result(result);
result= 0;
}
#if MYSQL_VERSION_ID >= MULTIPLE_RESULT_SET_VERSION
if (retval != -2 && !SvTRUE(async)) /* -2 means error */
{
/* more results? -1 = no, >0 = error, 0 = yes (keep looping) */
while ((next_result_rc= mysql_next_result(imp_dbh->pmysql)) == 0)
{
result = mysql_use_result(imp_dbh->pmysql);
if (result)
mysql_free_result(result);
}
if (next_result_rc > 0)
{
if (DBIc_DBISTATE(imp_dbh)->debug >= 2)
PerlIO_printf(DBIc_LOGPIO(imp_dbh),
"\t<- do() ERROR: %s\n",
mysql_error(imp_dbh->pmysql));
do_error(dbh, mysql_errno(imp_dbh->pmysql),
mysql_error(imp_dbh->pmysql),
mysql_sqlstate(imp_dbh->pmysql));
retval= -2;
}
}
#endif
/* 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 retval;
D_imp_dbh(dbh);
ASYNC_CHECK_XS(dbh);
retval = (mysql_ping(imp_dbh->pmysql) == 0);
if (!retval) {
if (mysql_db_reconnect(dbh)) {
retval = (mysql_ping(imp_dbh->pmysql) == 0);
}
}
RETVAL = boolSV(retval);
}
OUTPUT:
RETVAL
void
quote(dbh, str, type=NULL)
SV* dbh
SV* str
SV* type
PROTOTYPE: $$;$
PPCODE:
{
D_imp_dbh(dbh);
ASYNC_CHECK_XS(dbh);
SV* quoted = dbd_db_quote(dbh, str, type);
ST(0) = quoted ? sv_2mortal(quoted) : str;
XSRETURN(1);
}
int mysql_fd(dbh)
SV* dbh
CODE:
{
D_imp_dbh(dbh);
RETVAL = imp_dbh->pmysql->net.fd;
}
OUTPUT:
RETVAL
void mysql_async_result(dbh)
SV* dbh
PPCODE:
{
#if MYSQL_ASYNC
int retval;
retval = mysql_db_async_result(dbh, NULL);
if(retval > 0) {
XSRETURN_IV(retval);
} else if(retval == 0) {
XSRETURN_PV("0E0");
} else {
XSRETURN_UNDEF;
}
#else
do_error(dbh, 2000, "Async support was not built into this version of DBD::mysql", "HY000");
XSRETURN_UNDEF;
#endif
}
void mysql_async_ready(dbh)
SV* dbh
PPCODE:
{
#if MYSQL_ASYNC
int retval;
retval = mysql_db_async_ready(dbh);
if(retval > 0) {
XSRETURN_YES;
} else if(retval == 0) {
XSRETURN_NO;
} else {
XSRETURN_UNDEF;
}
#else
do_error(dbh, 2000, "Async support was not built into this version of DBD::mysql", "HY000");
XSRETURN_UNDEF;
#endif
}
void _async_check(dbh)
SV* dbh
PPCODE:
{
D_imp_dbh(dbh);
ASYNC_CHECK_XS(dbh);
XSRETURN_YES;
}
MODULE = DBD::mysql PACKAGE = DBD::mysql::st
int
more_results(sth)
SV * sth
CODE:
{
#if (MYSQL_VERSION_ID >= MULTIPLE_RESULT_SET_VERSION)
D_imp_sth(sth);
int retval;
if (dbd_st_more_results(sth, imp_sth))
{
RETVAL=1;
}
else
{
RETVAL=0;
}
#endif
}
OUTPUT:
RETVAL
int
dataseek(sth, pos)
SV* sth
int pos
PROTOTYPE: $$
CODE:
{
D_imp_sth(sth);
#if (MYSQL_VERSION_ID >=SERVER_PREPARE_VERSION)
if (imp_sth->use_server_side_prepare)
{
if (imp_sth->use_mysql_use_result || 1)
{
if (imp_sth->result && imp_sth->stmt)
{
mysql_stmt_data_seek(imp_sth->stmt, pos);
imp_sth->fetch_done=0;
RETVAL = 1;
}
else
{
RETVAL = 0;
do_error(sth, JW_ERR_NOT_ACTIVE, "Statement not active" ,NULL);
}
}
else
{
RETVAL = 0;
do_error(sth, JW_ERR_NOT_ACTIVE, "No result set" ,NULL);
}
}
else
{
#endif
if (imp_sth->result) {
mysql_data_seek(imp_sth->result, pos);
RETVAL = 1;
} else {
RETVAL = 0;
do_error(sth, JW_ERR_NOT_ACTIVE, "Statement not active" ,NULL);
}
#if (MYSQL_VERSION_ID >=SERVER_PREPARE_VERSION)
}
#endif
}
OUTPUT:
RETVAL
void
rows(sth)
SV* sth
CODE:
D_imp_sth(sth);
char buf[64];
#if MYSQL_ASYNC
D_imp_dbh_from_sth;
if(imp_dbh->async_query_in_flight) {
if(mysql_db_async_result(sth, &imp_sth->result) < 0) {
XSRETURN_UNDEF;
}
}
#endif
/* fix to make rows able to handle errors and handle max value from
affected rows.
if mysql_affected_row returns an error, it's value is 18446744073709551614,
while a (my_ulonglong)-1 is 18446744073709551615, so we have to add 1 to
imp_sth->row_num to know if there's an error
*/
if (imp_sth->row_num+1 == (my_ulonglong) -1)
sprintf(buf, "%d", -1);
else
sprintf(buf, "%llu", imp_sth->row_num);
ST(0) = sv_2mortal(newSVpvn(buf, strlen(buf)));
int mysql_async_result(sth)
SV* sth
CODE:
{
#if MYSQL_ASYNC
D_imp_sth(sth);
int retval;
retval= mysql_db_async_result(sth, &imp_sth->result);
if(retval > 0) {
imp_sth->row_num = retval;
XSRETURN_IV(retval);
} else if(retval == 0) {
imp_sth->row_num = retval;
XSRETURN_PV("0E0");
} else {
XSRETURN_UNDEF;
}
#else
do_error(sth, 2000,
"Async support was not built into this version of DBD::mysql", "HY000");
XSRETURN_UNDEF;
#endif
}
OUTPUT:
RETVAL
void mysql_async_ready(sth)
SV* sth
PPCODE:
{
#if MYSQL_ASYNC
int retval;
retval = mysql_db_async_ready(sth);
if(retval > 0) {
XSRETURN_YES;
} else if(retval == 0) {
XSRETURN_NO;
} else {
XSRETURN_UNDEF;
}
#else
do_error(sth, 2000,
"Async support was not built into this version of DBD::mysql", "HY000");
XSRETURN_UNDEF;
#endif
}
void _async_check(sth)
SV* sth
PPCODE:
{
D_imp_sth(sth);
D_imp_dbh_from_sth;
ASYNC_CHECK_XS(sth);
XSRETURN_YES;
}
MODULE = DBD::mysql PACKAGE = DBD::mysql::GetInfo
# This probably should be grabed out of some ODBC types header file
#define SQL_CATALOG_NAME_SEPARATOR 41
#define SQL_CATALOG_TERM 42
#define SQL_DBMS_VER 18
#define SQL_IDENTIFIER_QUOTE_CHAR 29
#define SQL_MAXIMUM_STATEMENT_LENGTH 105
#define SQL_MAXIMUM_TABLES_IN_SELECT 106
#define SQL_MAX_TABLE_NAME_LEN 35
#define SQL_SERVER_NAME 13
#define SQL_ASYNC_MODE 10021
#define SQL_MAX_ASYNC_CONCURRENT_STATEMENTS 10022
#define SQL_AM_NONE 0
#define SQL_AM_CONNECTION 1
#define SQL_AM_STATEMENT 2
# dbd_mysql_getinfo()
# Return ODBC get_info() information that must needs be accessed from C
# This is an undocumented function that should only
# be used by DBD::mysql::GetInfo.
void
dbd_mysql_get_info(dbh, sql_info_type)
SV* dbh
SV* sql_info_type
CODE:
D_imp_dbh(dbh);
IV type = 0;
SV* retsv=NULL;
bool using_322=0;
if (SvMAGICAL(sql_info_type))
mg_get(sql_info_type);
if (SvOK(sql_info_type))
type = SvIV(sql_info_type);
else
croak("get_info called with an invalied parameter");
switch(type) {
case SQL_CATALOG_NAME_SEPARATOR:
/* (dbc->flag & FLAG_NO_CATALOG) ? WTF is in flag ? */
retsv = newSVpv(".",1);
break;
case SQL_CATALOG_TERM:
/* (dbc->flag & FLAG_NO_CATALOG) ? WTF is in flag ? */
retsv = newSVpv("database",8);
break;
case SQL_DBMS_VER:
retsv = newSVpv(
imp_dbh->pmysql->server_version,
strlen(imp_dbh->pmysql->server_version)
);
break;
case SQL_IDENTIFIER_QUOTE_CHAR:
/*XXX What about a DB started in ANSI mode? */
/* Swiped from MyODBC's get_info.c */
using_322 = ((strncmp(mysql_get_server_info(imp_dbh->pmysql),"3.22",4) == 0) ? 1 : 0 );
retsv = newSVpv(!using_322 ? "`" : " ", 1);
break;
case SQL_MAXIMUM_STATEMENT_LENGTH:
retsv = newSViv(net_buffer_length);
break;
case SQL_MAXIMUM_TABLES_IN_SELECT:
/* newSViv((sizeof(int) > 32) ? sizeof(int)-1 : 31 ); in general? */
retsv= newSViv((sizeof(int) == 64 ) ? 63 : 31 );
break;
case SQL_MAX_TABLE_NAME_LEN:
retsv= newSViv(NAME_LEN);
break;
case SQL_SERVER_NAME:
retsv= newSVpv(imp_dbh->pmysql->host_info,strlen(imp_dbh->pmysql->host_info));
break;
case SQL_ASYNC_MODE:
#if MYSQL_ASYNC
retsv = newSViv(SQL_AM_STATEMENT);
#else
retsv = newSViv(SQL_AM_NONE);
#endif
break;
case SQL_MAX_ASYNC_CONCURRENT_STATEMENTS:
#if MYSQL_ASYNC
retsv = newSViv(1);
#else
retsv = newSViv(0);
#endif
break;
default:
croak("Unknown SQL Info type: %i",dbh);
}
ST(0) = sv_2mortal(retsv);