static mapping_t *
fetch_into_mapping( hDBC * handle )
{
int i;
mapping_t * map;
svalue_t * key,
* value;
STORE_DOUBLE_USED;
map = allocate_mapping( handle->colcnt, 1 );
MEM_CHECK( map );
for( i = 0; i < handle->colcnt; ++i ) {
if ( !handle->columns[ i ] ) continue;
//printf( " fetch_into_mapping[%2d] ", i );
key = pxalloc( sizeof( svalue_t ) );
MEM_CHECK( key );
put_malloced_string( key, string_copy( handle->columns[ i ]->name ) );
value = get_map_lvalue( map, key );
MEM_CHECK( value );
switch( handle->columns[ i ]->type ){
case T_FLOAT:
//printf( "float=%f\n", handle->columns[ i ]->data.double_v );
STORE_DOUBLE( value, *handle->columns[ i ]->data.double_v );
value->type = T_FLOAT;
break;
case T_NUMBER:
//printf( "number=%d\n", *handle->columns[ i ]->data.number_v );
put_number( value, *handle->columns[ i ]->data.number_v );
break;
case T_STRING:
default :
//printf( "string=%s\n", handle->columns[ i ]->data.string_v );
put_malloced_string( value, string_copy( handle->columns[ i ]->data.string_v ) );
break;
}
}
return( map );
}
void f_db_fetch (void)
{
db_t *db;
array_t *ret;
valid_database("fetch", &the_null_array);
db = find_db_conn((sp-1)->u.number);
if (!db) {
error("Attempt to fetch from an invalid database handle\n");
}
if (db->type->fetch) {
ret = db->type->fetch(&(db->c), sp->u.number);
} else {
ret = &the_null_array;
}
pop_stack();
if (!ret) {
if (db->type->error) {
char *errormsg;
errormsg = db->type->error(&(db->c));
put_malloced_string(errormsg);
} else {
sp->u.number = 0;
}
} else {
put_array(ret);
}
}
void
f_socket_address (void)
{
char *str;
int local, port;
char addr[ADDR_BUF_SIZE];
char buf[2 * ADDR_BUF_SIZE]; /* a bit of overkill to be safe */
/*
* Ok, we will add in a cute little check thing here to see if it is
* an object or not...
*/
local = (sp--)->u.number;
if (sp->type & T_OBJECT) {
char *tmp;
/* This is so we can get the address of interactives as well. */
if (!sp->u.ob->interactive) {
free_object(sp->u.ob, "f_socket_address:1");
*sp = const0u;
return;
}
tmp = inet_ntoa(sp->u.ob->interactive->addr.sin_addr);
sprintf(buf, "%s %d", tmp,
ntohs(sp->u.ob->interactive->addr.sin_port));
str = string_copy(buf, "f_socket_address");
free_object(sp->u.ob, "f_socket_address:2");
put_malloced_string(str);
return;
}
get_socket_address(sp->u.number, addr, &port, local);
sprintf(buf, "%s %d", addr, port);
str = string_copy(buf, "f_socket_address");
put_malloced_string(str);
} /* f_socket_address() */
void f_db_exec (void)
{
int ret = 0;
db_t *db;
array_t *info;
info = allocate_empty_array(1);
info->item[0].type = T_STRING;
info->item[0].subtype = STRING_MALLOC;
info->item[0].u.string = string_copy(sp->u.string, "f_db_exec");
valid_database("exec", info);
db = find_db_conn((sp-1)->u.number);
if (!db) {
error("Attempt to exec on an invalid database handle\n");
}
#ifdef PACKAGE_ASYNC
if(!db_mut){
db_mut = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(db_mut, NULL);
}
pthread_mutex_lock(db_mut);
#endif
if (db->type->cleanup) {
db->type->cleanup(&(db->c));
}
if (db->type->execute) {
ret = db->type->execute(&(db->c), sp->u.string);
}
pop_stack();
if (ret == -1) {
if (db->type->error) {
char *errormsg;
errormsg = db->type->error(&(db->c));
put_malloced_string(errormsg);
} else {
put_constant_string("Unknown error");
}
} else {
sp->u.number = ret;
}
#ifdef PACKAGE_ASYNC
pthread_mutex_unlock(db_mut);
#endif
}
/*************************************************************************
* f_sql_column_names( int handle )
*
* returns the returned column names of the last executed statement
*************************************************************************/
svalue_t *
f_sql_column_names( svalue_t * argv, int argc )
{
#if ODBC_DEBUG & DEBUG_FUNC
printf( "call f_sql_column_names( )\n" );
#endif
int id, cnt, i;
hDBC * handle;
vector_t * vec;
TYPE_TEST1( argv, T_NUMBER );
id = argv->u.number;
free_svalue( argv );
if ( !(handle = get_db_connection_by_id( id )) ) {
errorf( "Illegal handle for database.\n" );
return( NULL );
}
if ( !handle->columns ) {
vec = allocate_array( 0 );
MEM_CHECK( vec );
put_array( argv, vec );
return( argv );
}
cnt = handle->colcnt;
vec = allocate_array( cnt );
MEM_CHECK( vec );
for ( i = 0; i < cnt; ++i ) {
if ( handle->columns[ i ] )
put_malloced_string(vec->item + i, string_copy( handle->columns[ i ]->name ) );
}
put_array( argv, vec );
#if ODBC_DEBUG & DEBUG_FUNC
printf( "ret f_sql_column_names( )\n" );
#endif
return( argv );
}
void f_B2G ()
{
int i;
char *istr, *ostr;
istr = (char *)sp->u.string;
i = SVALUE_STRLEN(sp);
if(i == 0)
{
push_number(0);
free_string_svalue(sp);
return;
}
ostr = new_string(i, "f_B2G");
Big2GB(istr, ostr, i);
free_string_svalue(sp);
put_malloced_string(ostr);
}
static vector_t *
fetch_into_vector( hDBC * handle )
{
int i;
vector_t * vec;
STORE_DOUBLE_USED;
vec = allocate_array( handle->colcnt );
MEM_CHECK( vec );
for( i = 0; i < handle->colcnt; ++i ) {
if ( !handle->columns[ i ] ) continue;
//printf( " fetch_into_vector[%2d] ", i );
switch( handle->columns[ i ]->type ){
case T_FLOAT:
//printf( "float=%f\n", handle->columns[ i ]->data.double_v );
STORE_DOUBLE( vec->item + i, *handle->columns[ i ]->data.double_v );
( vec->item + i)->type = T_FLOAT;
break;
case T_NUMBER:
//printf( "number=%d\n", *handle->columns[ i ]->data.number_v );
put_number( vec->item + i, *handle->columns[ i ]->data.number_v );
break;
case T_STRING:
default :
//printf( "string=%s\n", handle->columns[ i ]->data.string_v );
put_malloced_string( vec->item + i, string_copy( handle->columns[ i ]->data.string_v ) );
break;
}
}
return( vec );
}
void
f_traceprefix (void)
{
char *old = 0;
if (command_giver && command_giver->interactive) {
old = command_giver->interactive->trace_prefix;
if (sp->type & T_STRING) {
const char *p = sp->u.string;
if (*p == '/') p++;
command_giver->interactive->trace_prefix = make_shared_string(p);
free_string_svalue(sp);
} else
command_giver->interactive->trace_prefix = 0;
}
if (old) {
put_malloced_string(add_slash(old));
free_string(old);
} else
*sp = const0;
}
/*************************************************************************
* string f_sql_error( int handle )
*
* returns the last encountered error
*************************************************************************/
svalue_t *
f_sql_error( svalue_t * argv, int argc )
{
#if ODBC_DEBUG & DEBUG_FUNC
printf( "call f_sql_error( )\n" );
#endif
int id, cnt, i;
hDBC * handle;
char * err;
TYPE_TEST1( argv, T_NUMBER );
id = argv->u.number;
free_svalue( argv );
if ( !(handle = get_db_connection_by_id( id )) ) {
errorf( "Illegal handle for database.\n" );
return( NULL );
}
if ( handle->hStmt ) {
err = extract_diagnostics_info( SQL_HANDLE_STMT, handle->hStmt );
} else {
err = extract_diagnostics_info( SQL_HANDLE_DBC, handle->hDBCon );
}
if ( err ) {
put_malloced_string( argv, err );
} else {
put_number( argv, 0 );
}
#if ODBC_DEBUG & DEBUG_FUNC
printf( "ret f_sql_error( )\n" );
#endif
return( argv );
}
void f_bg5cc ()
{
char *istr, *ostr, *ret;
unsigned char s;
istr = (char *)sp->u.string;
if(SVALUE_STRLEN(sp) == 0)
push_number(0);
if(!strchr(istr, '\\'))
{
ret = string_copy(istr, "f_bg5cc");
}
else
{
ostr = ret = new_string(max_string_length, "f_bg5cc");
while(*istr)
{
*ostr++ = s = *istr++;
if(is_B51(s))
{
*ostr++ = s = *istr++;
if(s == '\\' && *istr != '\\')
*ostr++ = s;
}
}
*ostr = '\0';
}
free_string_svalue(sp);
put_malloced_string(ret);
}
void f_cwrap ()
{
register int i, j;
int width, slen, blanks;
register char *istr, *ostr, *ret;
if(st_num_arg >= 2)
{
if(st_num_arg == 3)
{
blanks = sp->u.number;
pop_stack();
if(blanks < 0)
blanks = 0;
}
else
blanks = 4;
width = sp->u.number;
pop_stack();
if(width < 2)
width = 64;
if(width - blanks < 2)
{
width = 64;
blanks = 4;
}
}
else
{
blanks = 4;
width = 64;
}
istr = (char *)sp->u.string;
slen = SVALUE_STRLEN(sp);
if(slen < blanks)
blanks = 0;
i = blanks;
ostr = ret = new_string(slen+slen/width+blanks, "f_cwrap");
while(blanks--)
*ostr++ = ' ';
while(*istr)
{
if(*istr == '\n')
{
istr++;
continue;
}
if(istr[0] == 27 && istr[1] == '[')
{
j=2;
while(istr[j] && (isdigit(istr[j]) || istr[j]==';'))
j++;
if(istr[j++] == 'm')
{
while(j--)
*ostr++ = *istr++;
continue;
}
}
i++;
*ostr++ = *istr++;
if(is_B51((unsigned char)*(istr-1)))
{
i++;
*ostr++ = *istr++;
}
else if((unsigned char)*(istr-1) == '\t')
i += 4;
if(i >= width)
{
*ostr++ = '\n';
i = 0;
}
}
*ostr = '\0';
ostr = string_copy(ret, "f_cwrap");
FREE_MSTR(ret);
free_string_svalue(sp);
put_malloced_string(ostr);
}
/*************************************************************************
* f_sql_odbc_datasources( void )
*
* returns a mapping of all defined datasources.
* ([ name : description ])
*************************************************************************/
svalue_t *
f_sql_odbc_datasources( svalue_t * argv, int argc )
{
#if ODBC_DEBUG & DEBUG_FUNC
printf( "call f_sql_odbc_datasources( )\n" );
#endif
SQLRETURN ret;
char * err;
char dsName[ 256 ],
dsDescription[ 256 ];
SQLSMALLINT dsNameLen,
dsDescriptionLen;
mapping_t * map;
svalue_t * key;
svalue_t * value;
argv++;
err = init_odbc_environment();
if ( err ) {
errorf( err );
return( NULL );
}
map = allocate_mapping( 0, 1 );
MEM_CHECK( map );
do {
ret = SQLDataSources( hODBCEnv->hODBCEnv, SQL_FETCH_NEXT, dsName, 256, &dsNameLen,
dsDescription, 256, &dsDescriptionLen );
if ( SQL_SUCCEEDED( ret ) ) {
key = pxalloc( sizeof( svalue_t ) );
put_malloced_string( key, string_copy( dsName ) );
value = get_map_lvalue( map, key );
MEM_CHECK( value );
put_malloced_string( value, string_copy( dsDescription ) );
}
} while( SQL_SUCCEEDED( ret ) );
if ( ret != SQL_NO_DATA ) {
char * err;
err = extract_diagnostics_info( SQL_HANDLE_ENV, hODBCEnv->hODBCEnv );
free_mapping( map );
errorf( (err?err:"Failed to fetch datasource information.\n") );
return( NULL );
}
put_mapping( argv, map );
#if ODBC_DEBUG & DEBUG_FUNC
printf( "ret f_sql_odbc_datasources( )\n" );
#endif
return( argv );
}
