firebird/firebird-mirror
firebird/firebird-mirror
8
0
Fork 1
mirror of https://github.com/FirebirdSQL/firebird.git synced 2025-01-24 20:43:04 +01:00
Code Issues
d38d8dccbd
firebird-mirror/src/dsql/utld.cpp

1088 lines
24 KiB
C++
Raw Blame History

/*
* PROGRAM: Dynamic SQL runtime support
* MODULE: utld.cpp
* DESCRIPTION: Utility routines for DSQL
*
* The contents of this file are subject to the Interbase Public
* License Version 1.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy
* of the License at http://www.Inprise.com/IPL.html
*
* Software distributed under the License is distributed on an
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
* or implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code was created by Inprise Corporation
* and its predecessors. Portions created by Inprise Corporation are
* Copyright (C) Inprise Corporation.
*
* All Rights Reserved.
* Contributor(s): ______________________________________.
*
* 21 Nov 01 - Ann Harrison - Turn off the code in parse_sqlda that
* decides that two statements are the same based on their message
* descriptions because it misleads some code in remote/interface.c
* and causes problems when two statements are prepared.
*
* 2002.10.29 Sean Leyne - Removed obsolete "Netware" port
*
*/
#include "firebird.h"
#include <stdio.h>
#include <string.h>
#include "../dsql/dsql.h"
#include "../dsql/sqlda.h"
#include "../jrd/ibase.h"
#include "../jrd/align.h"
#include "../jrd/constants.h"
#include "../dsql/utld_proto.h"
#include "../jrd/gds_proto.h"
#if !defined(SUPERCLIENT)
#include "../dsql/metd_proto.h"
#endif
#include "../common/classes/init.h"
using namespace Jrd;
static void cleanup(void *);
static ISC_STATUS error_dsql_804(ISC_STATUS *, ISC_STATUS);
static SLONG get_numeric_info(const SCHAR**);
static SSHORT get_string_info(const SCHAR**, SCHAR*, int);
#ifdef NOT_USED_OR_REPLACED
#ifdef DEV_BUILD
static void print_xsqlda(XSQLDA *);
#endif
#endif
static void sqlvar_to_xsqlvar(const SQLVAR*, XSQLVAR*);
static void xsqlvar_to_sqlvar(const XSQLVAR*, SQLVAR*);
static inline void ch_stuff(BLOB_PTR*& p, const UCHAR value, bool& same_flag)
{
if (*p == value)
p++;
else {
*p++ = value;
same_flag = false;
}
}
static inline void ch_stuff_word(BLOB_PTR*& p, const USHORT value, bool& same_flag)
{
ch_stuff(p, value & 255, same_flag);
ch_stuff(p, value >> 8, same_flag);
}
// these statics define a round-robin data area for storing
// textual error messages returned to the user
static Firebird::GlobalPtr<Firebird::Mutex> failuresMutex;
static TEXT *DSQL_failures, *DSQL_failures_ptr;
const int DSQL_FAILURE_SPACE = 2048;
/**
Parse response on isc_info_sql_select or isc_info_sql_bind
request. Return pointer to the next byte after successfully
parsed info or NULL if error is encountered or info is truncated
**/
SCHAR* UTLD_skip_sql_info(SCHAR* info)
{
if (*info != isc_info_sql_select &&
*info != isc_info_sql_bind)
{
return 0;
}
info++;
if (*info++ != isc_info_sql_describe_vars)
return 0;
get_numeric_info((const SCHAR**) &info); // skip message->msg_index
// Loop over the variables being described
while (true)
{
SCHAR str[256]; // must be big enough to hold metadata name
const UCHAR item = *info++;
switch (item)
{
case isc_info_end:
return info;
case isc_info_truncated:
return 0;
case isc_info_sql_select:
case isc_info_sql_bind:
return --info;
case isc_info_sql_describe_end:
break;
case isc_info_sql_sqlda_seq:
case isc_info_sql_type:
case isc_info_sql_sub_type:
case isc_info_sql_scale:
case isc_info_sql_length:
get_numeric_info((const SCHAR**) &info);
break;
case isc_info_sql_field:
case isc_info_sql_relation:
case isc_info_sql_owner:
case isc_info_sql_alias:
get_string_info((const SCHAR**) &info, str, sizeof(str));
break;
default:
return 0;
}
}
return 0;
}
/**
UTLD_char_length_to_byte_length
@brief Return max byte length necessary for a specified character length string
@param lengthInChars
@param maxBytesPerChar
**/
USHORT UTLD_char_length_to_byte_length(USHORT lengthInChars, USHORT maxBytesPerChar)
{
return MIN(((MAX_COLUMN_SIZE - sizeof(USHORT)) / maxBytesPerChar) * maxBytesPerChar,
(ULONG) lengthInChars * maxBytesPerChar);
}
ISC_STATUS UTLD_copy_status(const ISC_STATUS* from, ISC_STATUS* to)
{
/**************************************
*
* c o p y _ s t a t u s
*
**************************************
*
* Functional description
* Copy a status vector.
*
**************************************/
const ISC_STATUS status = from[1];
const ISC_STATUS* const end = from + ISC_STATUS_LENGTH;
while (from < end)
*to++ = *from++;
return status;
}
/**
UTLD_parse_sql_info
@brief Fill in an SQLDA using data returned
by a call to isc_dsql_sql_info.
@param status
@param dialect
@param info
@param xsqlda
@param return_index
**/
ISC_STATUS UTLD_parse_sql_info(ISC_STATUS* status,
USHORT dialect,
const SCHAR* info,
XSQLDA* xsqlda,
USHORT* return_index)
{
XSQLVAR *xvar, xsqlvar;
SQLDA* sqlda;
if (return_index)
*return_index = 0;
if (!xsqlda)
return 0;
// The first byte of the returned buffer is assumed to be either a
// isc_info_sql_select or isc_info_sql_bind item. The second byte
// is assumed to be isc_info_sql_describe_vars.
info += 2;
const SSHORT n = static_cast<SSHORT>(get_numeric_info(&info));
if (dialect >= DIALECT_xsqlda)
{
if (xsqlda->version != SQLDA_VERSION1)
return error_dsql_804(status, isc_dsql_sqlda_err);
xsqlda->sqld = n;
// If necessary, inform the application that more sqlda items are needed
if (xsqlda->sqld > xsqlda->sqln)
return 0;
}
else
{
sqlda = (SQLDA *) xsqlda;
sqlda->sqld = n;
// If necessary, inform the application that more sqlda items are needed
if (sqlda->sqld > sqlda->sqln)
return 0;
xsqlda = NULL;
xvar = &xsqlvar;
}
// Loop over the variables being described.
SQLVAR* qvar = NULL;
USHORT last_index = 0;
USHORT index = 0;
while (*info != isc_info_end)
{
SCHAR item;
while ((item = *info++) != isc_info_sql_describe_end)
switch (item)
{
case isc_info_sql_sqlda_seq:
index = static_cast<USHORT>(get_numeric_info(&info));
if (xsqlda)
xvar = xsqlda->sqlvar + index - 1;
else
{
qvar = sqlda->sqlvar + index - 1;
memset(xvar, 0, sizeof(XSQLVAR));
}
break;
case isc_info_sql_type:
xvar->sqltype = static_cast<SSHORT>(get_numeric_info(&info));
break;
case isc_info_sql_sub_type:
xvar->sqlsubtype = static_cast<SSHORT>(get_numeric_info(&info));
break;
case isc_info_sql_scale:
xvar->sqlscale = static_cast<SSHORT>(get_numeric_info(&info));
break;
case isc_info_sql_length:
xvar->sqllen = static_cast<SSHORT>(get_numeric_info(&info));
break;
case isc_info_sql_field:
xvar->sqlname_length = get_string_info(&info, xvar->sqlname, sizeof(xvar->sqlname));
break;
case isc_info_sql_relation:
xvar->relname_length = get_string_info(&info, xvar->relname, sizeof(xvar->relname));
break;
case isc_info_sql_owner:
xvar->ownname_length = get_string_info(&info, xvar->ownname, sizeof(xvar->ownname));
break;
case isc_info_sql_alias:
xvar->aliasname_length =
get_string_info(&info, xvar->aliasname, sizeof(xvar->aliasname));
break;
case isc_info_truncated:
if (return_index)
*return_index = last_index;
default:
return error_dsql_804(status, isc_dsql_sqlda_err);
}
if (!xsqlda)
xsqlvar_to_sqlvar(xvar, qvar);
if (index > last_index)
last_index = index;
}
if (*info != isc_info_end)
return error_dsql_804(status, isc_dsql_sqlda_err);
return FB_SUCCESS;
}
/**
UTLD_parse_sqlda
@brief This routine creates a blr message that describes
a SQLDA as well as moving data from the SQLDA
into a message buffer or from the message buffer
into the SQLDA.
@param status
@param dasup
@param blr_length
@param msg_type
@param msg_length
@param dialect
@param xsqlda
@param clause
**/
ISC_STATUS UTLD_parse_sqlda(ISC_STATUS* status,
sqlda_sup* const dasup,
USHORT* blr_length,
USHORT* msg_type,
USHORT* msg_length,
USHORT dialect,
const XSQLDA* xsqlda,
const USHORT clause)
{
USHORT n;
XSQLVAR xsqlvar;
const XSQLVAR* xvar = &xsqlvar;
const SQLVAR* qvar;
const SQLDA* sqlda = NULL;
if (!xsqlda)
n = 0;
else
if (dialect >= DIALECT_xsqlda)
{
if (xsqlda->version != SQLDA_VERSION1)
return error_dsql_804(status, isc_dsql_sqlda_err);
n = xsqlda->sqld;
}
else
{
sqlda = reinterpret_cast<const SQLDA*>(xsqlda);
n = sqlda->sqld;
xsqlda = NULL;
}
sqlda_sup::dasup_clause* const pClause = &dasup->dasup_clauses[clause];
if (!n)
{
// If there isn't an SQLDA, don't bother with anything else.
if (blr_length)
*blr_length = pClause->dasup_blr_length = 0;
if (msg_length)
*msg_length = 0;
if (msg_type)
*msg_type = 0;
return 0;
}
if (msg_length)
{
// This is a call from execute or open, or the first call from fetch.
// Determine the size of the blr, allocate a blr buffer, create the
// blr, and finally allocate a message buffer.
// The message buffer we are describing could be for a message to
// either IB 4.0 or IB 3.3 - thus we need to describe the buffer
// with the right set of blr.
// As the BLR is only used to describe space allocation and alignment,
// we can safely use blr_text for both 4.0 and 3.3.
// Make a quick pass through the SQLDA to determine the amount of
// blr that will be generated.
USHORT blr_len = 8;
USHORT par_count = 0;
if (xsqlda)
xvar = xsqlda->sqlvar - 1;
else
qvar = sqlda->sqlvar - 1;
for (USHORT i = 0; i < n; i++)
{
if (xsqlda)
++xvar;
else
sqlvar_to_xsqlvar(++qvar, &xsqlvar);
const USHORT dtype = xvar->sqltype & ~1;
switch (dtype)
{
case SQL_VARYING:
case SQL_TEXT:
case SQL_NULL:
blr_len += 3;
break;
case SQL_SHORT:
case SQL_LONG:
case SQL_INT64:
case SQL_QUAD:
case SQL_BLOB:
case SQL_ARRAY:
blr_len += 2;
break;
default:
++blr_len;
}
blr_len += 2;
par_count += 2;
}
// Make sure the blr buffer is large enough. If it isn't, allocate
// a new one.
if (blr_len > pClause->dasup_blr_buf_len)
{
if (pClause->dasup_blr) {
gds__free(pClause->dasup_blr);
}
pClause->dasup_blr = static_cast<char*>(gds__alloc((SLONG) blr_len));
// FREE: unknown
if (!pClause->dasup_blr) // NOMEM:
return error_dsql_804(status, isc_virmemexh);
pClause->dasup_blr_buf_len = blr_len;
pClause->dasup_blr_length = 0;
}
memset(pClause->dasup_blr, 0, blr_len);
bool same_flag = (blr_len == pClause->dasup_blr_length);
// turn off same_flag because it breaks execute & execute2 when
// more than one statement is prepared
same_flag = false;
pClause->dasup_blr_length = blr_len;
// Generate the blr for the message and at the same time, determine
// the size of the message buffer. Allow for a null indicator with
// each variable in the SQLDA.
// one huge pointer per line for LIBS
BLOB_PTR* p = reinterpret_cast<UCHAR*>(pClause->dasup_blr);
// The define SQL_DIALECT_V5 is not available here, Hence using
// constant 1.
if (dialect > 1) {
ch_stuff(p, blr_version5, same_flag);
}
else {
ch_stuff(p, blr_version4, same_flag);
}
//else if ((SCHAR) *(p) == (SCHAR) (blr_version4)) {
// (p)++;
//}
//else {
// *(p)++ = (blr_version4);
// same_flag = false;
//}
ch_stuff(p, blr_begin, same_flag);
ch_stuff(p, blr_message, same_flag);
ch_stuff(p, 0, same_flag);
ch_stuff_word(p, par_count, same_flag);
USHORT msg_len = 0;
if (xsqlda)
xvar = xsqlda->sqlvar - 1;
else
qvar = sqlda->sqlvar - 1;
for (USHORT i = 0; i < n; i++)
{
if (xsqlda)
++xvar;
else
sqlvar_to_xsqlvar(++qvar, &xsqlvar);
USHORT dtype = xvar->sqltype & ~1;
USHORT len = xvar->sqllen;
switch (dtype)
{
case SQL_VARYING:
ch_stuff(p, blr_varying, same_flag);
ch_stuff_word(p, len, same_flag);
dtype = dtype_varying;
len += sizeof(USHORT);
break;
case SQL_TEXT:
ch_stuff(p, blr_text, same_flag);
ch_stuff_word(p, len, same_flag);
dtype = dtype_text;
break;
case SQL_DOUBLE:
ch_stuff(p, blr_double, same_flag);
dtype = dtype_double;
break;
case SQL_FLOAT:
ch_stuff(p, blr_float, same_flag);
dtype = dtype_real;
break;
case SQL_D_FLOAT:
ch_stuff(p, blr_d_float, same_flag);
dtype = dtype_d_float;
break;
case SQL_TYPE_DATE:
ch_stuff(p, blr_sql_date, same_flag);
dtype = dtype_sql_date;
break;
case SQL_TYPE_TIME:
ch_stuff(p, blr_sql_time, same_flag);
dtype = dtype_sql_time;
break;
case SQL_TIMESTAMP:
ch_stuff(p, blr_timestamp, same_flag);
dtype = dtype_timestamp;
break;
case SQL_BLOB:
ch_stuff(p, blr_quad, same_flag);
ch_stuff(p, 0, same_flag);
dtype = dtype_blob;
break;
case SQL_ARRAY:
ch_stuff(p, blr_quad, same_flag);
ch_stuff(p, 0, same_flag);
dtype = dtype_array;
break;
case SQL_LONG:
ch_stuff(p, blr_long, same_flag);
ch_stuff(p, xvar->sqlscale, same_flag);
dtype = dtype_long;
break;
case SQL_SHORT:
ch_stuff(p, blr_short, same_flag);
ch_stuff(p, xvar->sqlscale, same_flag);
dtype = dtype_short;
break;
case SQL_INT64:
ch_stuff(p, blr_int64, same_flag);
ch_stuff(p, xvar->sqlscale, same_flag);
dtype = dtype_int64;
break;
case SQL_QUAD:
ch_stuff(p, blr_quad, same_flag);
ch_stuff(p, xvar->sqlscale, same_flag);
dtype = dtype_quad;
break;
case SQL_NULL:
ch_stuff(p, blr_text, same_flag);
ch_stuff_word(p, len, same_flag);
dtype = dtype_text;
break;
default:
return error_dsql_804(status, isc_dsql_sqlda_value_err);
}
ch_stuff(p, blr_short, same_flag);
ch_stuff(p, 0, same_flag);
USHORT align = type_alignments[dtype];
if (align)
msg_len = FB_ALIGN(msg_len, align);
msg_len += len;
align = type_alignments[dtype_short];
if (align)
msg_len = FB_ALIGN(msg_len, align);
msg_len += sizeof(SSHORT);
}
ch_stuff(p, blr_end, same_flag);
ch_stuff(p, blr_eoc, same_flag);
// Make sure the message buffer is large enough. If it isn't, allocate
// a new one.
if (msg_len > pClause->dasup_msg_buf_len)
{
if (pClause->dasup_msg)
gds__free(pClause->dasup_msg);
pClause->dasup_msg = static_cast<char*>(gds__alloc((SLONG) msg_len));
// FREE: unknown
if (!pClause->dasup_msg) // NOMEM:
return error_dsql_804(status, isc_virmemexh);
pClause->dasup_msg_buf_len = msg_len;
}
memset(pClause->dasup_msg, 0, msg_len);
// Fill in the return values to the caller.
*blr_length = same_flag ? 0 : blr_len;
*msg_length = msg_len;
*msg_type = 0;
// If this is the first call from fetch, we're done.
if (clause == DASUP_CLAUSE_select)
return 0;
}
// Move the data between the SQLDA and the message buffer.
USHORT offset = 0;
// one huge pointer per line for LIBS
BLOB_PTR* msg_buf = reinterpret_cast<UCHAR*>(pClause->dasup_msg);
if (xsqlda)
xvar = xsqlda->sqlvar - 1;
else
qvar = sqlda->sqlvar - 1;
for (USHORT i = 0; i < n; i++)
{
if (xsqlda)
++xvar;
else
sqlvar_to_xsqlvar(++qvar, &xsqlvar);
USHORT dtype = xvar->sqltype & ~1;
USHORT len = xvar->sqllen;
switch (dtype)
{
case SQL_VARYING:
dtype = dtype_varying;
len += sizeof(USHORT);
break;
case SQL_TEXT:
dtype = dtype_text;
break;
case SQL_DOUBLE:
dtype = dtype_double;
break;
case SQL_FLOAT:
dtype = dtype_real;
break;
case SQL_D_FLOAT:
dtype = dtype_d_float;
break;
case SQL_TYPE_DATE:
dtype = dtype_sql_date;
break;
case SQL_TYPE_TIME:
dtype = dtype_sql_time;
break;
case SQL_TIMESTAMP:
dtype = dtype_timestamp;
break;
case SQL_BLOB:
dtype = dtype_blob;
break;
case SQL_ARRAY:
dtype = dtype_array;
break;
case SQL_LONG:
dtype = dtype_long;
break;
case SQL_SHORT:
dtype = dtype_short;
break;
case SQL_INT64:
dtype = dtype_int64;
break;
case SQL_QUAD:
dtype = dtype_quad;
break;
case SQL_NULL:
dtype = dtype_text;
break;
}
USHORT align = type_alignments[dtype];
if (align)
offset = FB_ALIGN(offset, align);
USHORT null_offset = offset + len;
align = type_alignments[dtype_short];
if (align)
null_offset = FB_ALIGN(null_offset, align);
SSHORT *null_ind = (SSHORT *) (msg_buf + null_offset);
if (clause == DASUP_CLAUSE_select)
{
// Move data from the message into the SQLDA.
if ((xvar->sqltype & ~1) != SQL_NULL)
{
// Make sure user has specified a data location
if (!xvar->sqldata)
return error_dsql_804(status, isc_dsql_sqlda_value_err);
memcpy(xvar->sqldata, msg_buf + offset, len);
}
if (xvar->sqltype & 1)
{
// Make sure user has specified a location for null indicator
if (!xvar->sqlind)
return error_dsql_804(status, isc_dsql_sqlda_value_err);
*xvar->sqlind = *null_ind;
}
}
else
{
// Move data from the SQLDA into the message. If the
// indicator variable identifies a null value, permit
// the data value to be missing.
if (xvar->sqltype & 1)
{
// Make sure user has specified a location for null indicator
if (!xvar->sqlind)
return error_dsql_804(status, isc_dsql_sqlda_value_err);
*null_ind = *xvar->sqlind;
}
else
*null_ind = 0;
// Make sure user has specified a data location (unless NULL)
if (!xvar->sqldata && !*null_ind && (xvar->sqltype & ~1) != SQL_NULL)
return error_dsql_804(status, isc_dsql_sqlda_value_err);
// Copy data - unless known to be NULL
if ((offset + len) > pClause->dasup_msg_buf_len)
return error_dsql_804(status, isc_dsql_sqlda_value_err);
if (!*null_ind)
memcpy(msg_buf + offset, xvar->sqldata, len);
}
offset = null_offset + sizeof(SSHORT);
}
return 0;
}
/**
UTLD_save_status_strings
@brief Strings in status vectors may be stored in stack variables
or memory pools that are transient. To perserve the information,
copy any included strings to a special buffer.
@param vector
**/
void UTLD_save_status_strings(ISC_STATUS* vector)
{
Firebird::MutexLockGuard guard(failuresMutex);
// allocate space for failure strings if it hasn't already been allocated
if (!DSQL_failures)
{
DSQL_failures = (TEXT*) gds__alloc((SLONG) DSQL_FAILURE_SPACE);
// FREE: by exit handler cleanup()
if (!DSQL_failures) // NOMEM: don't try to copy the strings
return;
DSQL_failures_ptr = DSQL_failures;
gds__register_cleanup(cleanup, 0);
#ifdef DEBUG_GDS_ALLOC
gds_alloc_flag_unfreed((void*) DSQL_failures);
#endif
}
while (*vector)
{
const TEXT* p;
USHORT l;
const ISC_STATUS status = *vector++;
switch (status)
{
case isc_arg_cstring:
l = static_cast<USHORT>(*vector++);
case isc_arg_string:
case isc_arg_interpreted:
case isc_arg_sql_state:
p = (TEXT*) *vector;
if (status != isc_arg_cstring)
l = strlen(p) + 1;
// If there isn't any more room in the buffer,
// start at the beginning again
if (DSQL_failures_ptr + l > DSQL_failures + DSQL_FAILURE_SPACE)
DSQL_failures_ptr = DSQL_failures;
*vector++ = (ISC_STATUS) DSQL_failures_ptr;
if (l)
{
do
{
*DSQL_failures_ptr++ = *p++;
} while (--l && (DSQL_failures_ptr < DSQL_failures + DSQL_FAILURE_SPACE));
}
if (l)
*(DSQL_failures_ptr - 1) = '\0';
break;
default:
++vector;
break;
}
}
}
/**
cleanup
@brief Exit handler to cleanup dynamically allocated memory.
@param arg
**/
static void cleanup(void*)
{
Firebird::MutexLockGuard guard(failuresMutex);
if (DSQL_failures)
gds__free(DSQL_failures);
gds__unregister_cleanup(cleanup, 0);
DSQL_failures = NULL;
}
/**
error_dsql_804
@brief Move a DSQL -804 error message into a status vector.
@param status
@param err
**/
static ISC_STATUS error_dsql_804( ISC_STATUS * status, ISC_STATUS err)
{
ISC_STATUS *p = status;
*p++ = isc_arg_gds;
*p++ = isc_dsql_error;
*p++ = isc_arg_gds;
*p++ = isc_sqlerr;
*p++ = isc_arg_number;
*p++ = -804;
*p++ = isc_arg_gds;
*p++ = err;
*p = isc_arg_end;
return status[1];
}
/**
get_numeric_info
@brief Pick up a VAX format numeric info item
with a 2 byte length.
@param ptr
**/
static SLONG get_numeric_info(const SCHAR** ptr)
{
const SSHORT l = static_cast<SSHORT>(gds__vax_integer(reinterpret_cast<const UCHAR*>(*ptr), 2));
*ptr += 2;
int item = gds__vax_integer(reinterpret_cast<const UCHAR*>(*ptr), l);
*ptr += l;
return item;
}
/**
get_string_info
@brief Pick up a string valued info item and return
its length. The buffer_len argument is assumed
to include space for the terminating null.
@param ptr
@param buffer
@param buffer_len
**/
static SSHORT get_string_info(const SCHAR** ptr, SCHAR* buffer, int buffer_len)
{
const SCHAR* p = *ptr;
SSHORT len = static_cast<SSHORT>(gds__vax_integer(reinterpret_cast<const UCHAR*>(p), 2));
// CVC: What else can we do here?
if (len < 0)
len = 0;
*ptr += len + 2;
p += 2;
if (len >= buffer_len)
len = buffer_len - 1;
if (len)
memcpy(buffer, p, len);
buffer[len] = 0;
return len;
}
#ifdef NOT_USED_OR_REPLACED
#ifdef DEV_BUILD
static void print_xsqlda( XSQLDA * xsqlda)
{
/*****************************************
*
* p r i n t _ x s q l d a
*
*****************************************
*
* print an sqlda
*
*****************************************/
XSQLVAR *xvar, *end_var;
if (!xsqlda)
return;
printf("SQLDA Version %d\n", xsqlda->version);
printf(" sqldaid %.8s\n", xsqlda->sqldaid);
printf(" sqldabc %d\n", xsqlda->sqldabc);
printf(" sqln %d\n", xsqlda->sqln);
printf(" sqld %d\n", xsqlda->sqld);
xvar = xsqlda->sqlvar;
for (end_var = xvar + xsqlda->sqld; xvar < end_var; xvar++)
printf(" %.31s %.31s type: %d, scale %d, len %d subtype %d\n",
xvar->sqlname, xvar->relname, xvar->sqltype,
xvar->sqlscale, xvar->sqllen, xvar->sqlsubtype);
}
#endif
#endif
/**
sqlvar_to_xsqlvar
@param sqlvar
@param xsqlvar
@param sqlvar
@param xsqlvar
**/
static void sqlvar_to_xsqlvar(const SQLVAR* sqlvar, XSQLVAR* xsqlvar)
{
xsqlvar->sqltype = sqlvar->sqltype;
xsqlvar->sqldata = sqlvar->sqldata;
xsqlvar->sqlind = sqlvar->sqlind;
xsqlvar->sqlsubtype = 0;
xsqlvar->sqlscale = 0;
xsqlvar->sqllen = sqlvar->sqllen;
switch (xsqlvar->sqltype & ~1)
{
case SQL_LONG:
xsqlvar->sqlscale = xsqlvar->sqllen >> 8;
xsqlvar->sqllen = sizeof(SLONG);
break;
case SQL_SHORT:
xsqlvar->sqlscale = xsqlvar->sqllen >> 8;
xsqlvar->sqllen = sizeof(SSHORT);
break;
case SQL_INT64:
xsqlvar->sqlscale = xsqlvar->sqllen >> 8;
xsqlvar->sqllen = sizeof(SINT64);
break;
case SQL_QUAD:
xsqlvar->sqlscale = xsqlvar->sqllen >> 8;
xsqlvar->sqllen = sizeof(ISC_QUAD);
break;
}
}
/**
xsqlvar_to_sqlvar
@brief Move an XSQLVAR to an SQLVAR.
@param xsqlvar
@param sqlvar
**/
static void xsqlvar_to_sqlvar(const XSQLVAR* xsqlvar, SQLVAR* sqlvar)
{
sqlvar->sqltype = xsqlvar->sqltype;
sqlvar->sqlname_length = xsqlvar->aliasname_length;
// N.B., this may not NULL-terminate the name...
memcpy(sqlvar->sqlname, xsqlvar->aliasname, sizeof(sqlvar->sqlname));
sqlvar->sqllen = xsqlvar->sqllen;
const USHORT scale = xsqlvar->sqlscale << 8;
switch (sqlvar->sqltype & ~1)
{
case SQL_LONG:
sqlvar->sqllen = sizeof(SLONG) | scale;
break;
case SQL_SHORT:
sqlvar->sqllen = sizeof(SSHORT) | scale;
break;
case SQL_INT64:
sqlvar->sqllen = sizeof(SINT64) | scale;
break;
case SQL_QUAD:
sqlvar->sqllen = sizeof(ISC_QUAD) | scale;
break;
}
}
#if !defined(SUPERCLIENT)
UCHAR DSqlDataTypeUtil::maxBytesPerChar(UCHAR charSet)
{
return METD_get_charset_bpc(statement, charSet);
}
USHORT DSqlDataTypeUtil::getDialect() const
{
return statement->req_client_dialect;
}
#endif
View Git Blame Copy Permalink