tests pass.
/* Bind parameters on a statement handle */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_BindParameter(
- HSTMT hstmt,
- UWORD ipar,
- SWORD fParamType,
- SWORD fCType,
- SWORD fSqlType,
- UDWORD cbColDef,
- SWORD ibScale,
- PTR rgbValue,
- SDWORD cbValueMax,
- SDWORD FAR *pcbValue)
+ HSTMT hstmt,
+ UWORD ipar,
+ SWORD fParamType,
+ SWORD fCType,
+ SWORD fSqlType,
+ UDWORD cbColDef,
+ SWORD ibScale,
+ PTR rgbValue,
+ SDWORD cbValueMax,
+ SDWORD FAR * pcbValue)
{
StatementClass *stmt = (StatementClass *) hstmt;
static char *func = "PGAPI_BindParameter";
/* Associate a user-supplied buffer with a database column. */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_BindCol(
- HSTMT hstmt,
- UWORD icol,
- SWORD fCType,
- PTR rgbValue,
- SDWORD cbValueMax,
- SDWORD FAR *pcbValue)
+ HSTMT hstmt,
+ UWORD icol,
+ SWORD fCType,
+ PTR rgbValue,
+ SDWORD cbValueMax,
+ SDWORD FAR * pcbValue)
{
StatementClass *stmt = (StatementClass *) hstmt;
static char *func = "PGAPI_BindCol";
mylog("%s: entering...\n", func);
mylog("**** PGAPI_BindCol: stmt = %u, icol = %d\n", stmt, icol);
-mylog("**** : fCType=%d rgb=%x valusMax=%d pcb=%x\n", fCType, rgbValue, cbValueMax, pcbValue);
+ mylog("**** : fCType=%d rgb=%x valusMax=%d pcb=%x\n", fCType, rgbValue, cbValueMax, pcbValue);
if (!stmt)
{
* it is best to say this function is not supported and let the application assume a
* data type (most likely varchar).
*/
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_DescribeParam(
- HSTMT hstmt,
- UWORD ipar,
- SWORD FAR *pfSqlType,
- UDWORD FAR *pcbColDef,
- SWORD FAR *pibScale,
- SWORD FAR *pfNullable)
+ HSTMT hstmt,
+ UWORD ipar,
+ SWORD FAR * pfSqlType,
+ UDWORD FAR * pcbColDef,
+ SWORD FAR * pibScale,
+ SWORD FAR * pfNullable)
{
StatementClass *stmt = (StatementClass *) hstmt;
static char *func = "PGAPI_DescribeParam";
/* Sets multiple values (arrays) for the set of parameter markers. */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_ParamOptions(
- HSTMT hstmt,
- UDWORD crow,
- UDWORD FAR *pirow)
+ HSTMT hstmt,
+ UDWORD crow,
+ UDWORD FAR * pirow)
{
static char *func = "PGAPI_ParamOptions";
- StatementClass *stmt = (StatementClass *) hstmt;
+ StatementClass *stmt = (StatementClass *) hstmt;
mylog("%s: entering... %d %x\n", func, crow, pirow);
- if (crow == 1) /* temporary solution and must be rewritten later */
+ if (crow == 1) /* temporary solution and must be
+ * rewritten later */
{
if (pirow)
*pirow = 1;
* to call it anyway.
* If the statement does not have parameters, it should just return 0.
*/
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_NumParams(
- HSTMT hstmt,
- SWORD FAR *pcpar)
+ HSTMT hstmt,
+ SWORD FAR * pcpar)
{
StatementClass *stmt = (StatementClass *) hstmt;
char in_quote = FALSE;
void
-extend_bindings(StatementClass *stmt, int num_columns)
+extend_bindings(StatementClass * stmt, int num_columns)
{
static char *func = "extend_bindings";
BindInfoClass *new_bindings;
};
BindInfoClass *create_empty_bindings(int num_columns);
-void extend_bindings(StatementClass *stmt, int num_columns);
-
+void extend_bindings(StatementClass * stmt, int num_columns);
#endif
void
-CI_Destructor(ColumnInfoClass *self)
+CI_Destructor(ColumnInfoClass * self)
{
CI_free_memory(self);
* If self is null, then just read, don't store.
*/
char
-CI_read_fields(ColumnInfoClass *self, ConnectionClass *conn)
+CI_read_fields(ColumnInfoClass * self, ConnectionClass * conn)
{
Int2 lf;
int new_num_fields;
void
-CI_free_memory(ColumnInfoClass *self)
+CI_free_memory(ColumnInfoClass * self)
{
register Int2 lf;
int num_fields = self->num_fields;
void
-CI_set_num_fields(ColumnInfoClass *self, int new_num_fields)
+CI_set_num_fields(ColumnInfoClass * self, int new_num_fields)
{
CI_free_memory(self); /* always safe to call */
void
-CI_set_field_info(ColumnInfoClass *self, int field_num, char *new_name,
+CI_set_field_info(ColumnInfoClass * self, int field_num, char *new_name,
Oid new_adtid, Int2 new_adtsize, Int4 new_atttypmod)
{
/* check bounds */
#define CI_get_atttypmod(self, col) (self->atttypmod[col])
ColumnInfoClass *CI_Constructor(void);
-void CI_Destructor(ColumnInfoClass *self);
-void CI_free_memory(ColumnInfoClass *self);
-char CI_read_fields(ColumnInfoClass *self, ConnectionClass *conn);
+void CI_Destructor(ColumnInfoClass * self);
+void CI_free_memory(ColumnInfoClass * self);
+char CI_read_fields(ColumnInfoClass * self, ConnectionClass * conn);
/* functions for setting up the fields from within the program, */
/* without reading from a socket */
-void CI_set_num_fields(ColumnInfoClass *self, int new_num_fields);
-void CI_set_field_info(ColumnInfoClass *self, int field_num, char *new_name,
+void CI_set_num_fields(ColumnInfoClass * self, int new_num_fields);
+void CI_set_field_info(ColumnInfoClass * self, int field_num, char *new_name,
Oid new_adtid, Int2 new_adtsize, Int4 atttypmod);
-
#endif
extern GLOBAL_VALUES globals;
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_AllocConnect(
- HENV henv,
- HDBC FAR *phdbc)
+ HENV henv,
+ HDBC FAR * phdbc)
{
EnvironmentClass *env = (EnvironmentClass *) henv;
ConnectionClass *conn;
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_Connect(
- HDBC hdbc,
- UCHAR FAR *szDSN,
- SWORD cbDSN,
- UCHAR FAR *szUID,
- SWORD cbUID,
- UCHAR FAR *szAuthStr,
- SWORD cbAuthStr)
+ HDBC hdbc,
+ UCHAR FAR * szDSN,
+ SWORD cbDSN,
+ UCHAR FAR * szUID,
+ SWORD cbUID,
+ UCHAR FAR * szAuthStr,
+ SWORD cbAuthStr)
{
ConnectionClass *conn = (ConnectionClass *) hdbc;
ConnInfo *ci;
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_BrowseConnect(
- HDBC hdbc,
- UCHAR FAR *szConnStrIn,
- SWORD cbConnStrIn,
- UCHAR FAR *szConnStrOut,
- SWORD cbConnStrOutMax,
- SWORD FAR *pcbConnStrOut)
+ HDBC hdbc,
+ UCHAR FAR * szConnStrIn,
+ SWORD cbConnStrIn,
+ UCHAR FAR * szConnStrOut,
+ SWORD cbConnStrOutMax,
+ SWORD FAR * pcbConnStrOut)
{
static char *func = "PGAPI_BrowseConnect";
/* Drop any hstmts open on hdbc and disconnect from database */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_Disconnect(
- HDBC hdbc)
+ HDBC hdbc)
{
ConnectionClass *conn = (ConnectionClass *) hdbc;
static char *func = "PGAPI_Disconnect";
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_FreeConnect(
- HDBC hdbc)
+ HDBC hdbc)
{
ConnectionClass *conn = (ConnectionClass *) hdbc;
static char *func = "PGAPI_FreeConnect";
memset(&rv->connInfo, 0, sizeof(ConnInfo));
#ifdef DRIVER_CURSOR_IMPLEMENT
rv->connInfo.updatable_cursors = 1;
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+#endif /* DRIVER_CURSOR_IMPLEMENT */
memcpy(&(rv->connInfo.drivers), &globals, sizeof(globals));
rv->sock = SOCK_Constructor(rv);
if (!rv->sock)
#ifdef MULTIBYTE
rv->client_encoding = NULL;
rv->server_encoding = NULL;
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
/* Initialize statement options to defaults */
char
-CC_Destructor(ConnectionClass *self)
+CC_Destructor(ConnectionClass * self)
{
mylog("enter CC_Destructor, self=%u\n", self);
free(self->client_encoding);
if (self->server_encoding)
free(self->server_encoding);
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
/* Free up statement holders */
if (self->stmts)
{
/* Return how many cursors are opened on this connection */
int
-CC_cursor_count(ConnectionClass *self)
+CC_cursor_count(ConnectionClass * self)
{
StatementClass *stmt;
int i,
void
-CC_clear_error(ConnectionClass *self)
+CC_clear_error(ConnectionClass * self)
{
self->errornumber = 0;
self->errormsg = NULL;
* We are almost always in the middle of a transaction.
*/
char
-CC_abort(ConnectionClass *self)
+CC_abort(ConnectionClass * self)
{
QResultClass *res;
/* This is called by SQLDisconnect also */
char
-CC_cleanup(ConnectionClass *self)
+CC_cleanup(ConnectionClass * self)
{
int i;
StatementClass *stmt;
int
-CC_set_translation(ConnectionClass *self)
+CC_set_translation(ConnectionClass * self)
{
#ifdef WIN32
char
-CC_connect(ConnectionClass *self, char do_password)
+CC_connect(ConnectionClass * self, char do_password)
{
StartupPacket sp;
StartupPacket6_2 sp62;
char msgbuffer[ERROR_MSG_LENGTH];
char salt[5];
static char *func = "CC_connect";
+
#ifdef MULTIBYTE
- char *encoding;
-#endif /* MULTIBYTE */
+ char *encoding;
+#endif /* MULTIBYTE */
mylog("%s: entering...\n", func);
if (encoding && strcmp(encoding, "OTHER"))
self->client_encoding = strdup(encoding);
else
- {
+ {
encoding = check_client_encoding(ci->drivers.conn_settings);
if (encoding && strcmp(encoding, "OTHER"))
self->client_encoding = strdup(encoding);
mylog("CC_connect(): DSN = '%s', server = '%s', port = '%s', database = '%s', username = '%s', password='%s'\n", ci->dsn, ci->server, ci->port, ci->database, ci->username, ci->password);
another_version_retry:
+
/*
* If the socket was closed for some reason (like a SQLDisconnect,
* but no SQLFreeConnect then create a socket now.
if (!PROTOCOL_62(ci))
{
- BOOL before_64 = PG_VERSION_LT(self, 6.4), ReadyForQuery = FALSE;
+ BOOL before_64 = PG_VERSION_LT(self, 6.4),
+ ReadyForQuery = FALSE;
+
do
{
if (do_password)
self->errormsg = msgbuffer;
qlog("ERROR from backend during authentication: '%s'\n", self->errormsg);
if (strncmp(msgbuffer, "Unsupported frontend protocol", 29) == 0)
- { /* retry older version */
+ { /* retry older version */
if (PROTOCOL_63(ci))
strcpy(ci->protocol, PG62);
else
CC_initialize_pg_version(self);
goto another_version_retry;
}
-
+
return 0;
case 'R':
return 0;
}
break;
- case 'K': /* Secret key (6.4 protocol) */
- (void) SOCK_get_int(sock, 4); /* pid */
- (void) SOCK_get_int(sock, 4); /* key */
+ case 'K': /* Secret key (6.4 protocol) */
+ (void) SOCK_get_int(sock, 4); /* pid */
+ (void) SOCK_get_int(sock, 4); /* key */
break;
- case 'Z': /* Backend is ready for new query (6.4) */
+ case 'Z': /* Backend is ready for new query (6.4) */
ReadyForQuery = TRUE;
break;
default:
return 0;
}
- /*
- * There were no ReadyForQuery responce
- * before 6.4.
+ /*
+ * There were no ReadyForQuery responce before 6.4.
*/
if (before_64 && areq == AUTH_REQ_OK)
ReadyForQuery = TRUE;
char
-CC_add_statement(ConnectionClass *self, StatementClass *stmt)
+CC_add_statement(ConnectionClass * self, StatementClass * stmt)
{
int i;
char
-CC_remove_statement(ConnectionClass *self, StatementClass *stmt)
+CC_remove_statement(ConnectionClass * self, StatementClass * stmt)
{
int i;
* error message with its socket error message.
*/
char *
-CC_create_errormsg(ConnectionClass *self)
+CC_create_errormsg(ConnectionClass * self)
{
SocketClass *sock = self->sock;
int pos;
char
-CC_get_error(ConnectionClass *self, int *number, char **message)
+CC_get_error(ConnectionClass * self, int *number, char **message)
{
int rv;
* 'declare cursor C3326857 for ...' and 'fetch 100 in C3326857' statements.
*/
QResultClass *
-CC_send_query(ConnectionClass *self, char *query, QueryInfo *qi)
+CC_send_query(ConnectionClass * self, char *query, QueryInfo * qi)
{
- QResultClass *result_in = NULL, *res = NULL, *retres = NULL;
- char swallow, *wq;
+ QResultClass *result_in = NULL,
+ *res = NULL,
+ *retres = NULL;
+ char swallow,
+ *wq;
int id;
SocketClass *sock = self->sock;
- int maxlen, empty_reqs;
- BOOL msg_truncated, ReadyToReturn,
- tuples_return = FALSE, query_completed = FALSE,
- before_64 = PG_VERSION_LT(self, 6.4);
+ int maxlen,
+ empty_reqs;
+ BOOL msg_truncated,
+ ReadyToReturn,
+ tuples_return = FALSE,
+ query_completed = FALSE,
+ before_64 = PG_VERSION_LT(self, 6.4);
/* ERROR_MSG_LENGTH is suffcient */
static char msgbuffer[ERROR_MSG_LENGTH + 1];
mylog("send_query: returning res = %u\n", res);
if (!before_64)
break;
+
/*
* (Quotation from the original comments) since
* backend may produce more than one result for some
CC_set_no_trans(self);
}
else
- {
self->errornumber = CONNECTION_SERVER_REPORTED_WARNING;
- }
QR_set_status(res, PGRES_FATAL_ERROR);
QR_set_aborted(res, TRUE);
while (msg_truncated)
}
else
{ /* next fetch, so reuse an existing result */
+
/*
- * called from QR_next_tuple
- * and must return immediately.
+ * called from QR_next_tuple and must return
+ * immediately.
*/
ReadyToReturn = TRUE;
if (!QR_fetch_tuples(result_in, NULL, NULL))
retres = NULL;
break;
}
+
/*
- * There were no ReadyForQuery response before 6.4.
+ * There were no ReadyForQuery response before 6.4.
*/
if (before_64)
{
break;
}
}
- /*
- * Break before being ready to return.
+
+ /*
+ * Break before being ready to return.
*/
if (!ReadyToReturn)
{
else
retres = res;
}
+
/*
- * set notice message to result_in.
+ * set notice message to result_in.
*/
if (result_in && res && retres == result_in)
{
QR_set_status(result_in, QR_get_status(res));
QR_set_notice(result_in, QR_get_notice(res));
}
+
/*
- * Cleanup garbage results before returning.
+ * Cleanup garbage results before returning.
*/
if (res && retres != res)
QR_Destructor(res);
int
-CC_send_function(ConnectionClass *self, int fnid, void *result_buf, int *actual_result_len, int result_is_int, LO_ARG *args, int nargs)
+CC_send_function(ConnectionClass * self, int fnid, void *result_buf, int *actual_result_len, int result_is_int, LO_ARG * args, int nargs)
{
char id,
c,
char
-CC_send_settings(ConnectionClass *self)
+CC_send_settings(ConnectionClass * self)
{
/* char ini_query[MAX_MESSAGE_LEN]; */
ConnInfo *ci = &(self->connInfo);
* will go away and the define 'PG_TYPE_LO' will be updated.
*/
void
-CC_lookup_lo(ConnectionClass *self)
+CC_lookup_lo(ConnectionClass * self)
{
HSTMT hstmt;
StatementClass *stmt;
* h-inoue 01-2-2001
*/
void
-CC_initialize_pg_version(ConnectionClass *self)
+CC_initialize_pg_version(ConnectionClass * self)
{
strcpy(self->pg_version, self->connInfo.protocol);
if (PROTOCOL_62(&self->connInfo))
* DJP - 25-1-2001
*/
void
-CC_lookup_pg_version(ConnectionClass *self)
+CC_lookup_pg_version(ConnectionClass * self)
{
HSTMT hstmt;
StatementClass *stmt;
void
-CC_log_error(char *func, char *desc, ConnectionClass *self)
+CC_log_error(char *func, char *desc, ConnectionClass * self)
{
#ifdef PRN_NULLCHECK
#define nullcheck(a) (a ? a : "(NULL)")
#undef PRN_NULLCHECK
}
-int CC_get_max_query_len(const ConnectionClass *conn)
+int
+CC_get_max_query_len(const ConnectionClass * conn)
{
- int value;
- /* Long Queries in 7.0+ */
- if (PG_VERSION_GE(conn, 7.0))
- value = 0 /* MAX_STATEMENT_LEN */;
- /* Prior to 7.0 we used 2*BLCKSZ */
- else if (PG_VERSION_GE(conn, 6.5))
- value = (2 * BLCKSZ);
- else
- /* Prior to 6.5 we used BLCKSZ */
- value = BLCKSZ;
- return value;
+ int value;
+
+ /* Long Queries in 7.0+ */
+ if (PG_VERSION_GE(conn, 7.0))
+ value = 0 /* MAX_STATEMENT_LEN */ ;
+ /* Prior to 7.0 we used 2*BLCKSZ */
+ else if (PG_VERSION_GE(conn, 6.5))
+ value = (2 * BLCKSZ);
+ else
+ /* Prior to 6.5 we used BLCKSZ */
+ value = BLCKSZ;
+ return value;
}
typedef enum
{
- CONN_NOT_CONNECTED, /* Connection has not been established */
- CONN_CONNECTED, /* Connection is up and has been
+ CONN_NOT_CONNECTED, /* Connection has not been
+ * established */
+ CONN_CONNECTED, /* Connection is up and has been
* established */
- CONN_DOWN, /* Connection is broken */
- CONN_EXECUTING /* the connection is currently executing a
+ CONN_DOWN, /* Connection is broken */
+ CONN_EXECUTING /* the connection is currently executing a
* statement */
-} CONN_Status;
+} CONN_Status;
/* These errors have general sql error state */
#define CONNECTION_SERVER_NOT_REACHED 101
char focus_password;
char disallow_premature;
char updatable_cursors;
- GLOBAL_VALUES drivers; /* moved from driver's option */
-} ConnInfo;
+ GLOBAL_VALUES drivers; /* moved from driver's option */
+} ConnInfo;
/* Macro to determine is the connection using 6.2 protocol? */
#define PROTOCOL_62(conninfo_) (strncmp((conninfo_)->protocol, PG62, strlen(PG62)) == 0)
#define HINSTANCE void *
#endif
-typedef BOOL (FAR WINAPI * DataSourceToDriverProc) (UDWORD,
- SWORD,
- PTR,
- SDWORD,
- PTR,
- SDWORD,
- SDWORD FAR *,
- UCHAR FAR *,
- SWORD,
- SWORD FAR *);
-
-typedef BOOL (FAR WINAPI * DriverToDataSourceProc) (UDWORD,
- SWORD,
- PTR,
- SDWORD,
- PTR,
- SDWORD,
- SDWORD FAR *,
- UCHAR FAR *,
- SWORD,
- SWORD FAR *);
+typedef BOOL(FAR WINAPI * DataSourceToDriverProc) (UDWORD,
+ SWORD,
+ PTR,
+ SDWORD,
+ PTR,
+ SDWORD,
+ SDWORD FAR *,
+ UCHAR FAR *,
+ SWORD,
+ SWORD FAR *);
+
+typedef BOOL(FAR WINAPI * DriverToDataSourceProc) (UDWORD,
+ SWORD,
+ PTR,
+ SDWORD,
+ PTR,
+ SDWORD,
+ SDWORD FAR *,
+ UCHAR FAR *,
+ SWORD,
+ SWORD FAR *);
/******* The Connection handle ************/
struct ConnectionClass_
Int2 pg_version_minor;
char ms_jet;
#ifdef MULTIBYTE
- char *client_encoding;
- char *server_encoding;
-#endif /* MULTIBYTE */
+ char *client_encoding;
+ char *server_encoding;
+#endif /* MULTIBYTE */
};
/* prototypes */
ConnectionClass *CC_Constructor(void);
-char CC_Destructor(ConnectionClass *self);
-int CC_cursor_count(ConnectionClass *self);
-char CC_cleanup(ConnectionClass *self);
-char CC_abort(ConnectionClass *self);
-int CC_set_translation(ConnectionClass *self);
-char CC_connect(ConnectionClass *self, char do_password);
-char CC_add_statement(ConnectionClass *self, StatementClass *stmt);
-char CC_remove_statement(ConnectionClass *self, StatementClass *stmt);
-char CC_get_error(ConnectionClass *self, int *number, char **message);
-QResultClass *CC_send_query(ConnectionClass *self, char *query, QueryInfo *qi);
-void CC_clear_error(ConnectionClass *self);
-char *CC_create_errormsg(ConnectionClass *self);
-int CC_send_function(ConnectionClass *conn, int fnid, void *result_buf, int *actual_result_len, int result_is_int, LO_ARG *argv, int nargs);
-char CC_send_settings(ConnectionClass *self);
-void CC_lookup_lo(ConnectionClass *conn);
-void CC_lookup_pg_version(ConnectionClass *conn);
-void CC_initialize_pg_version(ConnectionClass *conn);
-void CC_log_error(char *func, char *desc, ConnectionClass *self);
-int CC_get_max_query_len(const ConnectionClass *self);
-
+char CC_Destructor(ConnectionClass * self);
+int CC_cursor_count(ConnectionClass * self);
+char CC_cleanup(ConnectionClass * self);
+char CC_abort(ConnectionClass * self);
+int CC_set_translation(ConnectionClass * self);
+char CC_connect(ConnectionClass * self, char do_password);
+char CC_add_statement(ConnectionClass * self, StatementClass * stmt);
+char CC_remove_statement(ConnectionClass * self, StatementClass * stmt);
+char CC_get_error(ConnectionClass * self, int *number, char **message);
+QResultClass *CC_send_query(ConnectionClass * self, char *query, QueryInfo * qi);
+void CC_clear_error(ConnectionClass * self);
+char *CC_create_errormsg(ConnectionClass * self);
+int CC_send_function(ConnectionClass * conn, int fnid, void *result_buf, int *actual_result_len, int result_is_int, LO_ARG * argv, int nargs);
+char CC_send_settings(ConnectionClass * self);
+void CC_lookup_lo(ConnectionClass * conn);
+void CC_lookup_pg_version(ConnectionClass * conn);
+void CC_initialize_pg_version(ConnectionClass * conn);
+void CC_log_error(char *func, char *desc, ConnectionClass * self);
+int CC_get_max_query_len(const ConnectionClass * self);
#endif
/*-------
- * Module: convert.c
+ * Module: convert.c
*
* Description: This module contains routines related to
* converting parameters and columns into requested data types.
{0, 0}
};
-static char *mapFunction(const char *func);
+static char *mapFunction(const char *func);
static unsigned int conv_from_octal(const unsigned char *s);
static unsigned int conv_from_hex(const unsigned char *s);
-static char *conv_to_octal(unsigned char val);
+static char *conv_to_octal(unsigned char val);
/*---------
* A Guide for date/time/timestamp conversions
/* This is called by SQLFetch() */
int
-copy_and_convert_field_bindinfo(StatementClass *stmt, Int4 field_type, void *value, int col)
+copy_and_convert_field_bindinfo(StatementClass * stmt, Int4 field_type, void *value, int col)
{
BindInfoClass *bic = &(stmt->bindings[col]);
/* This is called by SQLGetData() */
int
-copy_and_convert_field(StatementClass *stmt, Int4 field_type, void *value, Int2 fCType,
- PTR rgbValue, SDWORD cbValueMax, SDWORD *pcbValue)
+copy_and_convert_field(StatementClass * stmt, Int4 field_type, void *value, Int2 fCType,
+ PTR rgbValue, SDWORD cbValueMax, SDWORD * pcbValue)
{
Int4 len = 0,
copy_len = 0;
int pcbValueOffset,
rgbValueOffset;
char *rgbValueBindRow;
- const char *ptr;
+ const char *ptr;
int bind_row = stmt->bind_row;
int bind_size = stmt->options.bind_size;
int result = COPY_OK;
BOOL changed;
- static char *tempBuf= NULL;
- static unsigned int tempBuflen = 0;
+ static char *tempBuf = NULL;
+ static unsigned int tempBuflen = 0;
const char *neut_str = value;
- char midtemp[2][32];
- int mtemp_cnt = 0;
+ char midtemp[2][32];
+ int mtemp_cnt = 0;
if (!tempBuf)
tempBuflen = 0;
if (!value)
{
-
/*
* handle a null just by returning SQL_NULL_DATA in pcbValue, and
* doing nothing to the buffer.
*/
switch (field_type)
{
-
/*
* $$$ need to add parsing for date/time/timestamp strings in
* PG_TYPE_CHAR,VARCHAR $$$
sscanf(value, "%4d-%2d-%2d %2d:%2d:%2d", &st.y, &st.m, &st.d, &st.hh, &st.mm, &st.ss);
else
{
-
/*
* The timestamp is invalid so set something conspicuous,
* like the epoch
break;
case PG_TYPE_BOOL:
- { /* change T/F to 1/0 */
+ { /* change T/F to 1/0 */
char *s;
s = midtemp[mtemp_cnt];
{
int nval,
i;
- const char *vp;
+ const char *vp;
/* this is an array of eight integers */
short *short_array = (short *) ((char *) rgbValue + rgbValueOffset);
default:
if (stmt->current_col >= 0 && stmt->bindings[stmt->current_col].data_left == -2)
- stmt->bindings[stmt->current_col].data_left = (cbValueMax > 0) ? 0 : -1; /* This seems to be needed for ADO ? */
+ stmt->bindings[stmt->current_col].data_left = (cbValueMax > 0) ? 0 : -1; /* This seems to be
+ * needed for ADO ? */
if (stmt->current_col < 0 || stmt->bindings[stmt->current_col].data_left < 0)
{
/* convert linefeeds to carriage-return/linefeed */
len = convert_linefeeds(neut_str, NULL, 0, &changed);
- if (cbValueMax == 0) /* just returns length info */
+ if (cbValueMax == 0) /* just returns length
+ * info */
{
result = COPY_RESULT_TRUNCATED;
break;
}
else
{
-
/*
* for SQL_C_CHAR, it's probably ok to leave currency symbols in.
* But to convert to numeric types, it is necessary to get rid of
*((UCHAR *) rgbValue + bind_row) = atoi(neut_str);
/*
- * mylog("SQL_C_BIT: bind_row = %d val = %d, cb = %d, rgb=%d\n",
- * bind_row, atoi(neut_str), cbValueMax, *((UCHAR *)rgbValue));
+ * mylog("SQL_C_BIT: bind_row = %d val = %d, cb = %d,
+ * rgb=%d\n", bind_row, atoi(neut_str), cbValueMax,
+ * *((UCHAR *)rgbValue));
*/
break;
* Functions/Macros to get rid of query size limit.
*
* I always used the follwoing macros to convert from
- * old_statement to new_statement. Please improve it
+ * old_statement to new_statement. Please improve it
* if you have a better way. Hiroshi 2001/05/22
*--------------------------------------------------------------------
*/
-#define INIT_MIN_ALLOC 4096
-static int enlarge_statement(StatementClass *stmt, unsigned int newsize)
+#define INIT_MIN_ALLOC 4096
+static int
+enlarge_statement(StatementClass * stmt, unsigned int newsize)
{
- unsigned int newalsize = INIT_MIN_ALLOC;
+ unsigned int newalsize = INIT_MIN_ALLOC;
static char *func = "enlarge_statement";
if (stmt->stmt_size_limit > 0 && stmt->stmt_size_limit < (int) newsize)
* Enlarge stmt_with_params if necessary.
*----------
*/
-#define ENLARGE_NEWSTATEMENT(newpos) \
+#define ENLARGE_NEWSTATEMENT(newpos) \
if (newpos >= new_stsize) \
{ \
if ((new_stsize = enlarge_statement(stmt, newpos)) <= 0) \
* Initialize stmt_with_params, new_statement etc.
*----------
*/
-#define CVT_INIT(size) \
+#define CVT_INIT(size) \
do { \
if (stmt->stmt_with_params) \
free(stmt->stmt_with_params); \
* Terminate the stmt_with_params string with NULL.
*----------
*/
-#define CVT_TERMINATE \
+#define CVT_TERMINATE \
do { \
new_statement[npos] = '\0'; \
} while (0)
* Append a data.
*----------
*/
-#define CVT_APPEND_DATA(s, len) \
+#define CVT_APPEND_DATA(s, len) \
do { \
unsigned int newpos = npos + len; \
ENLARGE_NEWSTATEMENT(newpos) \
* Append a string.
*----------
*/
-#define CVT_APPEND_STR(s) \
+#define CVT_APPEND_STR(s) \
do { \
unsigned int len = strlen(s); \
CVT_APPEND_DATA(s, len); \
} while (0)
/*----------
- * Append a char.
+ * Append a char.
*----------
*/
-#define CVT_APPEND_CHAR(c) \
+#define CVT_APPEND_CHAR(c) \
do { \
ENLARGE_NEWSTATEMENT(npos + 1); \
new_statement[npos++] = c; \
/*----------
* Append a binary data.
- * Newly reqeuired size may be overestimated currently.
+ * Newly reqeuired size may be overestimated currently.
*----------
*/
-#define CVT_APPEND_BINARY(buf, used) \
+#define CVT_APPEND_BINARY(buf, used) \
do { \
unsigned int newlimit = npos + 5 * used; \
ENLARGE_NEWSTATEMENT(newlimit); \
*
*----------
*/
-#define CVT_SPECIAL_CHARS(buf, used) \
+#define CVT_SPECIAL_CHARS(buf, used) \
do { \
- int cnvlen = convert_special_chars(buf, NULL, used); \
+ int cnvlen = convert_special_chars(buf, NULL, used); \
unsigned int newlimit = npos + cnvlen; \
\
ENLARGE_NEWSTATEMENT(newlimit); \
} while (0)
/*----------
- * Check if the statement is
+ * Check if the statement is
* SELECT ... INTO table FROM .....
* This isn't really a strict check but ...
- *----------
+ *----------
*/
static BOOL
into_table_from(const char *stmt)
case ',':
case '\'':
return FALSE;
- case '\"': /* double quoted table name ? */
+ case '\"': /* double quoted table name ? */
do
{
do
- {
- while (*(++stmt) != '\"' && *stmt);
- }
+ while (*(++stmt) != '\"' && *stmt);
while (*stmt && *(++stmt) == '\"');
- while (*stmt && !isspace((unsigned char) *stmt) && *stmt != '\"') stmt++;
+ while (*stmt && !isspace((unsigned char) *stmt) && *stmt != '\"')
+ stmt++;
}
while (*stmt == '\"');
break;
while (!isspace((unsigned char) *(++stmt)));
break;
}
- if (! *stmt)
+ if (!*stmt)
return FALSE;
while (isspace((unsigned char) *(++stmt)));
if (strnicmp(stmt, "from", 4))
}
/*----------
- * Check if the statement is
+ * Check if the statement is
* SELECT ... FOR UPDATE .....
* This isn't really a strict check but ...
- *----------
+ *----------
*/
static BOOL
table_for_update(const char *stmt, int *endpos)
{
const char *wstmt = stmt;
+
while (isspace((unsigned char) *(++wstmt)));
- if (! *wstmt)
+ if (!*wstmt)
return FALSE;
if (strnicmp(wstmt, "update", 6))
return FALSE;
* This function does a dynamic memory allocation to get rid of query size limit!
*/
int
-copy_statement_with_parameters(StatementClass *stmt)
+copy_statement_with_parameters(StatementClass * stmt)
{
static char *func = "copy_statement_with_parameters";
unsigned int opos,
oldstmtlen;
char param_string[128],
tmp[256],
- cbuf[PG_NUMERIC_MAX_PRECISION * 2]; /* seems big enough to handle the data in this function */
+ cbuf[PG_NUMERIC_MAX_PRECISION * 2]; /* seems big enough to
+ * handle the data in
+ * this function */
int param_number;
Int2 param_ctype,
param_sqltype;
- char *old_statement = stmt->statement, oldchar;
+ char *old_statement = stmt->statement,
+ oldchar;
char *new_statement = stmt->stmt_with_params;
- unsigned int new_stsize = 0;
+ unsigned int new_stsize = 0;
SIMPLE_TIME st;
time_t t = time(NULL);
struct tm *tim;
SDWORD used;
- char *buffer, *buf;
- BOOL in_quote = FALSE, in_dquote = FALSE, in_escape = FALSE;
+ char *buffer,
+ *buf;
+ BOOL in_quote = FALSE,
+ in_dquote = FALSE,
+ in_escape = FALSE;
Oid lobj_oid;
int lobj_fd,
retval;
- BOOL check_cursor_ok = FALSE; /* check cursor restriction */
- BOOL proc_no_param = TRUE;
- unsigned int declare_pos = 0;
- ConnectionClass *conn = SC_get_conn(stmt);
- ConnInfo *ci = &(conn->connInfo);
- BOOL prepare_dummy_cursor = FALSE, begin_first = FALSE;
- char token_save[64];
- int token_len;
- BOOL prev_token_end;
+ BOOL check_cursor_ok = FALSE; /* check cursor
+ * restriction */
+ BOOL proc_no_param = TRUE;
+ unsigned int declare_pos = 0;
+ ConnectionClass *conn = SC_get_conn(stmt);
+ ConnInfo *ci = &(conn->connInfo);
+ BOOL prepare_dummy_cursor = FALSE,
+ begin_first = FALSE;
+ char token_save[64];
+ int token_len;
+ BOOL prev_token_end;
+
#ifdef DRIVER_CURSOR_IMPLEMENT
- BOOL search_from_pos = FALSE;
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+ BOOL search_from_pos = FALSE;
+#endif /* DRIVER_CURSOR_IMPLEMENT */
if (ci->disallow_premature)
prepare_dummy_cursor = stmt->pre_executing;
stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
}
else if (stmt->options.cursor_type == SQL_CURSOR_FORWARD_ONLY)
- stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
+ stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
else if (stmt->options.scroll_concurrency != SQL_CONCUR_READ_ONLY)
{
if (stmt->parse_status == STMT_PARSE_NONE)
if (stmt->parse_status != STMT_PARSE_COMPLETE)
stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
else if (!stmt->ti || stmt->ntab != 1)
- stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
+ stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
else
search_from_pos = TRUE;
}
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+#endif /* DRIVER_CURSOR_IMPLEMENT */
/* If the application hasn't set a cursor name, then generate one */
if (stmt->cursor_name[0] == '\0')
else if (ci->drivers.use_declarefetch)
SC_set_fetchcursor(stmt);
sprintf(new_statement, "%sdeclare %s cursor for ",
- new_statement, stmt->cursor_name);
+ new_statement, stmt->cursor_name);
npos = strlen(new_statement);
check_cursor_ok = TRUE;
declare_pos = npos;
CVT_APPEND_CHAR(oldchar);
continue;
}
+
/*
- * From here we are guaranteed to handle a
- * 1-byte character.
+ * From here we are guaranteed to handle a 1-byte character.
*/
#endif
- if (in_escape) /* escape check */
+ if (in_escape) /* escape check */
{
in_escape = FALSE;
CVT_APPEND_CHAR(oldchar);
continue;
- }
+ }
else if (in_quote || in_dquote) /* quote/double quote check */
{
if (oldchar == '\\')
else if (oldchar == '\"' && in_dquote)
in_dquote = FALSE;
CVT_APPEND_CHAR(oldchar);
- continue;
+ continue;
}
+
/*
- * From here we are guranteed to be in neither
- * an escape, a quote nor a double quote.
+ * From here we are guranteed to be in neither an escape, a quote
+ * nor a double quote.
*/
/* Squeeze carriage-return/linefeed pairs to linefeed only */
else if (oldchar == '\r' && opos + 1 < oldstmtlen &&
- old_statement[opos + 1] == '\n')
+ old_statement[opos + 1] == '\n')
continue;
+
/*
* Handle literals (date, time, timestamp) and ODBC scalar
* functions
#else
char *end = strchr(begin, '}');
-
#endif
if (!end)
/* procedure calls */
if (stmt->statement_type == STMT_TYPE_PROCCALL)
{
- int lit_call_len = 4;
+ int lit_call_len = 4;
+
while (isspace((unsigned char) old_statement[++opos]));
/* '=?' to accept return values exists ? */
if (old_statement[opos] == '?')
opos--;
continue;
}
- opos += lit_call_len;
+ opos += lit_call_len;
CVT_APPEND_STR("SELECT ");
#ifdef MULTIBYTE
if (multibyte_strchr(&old_statement[opos], '('))
#else
if (strchr(&old_statement[opos], '('))
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
proc_no_param = FALSE;
- continue;
+ continue;
}
*end = '\0';
esc = convert_escape(begin);
if (esc)
- {
CVT_APPEND_STR(esc);
- }
else
{ /* it's not a valid literal so just copy */
*end = '}';
in_escape = TRUE;
else if (oldchar == '\"')
in_dquote = TRUE;
- else
+ else
{
if (isspace(oldchar))
{
if (token_len == 4)
{
if (check_cursor_ok &&
- into_table_from(&old_statement[opos - token_len]))
+ into_table_from(&old_statement[opos - token_len]))
{
stmt->statement_type = STMT_TYPE_CREATE;
SC_no_pre_executable(stmt);
}
#ifdef DRIVER_CURSOR_IMPLEMENT
else if (search_from_pos && /* where's from clause */
- strnicmp(token_save, "from", 4) == 0)
+ strnicmp(token_save, "from", 4) == 0)
{
search_from_pos = FALSE;
npos -= 5;
CVT_APPEND_STR(", CTID, OID from");
}
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+#endif /* DRIVER_CURSOR_IMPLEMENT */
}
if (token_len == 3)
{
- int endpos;
+ int endpos;
+
if (check_cursor_ok &&
- strnicmp(token_save, "for", 3) == 0 &&
- table_for_update(&old_statement[opos], &endpos))
+ strnicmp(token_save, "for", 3) == 0 &&
+ table_for_update(&old_statement[opos], &endpos))
{
SC_no_fetchcursor(stmt);
stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
}
}
}
- }
+ }
}
else if (prev_token_end)
{
}
else if (token_len + 1 < sizeof(token_save))
token_save[token_len++] = oldchar;
- }
+ }
CVT_APPEND_CHAR(oldchar);
continue;
}
}
else
{
-
-
+
+
used = stmt->parameters[param_number].used ? *stmt->parameters[param_number].used : SQL_NTS;
-
+
buffer = stmt->parameters[param_number].buffer;
}
/* it was a SQL_C_CHAR */
if (buf)
- {
CVT_SPECIAL_CHARS(buf, used);
- }
/* it was a numeric type */
else if (param_string[0] != '\0')
- {
CVT_APPEND_STR(param_string);
- }
/* it was date,time,timestamp -- use m,d,y,hh,mm,ss */
else
int length = strlen(new_statement);
conn->DriverToDataSource(conn->translation_option,
- SQL_CHAR,
- new_statement, length,
- new_statement, length, NULL,
- NULL, 0, NULL);
+ SQL_CHAR,
+ new_statement, length,
+ new_statement, length, NULL,
+ NULL, 0, NULL);
}
#ifdef DRIVER_CURSOR_IMPLEMENT
if (search_from_pos)
stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+#endif /* DRIVER_CURSOR_IMPLEMENT */
if (prepare_dummy_cursor && SC_is_pre_executable(stmt))
{
- char fetchstr[128];
+ char fetchstr[128];
+
sprintf(fetchstr, ";fetch backward in %s;close %s;",
stmt->cursor_name, stmt->cursor_name);
if (begin_first && CC_is_in_autocommit(conn))
}
else if (strcmp(key, "fn") == 0)
{
-
/*
* Function invocation Separate off the func name, skipping
* trailing whitespace.
mapFunc = mapFunction(key);
/*
- * We could have mapFunction() return key if not in table...
- * - thomas 2000-04-03
+ * We could have mapFunction() return key if not in table... -
+ * thomas 2000-04-03
*/
if (mapFunc == NULL)
{
BOOL
convert_money(const char *s, char *sout, size_t soutmax)
{
- size_t i = 0, out = 0;
+ size_t i = 0,
+ out = 0;
for (i = 0; s[i]; i++)
{
else
{
if (out + 1 >= soutmax)
- return FALSE; /* sout is too short */
+ return FALSE; /* sout is too short */
if (s[i] == '(')
sout[out++] = '-';
else
* It does not zero out SIMPLE_TIME in case it is desired to initialize it with a value
*/
char
-parse_datetime(char *buf, SIMPLE_TIME *st)
+parse_datetime(char *buf, SIMPLE_TIME * st)
{
int y,
m,
/* Change linefeed to carriage-return/linefeed */
int
-convert_linefeeds(const char *si, char *dst, size_t max, BOOL *changed)
+convert_linefeeds(const char *si, char *dst, size_t max, BOOL * changed)
{
size_t i = 0,
out = 0;
int
convert_from_pgbinary(const unsigned char *value, unsigned char *rgbValue, int cbValueMax)
{
- size_t i, ilen = strlen(value);
+ size_t i,
+ ilen = strlen(value);
int o = 0;
void
encode(const char *in, char *out)
{
- unsigned int i, ilen = strlen(in),
+ unsigned int i,
+ ilen = strlen(in),
o = 0;
for (i = 0; i < ilen; i++)
void
decode(const char *in, char *out)
{
- unsigned int i, ilen = strlen(in),
+ unsigned int i,
+ ilen = strlen(in),
o = 0;
for (i = 0; i < ilen; i++)
*-------
*/
int
-convert_lo(StatementClass *stmt, const void *value, Int2 fCType, PTR rgbValue,
- SDWORD cbValueMax, SDWORD *pcbValue)
+convert_lo(StatementClass * stmt, const void *value, Int2 fCType, PTR rgbValue,
+ SDWORD cbValueMax, SDWORD * pcbValue)
{
Oid oid;
int retval,
result,
left = -1;
BindInfoClass *bindInfo = NULL;
- ConnectionClass *conn = SC_get_conn(stmt);
- ConnInfo *ci = &(conn->connInfo);
+ ConnectionClass *conn = SC_get_conn(stmt);
+ ConnInfo *ci = &(conn->connInfo);
/* If using SQLGetData, then current_col will be set */
if (stmt->current_col >= 0)
int hh;
int mm;
int ss;
-} SIMPLE_TIME;
+} SIMPLE_TIME;
-int copy_and_convert_field_bindinfo(StatementClass *stmt, Int4 field_type, void *value, int col);
-int copy_and_convert_field(StatementClass *stmt, Int4 field_type, void *value, Int2 fCType,
- PTR rgbValue, SDWORD cbValueMax, SDWORD *pcbValue);
+int copy_and_convert_field_bindinfo(StatementClass * stmt, Int4 field_type, void *value, int col);
+int copy_and_convert_field(StatementClass * stmt, Int4 field_type, void *value, Int2 fCType,
+ PTR rgbValue, SDWORD cbValueMax, SDWORD * pcbValue);
-int copy_statement_with_parameters(StatementClass *stmt);
+int copy_statement_with_parameters(StatementClass * stmt);
char *convert_escape(char *value);
-BOOL convert_money(const char *s, char *sout, size_t soutmax);
-char parse_datetime(char *buf, SIMPLE_TIME *st);
-int convert_linefeeds(const char *s, char *dst, size_t max, BOOL *changed);
-int convert_special_chars(const char *si, char *dst, int used);
+BOOL convert_money(const char *s, char *sout, size_t soutmax);
+char parse_datetime(char *buf, SIMPLE_TIME * st);
+int convert_linefeeds(const char *s, char *dst, size_t max, BOOL * changed);
+int convert_special_chars(const char *si, char *dst, int used);
int convert_pgbinary_to_char(const char *value, char *rgbValue, int cbValueMax);
int convert_from_pgbinary(const unsigned char *value, unsigned char *rgbValue, int cbValueMax);
int convert_to_pgbinary(const unsigned char *in, char *out, int len);
void encode(const char *in, char *out);
void decode(const char *in, char *out);
-int convert_lo(StatementClass *stmt, const void *value, Int2 fCType, PTR rgbValue,
- SDWORD cbValueMax, SDWORD *pcbValue);
-
+int convert_lo(StatementClass * stmt, const void *value, Int2 fCType, PTR rgbValue,
+ SDWORD cbValueMax, SDWORD * pcbValue);
#endif
#endif
extern GLOBAL_VALUES globals;
+
#ifdef WIN32
-static int driver_optionsDraw(HWND, const ConnInfo *, int src, BOOL enable);
-static int driver_options_update(HWND hdlg, ConnInfo *ci, BOOL);
-static void updateCommons(const ConnInfo *ci);
+static int driver_optionsDraw(HWND, const ConnInfo *, int src, BOOL enable);
+static int driver_options_update(HWND hdlg, ConnInfo * ci, BOOL);
+static void updateCommons(const ConnInfo * ci);
#endif
#ifdef WIN32
void
-SetDlgStuff(HWND hdlg, const ConnInfo *ci)
+SetDlgStuff(HWND hdlg, const ConnInfo * ci)
{
-
/*
* If driver attribute NOT present, then set the datasource name and
* description
void
-GetDlgStuff(HWND hdlg, ConnInfo *ci)
+GetDlgStuff(HWND hdlg, ConnInfo * ci)
{
GetDlgItemText(hdlg, IDC_DESC, ci->desc, sizeof(ci->desc));
static int
-driver_optionsDraw(HWND hdlg, const ConnInfo *ci, int src, BOOL enable)
+driver_optionsDraw(HWND hdlg, const ConnInfo * ci, int src, BOOL enable)
{
- const GLOBAL_VALUES *comval;
- static BOOL defset = FALSE;
- static GLOBAL_VALUES defval;
-
+ const GLOBAL_VALUES *comval;
+ static BOOL defset = FALSE;
+ static GLOBAL_VALUES defval;
+
switch (src)
{
- case 0: /* driver common */
+ case 0: /* driver common */
comval = &globals;
break;
- case 1: /* dsn specific */
+ case 1: /* dsn specific */
comval = &(ci->drivers);
break;
- case 2: /* default */
+ case 2: /* default */
if (!defset)
{
defval.commlog = DEFAULT_COMMLOG;
return 0;
}
static int
-driver_options_update(HWND hdlg, ConnInfo *ci, BOOL updateProfile)
+driver_options_update(HWND hdlg, ConnInfo * ci, BOOL updateProfile)
{
- GLOBAL_VALUES *comval;
+ GLOBAL_VALUES *comval;
if (ci)
comval = &(ci->drivers);
comval->fetch_max = GetDlgItemInt(hdlg, DRV_CACHE_SIZE, NULL, FALSE);
comval->max_varchar_size = GetDlgItemInt(hdlg, DRV_VARCHAR_SIZE, NULL, FALSE);
comval->max_longvarchar_size = GetDlgItemInt(hdlg, DRV_LONGVARCHAR_SIZE, NULL, TRUE); /* allows for
- * SQL_NO_TOTAL */
+ * SQL_NO_TOTAL */
GetDlgItemText(hdlg, DRV_EXTRASYSTABLEPREFIXES, comval->extra_systable_prefixes, sizeof(comval->extra_systable_prefixes));
WPARAM wParam,
LPARAM lParam)
{
- ConnInfo *ci;
+ ConnInfo *ci;
+
switch (wMsg)
{
case WM_INITDIALOG:
- SetWindowLong(hdlg, DWL_USER, lParam); /* save for OK etc */
+ SetWindowLong(hdlg, DWL_USER, lParam); /* save for OK etc */
ci = (ConnInfo *) lParam;
CheckDlgButton(hdlg, DRV_OR_DSN, 0);
if (ci && ci->dsn && ci->dsn[0])
- {
SetWindowText(hdlg, "Advanced Options (per DSN)");
- }
else
{
SetWindowText(hdlg, "Advanced Options (Connection)");
case IDOK:
ci = (ConnInfo *) GetWindowLong(hdlg, DWL_USER);
driver_options_update(hdlg, IsDlgButtonChecked(hdlg, DRV_OR_DSN) ? NULL : ci,
- ci && ci->dsn && ci->dsn[0]);
+ ci && ci->dsn && ci->dsn[0]);
case IDCANCEL:
EndDialog(hdlg, GET_WM_COMMAND_ID(wParam, lParam) == IDOK);
else
{
ConnInfo *ci = (ConnInfo *) GetWindowLong(hdlg, DWL_USER);
+
driver_optionsDraw(hdlg, ci, 0, FALSE);
}
break;
else
{
ConnInfo *ci = (ConnInfo *) GetWindowLong(hdlg, DWL_USER);
+
SetWindowText(hdlg, "Advanced Options (per DSN)");
driver_optionsDraw(hdlg, ci, ci ? 1 : 0, ci == NULL);
}
* to the ODBCINST.INI portion of the registry
*/
static void
-updateCommons(const ConnInfo *ci)
+updateCommons(const ConnInfo * ci)
{
- const char *sectionName;
- const char *fileName;
- const GLOBAL_VALUES *comval;
+ const char *sectionName;
+ const char *fileName;
+ const GLOBAL_VALUES *comval;
char tmp[128];
if (ci)
{
mylog("ci but dsn==NULL\n");
return;
- }
+ }
else
{
mylog("drivers updating\n");
SQLWritePrivateProfileString(sectionName,
INI_KSQO, tmp, fileName);
- /* Never update the onlyread, unique_index from this module
- sprintf(tmp, "%d", comval->unique_index);
- SQLWritePrivateProfileString(sectionName,
- INI_UNIQUEINDEX, tmp, fileName);
-
- sprintf(tmp, "%d", comval->onlyread);
- SQLWritePrivateProfileString(sectionName,
- INI_READONLY, tmp, fileName);*/
+ /*
+ * Never update the onlyread, unique_index from this module
+ * sprintf(tmp, "%d", comval->unique_index);
+ * SQLWritePrivateProfileString(sectionName, INI_UNIQUEINDEX, tmp,
+ * fileName);
+ *
+ * sprintf(tmp, "%d", comval->onlyread);
+ * SQLWritePrivateProfileString(sectionName, INI_READONLY, tmp,
+ * fileName);
+ */
sprintf(tmp, "%d", comval->use_declarefetch);
SQLWritePrivateProfileString(sectionName,
sprintf(tmp, "%d", comval->text_as_longvarchar);
SQLWritePrivateProfileString(sectionName,
- INI_TEXTASLONGVARCHAR, tmp, fileName);
+ INI_TEXTASLONGVARCHAR, tmp, fileName);
sprintf(tmp, "%d", comval->unknowns_as_longvarchar);
SQLWritePrivateProfileString(sectionName,
- INI_UNKNOWNSASLONGVARCHAR, tmp, fileName);
+ INI_UNKNOWNSASLONGVARCHAR, tmp, fileName);
sprintf(tmp, "%d", comval->bools_as_char);
SQLWritePrivateProfileString(sectionName,
sprintf(tmp, "%d", comval->max_longvarchar_size);
SQLWritePrivateProfileString(sectionName,
- INI_MAXLONGVARCHARSIZE, tmp, fileName);
+ INI_MAXLONGVARCHARSIZE, tmp, fileName);
SQLWritePrivateProfileString(sectionName,
- INI_EXTRASYSTABLEPREFIXES, comval->extra_systable_prefixes, fileName);
+ INI_EXTRASYSTABLEPREFIXES, comval->extra_systable_prefixes, fileName);
- /* Never update the conn_setting from this module
- SQLWritePrivateProfileString(sectionName,
- INI_CONNSETTINGS, comval->conn_settings, fileName); */
+ /*
+ * Never update the conn_setting from this module
+ * SQLWritePrivateProfileString(sectionName, INI_CONNSETTINGS,
+ * comval->conn_settings, fileName);
+ */
}
#endif /* WIN32 */
void
-makeConnectString(char *connect_string, const ConnInfo *ci, UWORD len)
+makeConnectString(char *connect_string, const ConnInfo * ci, UWORD len)
{
char got_dsn = (ci->dsn[0] != '\0');
char encoded_conn_settings[LARGE_REGISTRY_LEN];
hlen = strlen(connect_string);
if (!abbrev)
sprintf(&connect_string[hlen],
- ";READONLY=%s;PROTOCOL=%s;FAKEOIDINDEX=%s;SHOWOIDCOLUMN=%s;ROWVERSIONING=%s;SHOWSYSTEMTABLES=%s;CONNSETTINGS=%s;FETCH=%d;SOCKET=%d;UNKNOWNSIZES=%d;MAXVARCHARSIZE=%d;MAXLONGVARCHARSIZE=%d;DEBUG=%d;COMMLOG=%d;OPTIMIZER=%d;KSQO=%d;USEDECLAREFETCH=%d;TEXTASLONGVARCHAR=%d;UNKNOWNSASLONGVARCHAR=%d;BOOLSASCHAR=%d;PARSE=%d;CANCELASFREESTMT=%d;EXTRASYSTABLEPREFIXES=%s",
- ci->onlyread,
- ci->protocol,
- ci->fake_oid_index,
- ci->show_oid_column,
- ci->row_versioning,
- ci->show_system_tables,
- encoded_conn_settings,
- ci->drivers.fetch_max,
- ci->drivers.socket_buffersize,
- ci->drivers.unknown_sizes,
- ci->drivers.max_varchar_size,
- ci->drivers.max_longvarchar_size,
- ci->drivers.debug,
- ci->drivers.commlog,
- ci->drivers.disable_optimizer,
- ci->drivers.ksqo,
- ci->drivers.use_declarefetch,
- ci->drivers.text_as_longvarchar,
- ci->drivers.unknowns_as_longvarchar,
- ci->drivers.bools_as_char,
- ci->drivers.parse,
- ci->drivers.cancel_as_freestmt,
- ci->drivers.extra_systable_prefixes);
+ ";READONLY=%s;PROTOCOL=%s;FAKEOIDINDEX=%s;SHOWOIDCOLUMN=%s;ROWVERSIONING=%s;SHOWSYSTEMTABLES=%s;CONNSETTINGS=%s;FETCH=%d;SOCKET=%d;UNKNOWNSIZES=%d;MAXVARCHARSIZE=%d;MAXLONGVARCHARSIZE=%d;DEBUG=%d;COMMLOG=%d;OPTIMIZER=%d;KSQO=%d;USEDECLAREFETCH=%d;TEXTASLONGVARCHAR=%d;UNKNOWNSASLONGVARCHAR=%d;BOOLSASCHAR=%d;PARSE=%d;CANCELASFREESTMT=%d;EXTRASYSTABLEPREFIXES=%s",
+ ci->onlyread,
+ ci->protocol,
+ ci->fake_oid_index,
+ ci->show_oid_column,
+ ci->row_versioning,
+ ci->show_system_tables,
+ encoded_conn_settings,
+ ci->drivers.fetch_max,
+ ci->drivers.socket_buffersize,
+ ci->drivers.unknown_sizes,
+ ci->drivers.max_varchar_size,
+ ci->drivers.max_longvarchar_size,
+ ci->drivers.debug,
+ ci->drivers.commlog,
+ ci->drivers.disable_optimizer,
+ ci->drivers.ksqo,
+ ci->drivers.use_declarefetch,
+ ci->drivers.text_as_longvarchar,
+ ci->drivers.unknowns_as_longvarchar,
+ ci->drivers.bools_as_char,
+ ci->drivers.parse,
+ ci->drivers.cancel_as_freestmt,
+ ci->drivers.extra_systable_prefixes);
/* Abbrebiation is needed ? */
if (abbrev || strlen(connect_string) >= len)
sprintf(&connect_string[hlen],
- ";A0=%s;A1=%s;A2=%s;A3=%s;A4=%s;A5=%s;A6=%s;A7=%d;A8=%d;A9=%d;B0=%d;B1=%d;B2=%d;B3=%d;B4=%d;B5=%d;B6=%d;B7=%d;B8=%d;B9=%d;C0=%d;C1=%d;C2=%s",
- ci->onlyread,
- ci->protocol,
- ci->fake_oid_index,
- ci->show_oid_column,
- ci->row_versioning,
- ci->show_system_tables,
- encoded_conn_settings,
- ci->drivers.fetch_max,
- ci->drivers.socket_buffersize,
- ci->drivers.unknown_sizes,
- ci->drivers.max_varchar_size,
- ci->drivers.max_longvarchar_size,
- ci->drivers.debug,
- ci->drivers.commlog,
- ci->drivers.disable_optimizer,
- ci->drivers.ksqo,
- ci->drivers.use_declarefetch,
- ci->drivers.text_as_longvarchar,
- ci->drivers.unknowns_as_longvarchar,
- ci->drivers.bools_as_char,
- ci->drivers.parse,
- ci->drivers.cancel_as_freestmt,
- ci->drivers.extra_systable_prefixes);
+ ";A0=%s;A1=%s;A2=%s;A3=%s;A4=%s;A5=%s;A6=%s;A7=%d;A8=%d;A9=%d;B0=%d;B1=%d;B2=%d;B3=%d;B4=%d;B5=%d;B6=%d;B7=%d;B8=%d;B9=%d;C0=%d;C1=%d;C2=%s",
+ ci->onlyread,
+ ci->protocol,
+ ci->fake_oid_index,
+ ci->show_oid_column,
+ ci->row_versioning,
+ ci->show_system_tables,
+ encoded_conn_settings,
+ ci->drivers.fetch_max,
+ ci->drivers.socket_buffersize,
+ ci->drivers.unknown_sizes,
+ ci->drivers.max_varchar_size,
+ ci->drivers.max_longvarchar_size,
+ ci->drivers.debug,
+ ci->drivers.commlog,
+ ci->drivers.disable_optimizer,
+ ci->drivers.ksqo,
+ ci->drivers.use_declarefetch,
+ ci->drivers.text_as_longvarchar,
+ ci->drivers.unknowns_as_longvarchar,
+ ci->drivers.bools_as_char,
+ ci->drivers.parse,
+ ci->drivers.cancel_as_freestmt,
+ ci->drivers.extra_systable_prefixes);
}
void
-copyAttributes(ConnInfo *ci, const char *attribute, const char *value)
+copyAttributes(ConnInfo * ci, const char *attribute, const char *value)
{
if (stricmp(attribute, "DSN") == 0)
strcpy(ci->dsn, value);
/* strcpy(ci->conn_settings, value); */
}
else if (stricmp(attribute, INI_DISALLOWPREMATURE) == 0 || stricmp(attribute, "C3") == 0)
- {
ci->disallow_premature = atoi(value);
- }
else if (stricmp(attribute, INI_UPDATABLECURSORS) == 0 || stricmp(attribute, "C4") == 0)
- {
ci->updatable_cursors = atoi(value);
- }
mylog("copyAttributes: DSN='%s',server='%s',dbase='%s',user='%s',passwd='%s',port='%s',onlyread='%s',protocol='%s',conn_settings='%s',disallow_premature=%d)\n", ci->dsn, ci->server, ci->database, ci->username, ci->password, ci->port, ci->onlyread, ci->protocol, ci->conn_settings, ci->disallow_premature);
}
void
-copyCommonAttributes(ConnInfo *ci, const char *attribute, const char *value)
+copyCommonAttributes(ConnInfo * ci, const char *attribute, const char *value)
{
if (stricmp(attribute, INI_FETCH) == 0 || stricmp(attribute, "A7") == 0)
ci->drivers.fetch_max = atoi(value);
ci->drivers.disable_optimizer = atoi(value);
else if (stricmp(attribute, INI_KSQO) == 0 || stricmp(attribute, "B5") == 0)
ci->drivers.ksqo = atoi(value);
+
/*
- else if (stricmp(attribute, INI_UNIQUEINDEX) == 0 || stricmp(attribute, "UIX") == 0)
- ci->drivers.unique_index = atoi(value);
- */
+ * else if (stricmp(attribute, INI_UNIQUEINDEX) == 0 ||
+ * stricmp(attribute, "UIX") == 0) ci->drivers.unique_index =
+ * atoi(value);
+ */
else if (stricmp(attribute, INI_UNKNOWNSIZES) == 0 || stricmp(attribute, "A9") == 0)
ci->drivers.unknown_sizes = atoi(value);
else if (stricmp(attribute, INI_LIE) == 0)
else if (stricmp(attribute, INI_EXTRASYSTABLEPREFIXES) == 0 || stricmp(attribute, "C2") == 0)
strcpy(ci->drivers.extra_systable_prefixes, value);
mylog("CopyCommonAttributes: A7=%d;A8=%d;A9=%d;B0=%d;B1=%d;B2=%d;B3=%d;B4=%d;B5=%d;B6=%d;B7=%d;B8=%d;B9=%d;C0=%d;C1=%d;C2=%s",
- ci->drivers.fetch_max,
- ci->drivers.socket_buffersize,
- ci->drivers.unknown_sizes,
- ci->drivers.max_varchar_size,
- ci->drivers.max_longvarchar_size,
- ci->drivers.debug,
- ci->drivers.commlog,
- ci->drivers.disable_optimizer,
- ci->drivers.ksqo,
- ci->drivers.use_declarefetch,
- ci->drivers.text_as_longvarchar,
- ci->drivers.unknowns_as_longvarchar,
- ci->drivers.bools_as_char,
- ci->drivers.parse,
- ci->drivers.cancel_as_freestmt,
- ci->drivers.extra_systable_prefixes);
+ ci->drivers.fetch_max,
+ ci->drivers.socket_buffersize,
+ ci->drivers.unknown_sizes,
+ ci->drivers.max_varchar_size,
+ ci->drivers.max_longvarchar_size,
+ ci->drivers.debug,
+ ci->drivers.commlog,
+ ci->drivers.disable_optimizer,
+ ci->drivers.ksqo,
+ ci->drivers.use_declarefetch,
+ ci->drivers.text_as_longvarchar,
+ ci->drivers.unknowns_as_longvarchar,
+ ci->drivers.bools_as_char,
+ ci->drivers.parse,
+ ci->drivers.cancel_as_freestmt,
+ ci->drivers.extra_systable_prefixes);
}
void
-getDSNdefaults(ConnInfo *ci)
+getDSNdefaults(ConnInfo * ci)
{
if (ci->port[0] == '\0')
strcpy(ci->port, DEFAULT_PORT);
void
-getDSNinfo(ConnInfo *ci, char overwrite)
+getDSNinfo(ConnInfo * ci, char overwrite)
{
char *DSN = ci->dsn;
char encoded_conn_settings[LARGE_REGISTRY_LEN],
- temp[SMALL_REGISTRY_LEN];
+ temp[SMALL_REGISTRY_LEN];
/*
* If a driver keyword was present, then dont use a DSN and return.
/* This is for datasource based options only */
void
-writeDSNinfo(const ConnInfo *ci)
+writeDSNinfo(const ConnInfo * ci)
{
- const char *DSN = ci->dsn;
+ const char *DSN = ci->dsn;
char encoded_conn_settings[LARGE_REGISTRY_LEN],
- temp[SMALL_REGISTRY_LEN];
+ temp[SMALL_REGISTRY_LEN];
encode(ci->conn_settings, encoded_conn_settings);
encoded_conn_settings,
ODBC_INI);
- sprintf(temp, "%d", ci->disallow_premature);
+ sprintf(temp, "%d", ci->disallow_premature);
SQLWritePrivateProfileString(DSN,
INI_DISALLOWPREMATURE,
temp,
ODBC_INI);
- sprintf(temp, "%d", ci->updatable_cursors);
+ sprintf(temp, "%d", ci->updatable_cursors);
SQLWritePrivateProfileString(DSN,
INI_UPDATABLECURSORS,
temp,
* the registry and gets any driver defaults.
*/
void
-getCommonDefaults(const char *section, const char *filename, ConnInfo *ci)
+getCommonDefaults(const char *section, const char *filename, ConnInfo * ci)
{
char temp[256];
- GLOBAL_VALUES *comval;
+ GLOBAL_VALUES *comval;
if (ci)
comval = &(ci->drivers);
/* Dont allow override of an override! */
if (!ci)
{
-
/*
* ConnSettings is stored in the driver section and per datasource
* for override
*/
SQLGetPrivateProfileString(section, INI_CONNSETTINGS, "",
- comval->conn_settings, sizeof(comval->conn_settings), filename);
+ comval->conn_settings, sizeof(comval->conn_settings), filename);
/* Default state for future DSN's Readonly attribute */
SQLGetPrivateProfileString(section, INI_READONLY, "",
#define DEFAULT_EXTRASYSTABLEPREFIXES "dd_;"
/* prototypes */
-void getCommonDefaults(const char *section, const char *filename, ConnInfo *ci);
+void getCommonDefaults(const char *section, const char *filename, ConnInfo * ci);
#ifdef WIN32
-void SetDlgStuff(HWND hdlg, const ConnInfo *ci);
-void GetDlgStuff(HWND hdlg, ConnInfo *ci);
+void SetDlgStuff(HWND hdlg, const ConnInfo * ci);
+void GetDlgStuff(HWND hdlg, ConnInfo * ci);
int CALLBACK driver_optionsProc(HWND hdlg,
WORD wMsg,
WORD wMsg,
WPARAM wParam,
LPARAM lParam);
-
#endif /* WIN32 */
void updateGlobals(void);
-void writeDSNinfo(const ConnInfo *ci);
-void getDSNdefaults(ConnInfo *ci);
-void getDSNinfo(ConnInfo *ci, char overwrite);
-void makeConnectString(char *connect_string, const ConnInfo *ci, UWORD);
-void copyAttributes(ConnInfo *ci, const char *attribute, const char *value);
-void copyCommonAttributes(ConnInfo *ci, const char *attribute, const char *value);
-
+void writeDSNinfo(const ConnInfo * ci);
+void getDSNdefaults(ConnInfo * ci);
+void getDSNinfo(ConnInfo * ci, char overwrite);
+void makeConnectString(char *connect_string, const ConnInfo * ci, UWORD);
+void copyAttributes(ConnInfo * ci, const char *attribute, const char *value);
+void copyCommonAttributes(ConnInfo * ci, const char *attribute, const char *value);
#endif
#include "dlg_specific.h"
/* prototypes */
-void dconn_get_connect_attributes(const UCHAR FAR *connect_string, ConnInfo *ci);
-static void dconn_get_common_attributes(const UCHAR FAR *connect_string, ConnInfo *ci);
+void dconn_get_connect_attributes(const UCHAR FAR * connect_string, ConnInfo * ci);
+static void dconn_get_common_attributes(const UCHAR FAR * connect_string, ConnInfo * ci);
#ifdef WIN32
BOOL FAR PASCAL dconn_FDriverConnectProc(HWND hdlg, UINT wMsg, WPARAM wParam, LPARAM lParam);
-RETCODE dconn_DoDialog(HWND hwnd, ConnInfo *ci);
-
-extern HINSTANCE NEAR s_hModule;/* Saved module handle. */
+RETCODE dconn_DoDialog(HWND hwnd, ConnInfo * ci);
+extern HINSTANCE NEAR s_hModule; /* Saved module handle. */
#endif
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_DriverConnect(
- HDBC hdbc,
- HWND hwnd,
- UCHAR FAR *szConnStrIn,
- SWORD cbConnStrIn,
- UCHAR FAR *szConnStrOut,
- SWORD cbConnStrOutMax,
- SWORD FAR *pcbConnStrOut,
- UWORD fDriverCompletion)
+ HDBC hdbc,
+ HWND hwnd,
+ UCHAR FAR * szConnStrIn,
+ SWORD cbConnStrIn,
+ UCHAR FAR * szConnStrOut,
+ SWORD cbConnStrOutMax,
+ SWORD FAR * pcbConnStrOut,
+ UWORD fDriverCompletion)
{
static char *func = "PGAPI_DriverConnect";
ConnectionClass *conn = (ConnectionClass *) hdbc;
#ifdef WIN32
RETCODE dialog_result;
-
#endif
RETCODE result;
char connStrIn[MAX_CONNECT_STRING];
lenStrout = cbConnStrOutMax;
if (conn->ms_jet && lenStrout > 255)
- lenStrout = 255;
+ lenStrout = 255;
makeConnectString(connStrOut, ci, lenStrout);
len = strlen(connStrOut);
if (szConnStrOut)
{
-
/*
* Return the completed string to the caller. The correct method
* is to only construct the connect string if a dialog was put up,
if (len >= cbConnStrOutMax)
{
- int clen;
+ int clen;
+
for (clen = strlen(szConnStrOut) - 1; clen >= 0 && szConnStrOut[clen] != ';'; clen--)
szConnStrOut[clen] = '\0';
result = SQL_SUCCESS_WITH_INFO;
#ifdef WIN32
RETCODE
-dconn_DoDialog(HWND hwnd, ConnInfo *ci)
+dconn_DoDialog(HWND hwnd, ConnInfo * ci)
{
int dialog_result;
case IDC_DRIVER:
ci = (ConnInfo *) GetWindowLong(hdlg, DWL_USER);
DialogBoxParam(s_hModule, MAKEINTRESOURCE(DLG_OPTIONS_DRV),
- hdlg, driver_optionsProc, (LPARAM) ci);
+ hdlg, driver_optionsProc, (LPARAM) ci);
break;
case IDC_DATASOURCE:
return FALSE;
}
-
#endif /* WIN32 */
void
-dconn_get_connect_attributes(const UCHAR FAR *connect_string, ConnInfo *ci)
+dconn_get_connect_attributes(const UCHAR FAR * connect_string, ConnInfo * ci)
{
char *our_connect_string;
char *pair,
memset(ci, 0, sizeof(ConnInfo));
#ifdef DRIVER_CURSOR_IMPLEMENT
ci->updatable_cursors = 1;
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+#endif /* DRIVER_CURSOR_IMPLEMENT */
our_connect_string = strdup(connect_string);
strtok_arg = our_connect_string;
}
static void
-dconn_get_common_attributes(const UCHAR FAR *connect_string, ConnInfo *ci)
+dconn_get_common_attributes(const UCHAR FAR * connect_string, ConnInfo * ci)
{
char *our_connect_string;
char *pair,
ConnectionClass *conns[MAX_CONNECTIONS];
-RETCODE SQL_API
-PGAPI_AllocEnv(HENV FAR *phenv)
+RETCODE SQL_API
+PGAPI_AllocEnv(HENV FAR * phenv)
{
static char *func = "PGAPI_AllocEnv";
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_FreeEnv(HENV henv)
{
static char *func = "PGAPI_FreeEnv";
/* Returns the next SQL error information. */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_Error(
- HENV henv,
- HDBC hdbc,
- HSTMT hstmt,
- UCHAR FAR *szSqlState,
- SDWORD FAR *pfNativeError,
- UCHAR FAR *szErrorMsg,
- SWORD cbErrorMsgMax,
- SWORD FAR *pcbErrorMsg)
+ HENV henv,
+ HDBC hdbc,
+ HSTMT hstmt,
+ UCHAR FAR * szSqlState,
+ SDWORD FAR * pfNativeError,
+ UCHAR FAR * szErrorMsg,
+ SWORD cbErrorMsgMax,
+ SWORD FAR * pcbErrorMsg)
{
char *msg;
int status;
- BOOL once_again = FALSE;
- SWORD msglen;
+ BOOL once_again = FALSE;
+ SWORD msglen;
mylog("**** PGAPI_Error: henv=%u, hdbc=%u, hstmt=%u <%d>\n", henv, hdbc, hstmt, cbErrorMsgMax);
strcpy(szSqlState, "07006");
break;
case STMT_INVALID_CURSOR_STATE_ERROR:
- strcpy(szSqlState, "24000");
+ strcpy(szSqlState, "24000");
break;
case STMT_OPTION_VALUE_CHANGED:
strcpy(szSqlState, "01S02");
if (once_again)
{
- int outlen;
+ int outlen;
+
stmt->errornumber = status;
if (cbErrorMsgMax > 0)
outlen = *pcbErrorMsg;
char
-EN_Destructor(EnvironmentClass *self)
+EN_Destructor(EnvironmentClass * self)
{
int lf;
char rv = 1;
mylog("exit EN_Destructor: rv = %d\n", rv);
#ifdef _MEMORY_DEBUG_
-debug_memory_inouecheck();
-#endif /* _MEMORY_DEBUG_ */
+ debug_memory_inouecheck();
+#endif /* _MEMORY_DEBUG_ */
return rv;
}
char
-EN_get_error(EnvironmentClass *self, int *number, char **message)
+EN_get_error(EnvironmentClass * self, int *number, char **message)
{
if (self && self->errormsg && self->errornumber)
{
char
-EN_add_connection(EnvironmentClass *self, ConnectionClass *conn)
+EN_add_connection(EnvironmentClass * self, ConnectionClass * conn)
{
int i;
char
-EN_remove_connection(EnvironmentClass *self, ConnectionClass *conn)
+EN_remove_connection(EnvironmentClass * self, ConnectionClass * conn)
{
int i;
void
-EN_log_error(char *func, char *desc, EnvironmentClass *self)
+EN_log_error(char *func, char *desc, EnvironmentClass * self)
{
if (self)
qlog("ENVIRON ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'\n", func, desc, self->errornumber, self->errormsg);
/* Environment prototypes */
EnvironmentClass *EN_Constructor(void);
-char EN_Destructor(EnvironmentClass *self);
-char EN_get_error(EnvironmentClass *self, int *number, char **message);
-char EN_add_connection(EnvironmentClass *self, ConnectionClass *conn);
-char EN_remove_connection(EnvironmentClass *self, ConnectionClass *conn);
-void EN_log_error(char *func, char *desc, EnvironmentClass *self);
-
+char EN_Destructor(EnvironmentClass * self);
+char EN_get_error(EnvironmentClass * self, int *number, char **message);
+char EN_add_connection(EnvironmentClass * self, ConnectionClass * conn);
+char EN_remove_connection(EnvironmentClass * self, ConnectionClass * conn);
+void EN_log_error(char *func, char *desc, EnvironmentClass * self);
#endif
/* Perform a Prepare on the SQL statement */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_Prepare(HSTMT hstmt,
- UCHAR FAR *szSqlStr,
- SDWORD cbSqlStr)
+ UCHAR FAR * szSqlStr,
+ SDWORD cbSqlStr)
{
static char *func = "PGAPI_Prepare";
StatementClass *self = (StatementClass *) hstmt;
/* Performs the equivalent of SQLPrepare, followed by SQLExecute. */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_ExecDirect(
- HSTMT hstmt,
- UCHAR FAR *szSqlStr,
- SDWORD cbSqlStr)
+ HSTMT hstmt,
+ UCHAR FAR * szSqlStr,
+ SDWORD cbSqlStr)
{
StatementClass *stmt = (StatementClass *) hstmt;
RETCODE result;
/* Execute a prepared SQL statement */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_Execute(
- HSTMT hstmt)
+ HSTMT hstmt)
{
static char *func = "PGAPI_Execute";
StatementClass *stmt = (StatementClass *) hstmt;
*/
if (!stmt->pre_executing)
{
-
/*
* The bound parameters could have possibly changed since the last
* execute of this statement? Therefore check for params and
return retval;
mylog(" stmt_with_params = '%s'\n", stmt->stmt_with_params);
+
/*
- * Get the field info for the prepared
- * query using dummy backward fetch.
+ * Get the field info for the prepared query using dummy backward
+ * fetch.
*/
if (stmt->inaccurate_result && conn->connInfo.disallow_premature)
{
if (SC_is_pre_executable(stmt))
{
- BOOL in_trans = CC_is_in_trans(conn);
- BOOL issued_begin = FALSE, begin_included = FALSE;
- QResultClass *res;
+ BOOL in_trans = CC_is_in_trans(conn);
+ BOOL issued_begin = FALSE,
+ begin_included = FALSE;
+ QResultClass *res;
if (strnicmp(stmt->stmt_with_params, "BEGIN;", 6) == 0)
begin_included = TRUE;
}
else if (!in_trans && begin_included)
CC_set_no_trans(conn);
- }
- stmt->status =STMT_FINISHED;
+ }
+ stmt->status = STMT_FINISHED;
return SQL_SUCCESS;
}
}
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_Transact(
- HENV henv,
- HDBC hdbc,
- UWORD fType)
+ HENV henv,
+ HDBC hdbc,
+ UWORD fType)
{
static char *func = "PGAPI_Transact";
extern ConnectionClass *conns[];
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_Cancel(
- HSTMT hstmt) /* Statement to cancel. */
+ HSTMT hstmt) /* Statement to cancel. */
{
static char *func = "PGAPI_Cancel";
StatementClass *stmt = (StatementClass *) hstmt;
RETCODE result;
- ConnInfo *ci;
+ ConnInfo *ci;
#ifdef WIN32
HMODULE hmodule;
FARPROC addr;
-
#endif
mylog("%s: entering...\n", func);
*/
if (stmt->data_at_exec < 0)
{
-
/*
* MAJOR HACK for Windows to reset the driver manager's cursor
* state: Because of what seems like a bug in the Odbc driver
* Currently, just copy the input string without modification
* observing buffer limits and truncation.
*/
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_NativeSql(
- HDBC hdbc,
- UCHAR FAR *szSqlStrIn,
- SDWORD cbSqlStrIn,
- UCHAR FAR *szSqlStr,
- SDWORD cbSqlStrMax,
- SDWORD FAR *pcbSqlStr)
+ HDBC hdbc,
+ UCHAR FAR * szSqlStrIn,
+ SDWORD cbSqlStrIn,
+ UCHAR FAR * szSqlStr,
+ SDWORD cbSqlStrMax,
+ SDWORD FAR * pcbSqlStr)
{
static char *func = "PGAPI_NativeSql";
int len = 0;
* Supplies parameter data at execution time.
* Used in conjuction with SQLPutData.
*/
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_ParamData(
- HSTMT hstmt,
- PTR FAR *prgbValue)
+ HSTMT hstmt,
+ PTR FAR * prgbValue)
{
static char *func = "PGAPI_ParamData";
StatementClass *stmt = (StatementClass *) hstmt;
int i,
retval;
- ConnInfo *ci;
+ ConnInfo *ci;
mylog("%s: entering...\n", func);
* Supplies parameter data at execution time.
* Used in conjunction with SQLParamData.
*/
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_PutData(
- HSTMT hstmt,
- PTR rgbValue,
- SDWORD cbValue)
+ HSTMT hstmt,
+ PTR rgbValue,
+ SDWORD cbValue)
{
static char *func = "PGAPI_PutData";
StatementClass *stmt = (StatementClass *) hstmt;
/*
* theIniFileName is searched for in:
- * $HOME/theIniFileName
- * theIniFileName
- * ODBCINSTDIR/ODBCINST_INI
+ * $HOME/theIniFileName
+ * theIniFileName
+ * ODBCINSTDIR/ODBCINST_INI
*/
DWORD
-GetPrivateProfileString(const char *theSection, /* section name */
- const char *theKey, /* search key name */
- const char *theDefault, /* default value if not
+GetPrivateProfileString(const char *theSection, /* section name */
+ const char *theKey, /* search key name */
+ const char *theDefault, /* default value if not
* found */
char *theReturnBuffer, /* return value stored
* here */
size_t theReturnBufferLength, /* byte length of return
* buffer */
- const char *theIniFileName) /* pathname of ini file to
- * search */
+ const char *theIniFileName) /* pathname of ini file
+ * to search */
{
char buf[MAXPGPATH];
char *ptr = 0;
if (ptr == NULL || (((struct passwd *) ptr)->pw_dir) == NULL || *(((struct passwd *) ptr)->pw_dir) == '\0')
ptr = "/home";
else
- ptr = ((struct passwd *) ptr)->pw_dir; /* get user home dir */
+ ptr = ((struct passwd *) ptr)->pw_dir; /* get user home dir */
/*
- * If it can't be opened because the paths are too long, then
- * skip it, don't just truncate the path string... The truncated path
- * might accidently be an existing file. The default value will be
- * returned instead.
+ * If it can't be opened because the paths are too long, then skip it,
+ * don't just truncate the path string... The truncated path might
+ * accidently be an existing file. The default value will be returned
+ * instead.
*/
if (MAXPGPATH - 1 >= strlen(ptr) + 1 + strlen(theIniFileName))
{
DWORD
WritePrivateProfileString(const char *theSection, /* section name */
- const char *theKey, /* write key name */
+ const char *theKey, /* write key name */
const char *theBuffer, /* input buffer */
- const char *theIniFileName) /* pathname of ini file to
- * write */
+ const char *theIniFileName) /* pathname of ini file
+ * to write */
{
return 0;
}
return aReturnLength > 0 ? aReturnLength - 1 : 0;
}
+#endif /* NOT_USED */
-#endif /* NOT_USED */
-
-
-#endif /* not WIN32 */
+#endif /* not WIN32 */
{
#endif
- DWORD
- GetPrivateProfileString(const char *theSection, /* section name */
- const char *theKey, /* search key name */
- const char *theDefault, /* default value if not
- * found */
+ DWORD
+ GetPrivateProfileString(const char *theSection, /* section name */
+ const char *theKey, /* search key name */
+ const char *theDefault, /* default value if not
+ * found */
char *theReturnBuffer, /* return valuse stored
* here */
size_t theBufferLength, /* byte length of return
* buffer */
- const char *theIniFileName); /* pathname of ini file
+ const char *theIniFileName); /* pathname of ini file
* to search */
- DWORD
+ DWORD
WritePrivateProfileString(const char *theSection, /* section name */
const char *theKey, /* write key name */
- const char *theBuffer, /* input buffer */
- const char *theIniFileName); /* pathname of ini file
+ const char *theBuffer, /* input buffer */
+ const char *theIniFileName); /* pathname of ini file
* to write */
#ifdef __cplusplus
}
-
#endif
#ifndef WIN32
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_GetInfo(
- HDBC hdbc,
- UWORD fInfoType,
- PTR rgbInfoValue,
- SWORD cbInfoValueMax,
- SWORD FAR *pcbInfoValue)
+ HDBC hdbc,
+ UWORD fInfoType,
+ PTR rgbInfoValue,
+ SWORD cbInfoValueMax,
+ SWORD FAR * pcbInfoValue)
{
static char *func = "PGAPI_GetInfo";
ConnectionClass *conn = (ConnectionClass *) hdbc;
#ifdef DRIVER_CURSOR_IMPLEMENT
{
static char dver[32];
+
SQLGetPrivateProfileString(DBMS_NAME,
- "DriverODBCVer", "", dver, sizeof(dver), "odbcinst.ini");
+ "DriverODBCVer", "", dver, sizeof(dver), "odbcinst.ini");
if (dver[0])
{
- int major, minor;
+ int major,
+ minor;
+
mylog("REGISTRY_ODBC_VER = %s\n", dver)
-;
+ ;
if (sscanf(dver, "%x.%x", &major, &minor) >= 2)
{
- Int2 drv_ver = (major << 8) + minor;
+ Int2 drv_ver = (major << 8) + minor;
+
if (drv_ver > ODBCVER)
{
conn->driver_version = drv_ver;
}
}
}
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+#endif /* DRIVER_CURSOR_IMPLEMENT */
break;
case SQL_DRIVER_VER: /* ODBC 1.0 */
case SQL_POSITIONED_STATEMENTS: /* ODBC 2.0 */
len = 4;
value = ci->drivers.lie ? (SQL_PS_POSITIONED_DELETE |
- SQL_PS_POSITIONED_UPDATE |
- SQL_PS_SELECT_FOR_UPDATE) : 0;
+ SQL_PS_POSITIONED_UPDATE |
+ SQL_PS_SELECT_FOR_UPDATE) : 0;
break;
case SQL_PROCEDURE_TERM: /* ODBC 1.0 */
case SQL_SCROLL_CONCURRENCY: /* ODBC 1.0 */
len = 4;
value = ci->drivers.lie ? (SQL_SCCO_READ_ONLY |
- SQL_SCCO_LOCK |
- SQL_SCCO_OPT_ROWVER |
- SQL_SCCO_OPT_VALUES) :
- (SQL_SCCO_READ_ONLY);
+ SQL_SCCO_LOCK |
+ SQL_SCCO_OPT_ROWVER |
+ SQL_SCCO_OPT_VALUES) :
+ (SQL_SCCO_READ_ONLY);
if (ci->updatable_cursors)
value |= SQL_SCCO_OPT_ROWVER;
break;
case SQL_SCROLL_OPTIONS: /* ODBC 1.0 */
len = 4;
value = ci->drivers.lie ? (SQL_SO_FORWARD_ONLY |
- SQL_SO_STATIC |
- SQL_SO_KEYSET_DRIVEN |
- SQL_SO_DYNAMIC |
- SQL_SO_MIXED)
- : (ci->drivers.use_declarefetch ? SQL_SO_FORWARD_ONLY : (SQL_SO_FORWARD_ONLY | SQL_SO_STATIC));
+ SQL_SO_STATIC |
+ SQL_SO_KEYSET_DRIVEN |
+ SQL_SO_DYNAMIC |
+ SQL_SO_MIXED)
+ : (ci->drivers.use_declarefetch ? SQL_SO_FORWARD_ONLY : (SQL_SO_FORWARD_ONLY | SQL_SO_STATIC));
if (ci->updatable_cursors)
- value |= 0; /* SQL_SO_KEYSET_DRIVEN in the furure */
+ value |= 0; /* SQL_SO_KEYSET_DRIVEN in the furure */
break;
case SQL_SEARCH_PATTERN_ESCAPE: /* ODBC 1.0 */
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_GetTypeInfo(
- HSTMT hstmt,
- SWORD fSqlType)
+ HSTMT hstmt,
+ SWORD fSqlType)
{
static char *func = "PGAPI_GetTypeInfo";
StatementClass *stmt = (StatementClass *) hstmt;
if (fSqlType == SQL_ALL_TYPES || fSqlType == sqlType)
{
- row = (TupleNode *) malloc(sizeof(TupleNode) + (15 - 1) *sizeof(TupleField));
+ row = (TupleNode *) malloc(sizeof(TupleNode) + (15 - 1) * sizeof(TupleField));
/* These values can't be NULL */
set_tuplefield_string(&row->tuple[0], pgtype_to_name(stmt, pgType));
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_GetFunctions(
- HDBC hdbc,
- UWORD fFunction,
- UWORD FAR *pfExists)
+ HDBC hdbc,
+ UWORD fFunction,
+ UWORD FAR * pfExists)
{
static char *func = "PGAPI_GetFunctions";
- ConnectionClass *conn = (ConnectionClass *)hdbc;
- ConnInfo *ci = &(conn->connInfo);
+ ConnectionClass *conn = (ConnectionClass *) hdbc;
+ ConnInfo *ci = &(conn->connInfo);
mylog("%s: entering...%u\n", func, fFunction);
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_Tables(
- HSTMT hstmt,
- UCHAR FAR *szTableQualifier,
- SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
- SWORD cbTableOwner,
- UCHAR FAR *szTableName,
- SWORD cbTableName,
- UCHAR FAR *szTableType,
- SWORD cbTableType)
+ HSTMT hstmt,
+ UCHAR FAR * szTableQualifier,
+ SWORD cbTableQualifier,
+ UCHAR FAR * szTableOwner,
+ SWORD cbTableOwner,
+ UCHAR FAR * szTableName,
+ SWORD cbTableName,
+ UCHAR FAR * szTableType,
+ SWORD cbTableType)
{
static char *func = "PGAPI_Tables";
StatementClass *stmt = (StatementClass *) hstmt;
}
result = PGAPI_BindCol(htbl_stmt, 1, SQL_C_CHAR,
- table_name, MAX_INFO_STRING, NULL);
+ table_name, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = tbl_stmt->errormsg;
}
result = PGAPI_BindCol(htbl_stmt, 2, SQL_C_CHAR,
- table_owner, MAX_INFO_STRING, NULL);
+ table_owner, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = tbl_stmt->errormsg;
return SQL_ERROR;
}
result = PGAPI_BindCol(htbl_stmt, 3, SQL_C_CHAR,
- relkind_or_hasrules, MAX_INFO_STRING, NULL);
+ relkind_or_hasrules, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = tbl_stmt->errormsg;
result = PGAPI_Fetch(htbl_stmt);
while ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO))
{
-
/*
* Determine if this table name is a system table. If treating
* system tables as regular tables, then no need to do this test.
(view && show_views) ||
(regular_table && show_regular_tables))
{
- row = (TupleNode *) malloc(sizeof(TupleNode) + (5 - 1) *sizeof(TupleField));
+ row = (TupleNode *) malloc(sizeof(TupleNode) + (5 - 1) * sizeof(TupleField));
set_tuplefield_string(&row->tuple[0], "");
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_Columns(
- HSTMT hstmt,
- UCHAR FAR *szTableQualifier,
- SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
- SWORD cbTableOwner,
- UCHAR FAR *szTableName,
- SWORD cbTableName,
- UCHAR FAR *szColumnName,
- SWORD cbColumnName)
+ HSTMT hstmt,
+ UCHAR FAR * szTableQualifier,
+ SWORD cbTableQualifier,
+ UCHAR FAR * szTableOwner,
+ SWORD cbTableOwner,
+ UCHAR FAR * szTableName,
+ SWORD cbTableName,
+ UCHAR FAR * szColumnName,
+ SWORD cbColumnName)
{
static char *func = "PGAPI_Columns";
StatementClass *stmt = (StatementClass *) hstmt;
mylog("%s: hcol_stmt = %u, col_stmt = %u\n", func, hcol_stmt, col_stmt);
result = PGAPI_ExecDirect(hcol_stmt, columns_query,
- strlen(columns_query));
+ strlen(columns_query));
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = SC_create_errormsg(hcol_stmt);
}
result = PGAPI_BindCol(hcol_stmt, 1, SQL_C_CHAR,
- table_owner, MAX_INFO_STRING, NULL);
+ table_owner, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = col_stmt->errormsg;
}
result = PGAPI_BindCol(hcol_stmt, 2, SQL_C_CHAR,
- table_name, MAX_INFO_STRING, NULL);
+ table_name, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = col_stmt->errormsg;
}
result = PGAPI_BindCol(hcol_stmt, 3, SQL_C_CHAR,
- field_name, MAX_INFO_STRING, NULL);
+ field_name, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = col_stmt->errormsg;
}
result = PGAPI_BindCol(hcol_stmt, 4, SQL_C_LONG,
- &field_type, 4, NULL);
+ &field_type, 4, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = col_stmt->errormsg;
}
result = PGAPI_BindCol(hcol_stmt, 5, SQL_C_CHAR,
- field_type_name, MAX_INFO_STRING, NULL);
+ field_type_name, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = col_stmt->errormsg;
}
result = PGAPI_BindCol(hcol_stmt, 6, SQL_C_SHORT,
- &field_number, MAX_INFO_STRING, NULL);
+ &field_number, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = col_stmt->errormsg;
}
result = PGAPI_BindCol(hcol_stmt, 7, SQL_C_LONG,
- &field_length, MAX_INFO_STRING, NULL);
+ &field_length, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = col_stmt->errormsg;
}
result = PGAPI_BindCol(hcol_stmt, 8, SQL_C_LONG,
- &mod_length, MAX_INFO_STRING, NULL);
+ &mod_length, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = col_stmt->errormsg;
}
result = PGAPI_BindCol(hcol_stmt, 9, SQL_C_CHAR,
- not_null, MAX_INFO_STRING, NULL);
+ not_null, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = col_stmt->errormsg;
}
result = PGAPI_BindCol(hcol_stmt, 10, SQL_C_CHAR,
- relhasrules, MAX_INFO_STRING, NULL);
+ relhasrules, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = col_stmt->errormsg;
/* For OID fields */
the_type = PG_TYPE_OID;
row = (TupleNode *) malloc(sizeof(TupleNode) +
- (result_cols - 1) *sizeof(TupleField));
+ (result_cols - 1) * sizeof(TupleField));
set_tuplefield_string(&row->tuple[0], "");
/* see note in SQLTables() */
while ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO))
{
row = (TupleNode *) malloc(sizeof(TupleNode) +
- (result_cols - 1) *sizeof(TupleField));
+ (result_cols - 1) * sizeof(TupleField));
set_tuplefield_string(&row->tuple[0], "");
if (field_type == PG_TYPE_NUMERIC)
{
if (mod_length >= 4)
- mod_length -= 4;/* the length is in atttypmod - 4 */
+ mod_length -= 4; /* the length is in atttypmod - 4 */
if (mod_length >= 0)
{
useStaticPrecision = FALSE;
if (mod_length >= 4)
- mod_length -= 4;/* the length is in atttypmod - 4 */
+ mod_length -= 4; /* the length is in atttypmod - 4 */
if (mod_length > ci->drivers.max_varchar_size || mod_length <= 0)
mod_length = ci->drivers.max_varchar_size;
the_type = PG_TYPE_INT4;
row = (TupleNode *) malloc(sizeof(TupleNode) +
- (result_cols - 1) *sizeof(TupleField));
+ (result_cols - 1) * sizeof(TupleField));
set_tuplefield_string(&row->tuple[0], "");
set_tuplefield_string(&row->tuple[1], "");
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_SpecialColumns(
- HSTMT hstmt,
- UWORD fColType,
- UCHAR FAR *szTableQualifier,
- SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
- SWORD cbTableOwner,
- UCHAR FAR *szTableName,
- SWORD cbTableName,
- UWORD fScope,
- UWORD fNullable)
+ HSTMT hstmt,
+ UWORD fColType,
+ UCHAR FAR * szTableQualifier,
+ SWORD cbTableQualifier,
+ UCHAR FAR * szTableOwner,
+ SWORD cbTableOwner,
+ UCHAR FAR * szTableName,
+ SWORD cbTableName,
+ UWORD fScope,
+ UWORD fNullable)
{
static char *func = "PGAPI_SpecialColumns";
TupleNode *row;
mylog("%s: hcol_stmt = %u, col_stmt = %u\n", func, hcol_stmt, col_stmt);
result = PGAPI_ExecDirect(hcol_stmt, columns_query,
- strlen(columns_query));
+ strlen(columns_query));
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = SC_create_errormsg(hcol_stmt);
}
result = PGAPI_BindCol(hcol_stmt, 1, SQL_C_CHAR,
- relhasrules, MAX_INFO_STRING, NULL);
+ relhasrules, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = col_stmt->errormsg;
/* use the oid value for the rowid */
if (fColType == SQL_BEST_ROWID)
{
- row = (TupleNode *) malloc(sizeof(TupleNode) + (8 - 1) *sizeof(TupleField));
+ row = (TupleNode *) malloc(sizeof(TupleNode) + (8 - 1) * sizeof(TupleField));
set_tuplefield_int2(&row->tuple[0], SQL_SCOPE_SESSION);
set_tuplefield_string(&row->tuple[1], "oid");
if (atoi(ci->row_versioning))
{
- row = (TupleNode *) malloc(sizeof(TupleNode) + (8 - 1) *sizeof(TupleField));
+ row = (TupleNode *) malloc(sizeof(TupleNode) + (8 - 1) * sizeof(TupleField));
set_tuplefield_null(&row->tuple[0]);
set_tuplefield_string(&row->tuple[1], "xmin");
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_Statistics(
- HSTMT hstmt,
- UCHAR FAR *szTableQualifier,
- SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
- SWORD cbTableOwner,
- UCHAR FAR *szTableName,
- SWORD cbTableName,
- UWORD fUnique,
- UWORD fAccuracy)
+ HSTMT hstmt,
+ UCHAR FAR * szTableQualifier,
+ SWORD cbTableQualifier,
+ UCHAR FAR * szTableOwner,
+ SWORD cbTableOwner,
+ UCHAR FAR * szTableName,
+ SWORD cbTableName,
+ UWORD fUnique,
+ UWORD fAccuracy)
{
static char *func = "PGAPI_Statistics";
StatementClass *stmt = (StatementClass *) hstmt;
*/
col_stmt->internal = TRUE;
result = PGAPI_Columns(hcol_stmt, "", 0, "", 0,
- table_name, (SWORD) strlen(table_name), "", 0);
+ table_name, (SWORD) strlen(table_name), "", 0);
col_stmt->internal = FALSE;
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
goto SEEYA;
}
result = PGAPI_BindCol(hcol_stmt, 4, SQL_C_CHAR,
- column_name, MAX_INFO_STRING, &column_name_len);
+ column_name, MAX_INFO_STRING, &column_name_len);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = col_stmt->errormsg;
" and d.oid = i.indrelid"
" and i.indexrelid = c.oid"
" and c.relam = a.oid"
- , table_name);
+ ,table_name);
if (PG_VERSION_GT(SC_get_conn(stmt), 6.4))
strcat(index_query, " order by i.indisprimary desc");
/* bind the index name column */
result = PGAPI_BindCol(hindx_stmt, 1, SQL_C_CHAR,
- index_name, MAX_INFO_STRING, &index_name_len);
+ index_name, MAX_INFO_STRING, &index_name_len);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = indx_stmt->errormsg; /* "Couldn't bind column
}
/* bind the vector column */
result = PGAPI_BindCol(hindx_stmt, 2, SQL_C_DEFAULT,
- fields_vector, 32, &fields_vector_len);
+ fields_vector, 32, &fields_vector_len);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = indx_stmt->errormsg; /* "Couldn't bind column
}
/* bind the "is unique" column */
result = PGAPI_BindCol(hindx_stmt, 3, SQL_C_CHAR,
- isunique, sizeof(isunique), NULL);
+ isunique, sizeof(isunique), NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = indx_stmt->errormsg; /* "Couldn't bind column
/* bind the "is clustered" column */
result = PGAPI_BindCol(hindx_stmt, 4, SQL_C_CHAR,
- isclustered, sizeof(isclustered), NULL);
+ isclustered, sizeof(isclustered), NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = indx_stmt->errormsg; /* "Couldn't bind column
/* bind the "is hash" column */
result = PGAPI_BindCol(hindx_stmt, 5, SQL_C_CHAR,
- ishash, sizeof(ishash), NULL);
+ ishash, sizeof(ishash), NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = indx_stmt->errormsg; /* "Couldn't bind column
}
result = PGAPI_BindCol(hindx_stmt, 6, SQL_C_CHAR,
- relhasrules, MAX_INFO_STRING, NULL);
+ relhasrules, MAX_INFO_STRING, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = indx_stmt->errormsg;
if (relhasrules[0] != '1' && atoi(ci->show_oid_column) && atoi(ci->fake_oid_index))
{
row = (TupleNode *) malloc(sizeof(TupleNode) +
- (13 - 1) *sizeof(TupleField));
+ (13 - 1) * sizeof(TupleField));
/* no table qualifier */
set_tuplefield_string(&row->tuple[0], "");
while (i < 16 && fields_vector[i] != 0)
{
row = (TupleNode *) malloc(sizeof(TupleNode) +
- (13 - 1) *sizeof(TupleField));
+ (13 - 1) * sizeof(TupleField));
/* no table qualifier */
set_tuplefield_string(&row->tuple[0], "");
* Clustered/HASH index?
*/
set_tuplefield_int2(&row->tuple[6], (Int2)
- (atoi(isclustered) ? SQL_INDEX_CLUSTERED :
- (!strncmp(ishash, "hash", 4)) ? SQL_INDEX_HASHED : SQL_INDEX_OTHER));
+ (atoi(isclustered) ? SQL_INDEX_CLUSTERED :
+ (!strncmp(ishash, "hash", 4)) ? SQL_INDEX_HASHED : SQL_INDEX_OTHER));
set_tuplefield_int2(&row->tuple[7], (Int2) (i + 1));
if (fields_vector[i] == OID_ATTNUM)
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_ColumnPrivileges(
- HSTMT hstmt,
- UCHAR FAR *szTableQualifier,
- SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
- SWORD cbTableOwner,
- UCHAR FAR *szTableName,
- SWORD cbTableName,
- UCHAR FAR *szColumnName,
- SWORD cbColumnName)
+ HSTMT hstmt,
+ UCHAR FAR * szTableQualifier,
+ SWORD cbTableQualifier,
+ UCHAR FAR * szTableOwner,
+ SWORD cbTableOwner,
+ UCHAR FAR * szTableName,
+ SWORD cbTableName,
+ UCHAR FAR * szColumnName,
+ SWORD cbColumnName)
{
static char *func = "PGAPI_ColumnPrivileges";
*
* Retrieve the primary key columns for the specified table.
*/
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_PrimaryKeys(
- HSTMT hstmt,
- UCHAR FAR *szTableQualifier,
- SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
- SWORD cbTableOwner,
- UCHAR FAR *szTableName,
- SWORD cbTableName)
+ HSTMT hstmt,
+ UCHAR FAR * szTableQualifier,
+ SWORD cbTableQualifier,
+ UCHAR FAR * szTableOwner,
+ SWORD cbTableOwner,
+ UCHAR FAR * szTableName,
+ SWORD cbTableName)
{
static char *func = "PGAPI_PrimaryKeys";
StatementClass *stmt = (StatementClass *) hstmt;
SDWORD attname_len;
char pktab[MAX_TABLE_LEN + 1];
Int2 result_cols;
- int qno, qstart, qend;
+ int qno,
+ qstart,
+ qend;
mylog("%s: entering...stmt=%u\n", func, stmt);
}
result = PGAPI_BindCol(htbl_stmt, 1, SQL_C_CHAR,
- attname, MAX_INFO_STRING, &attname_len);
+ attname, MAX_INFO_STRING, &attname_len);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = tbl_stmt->errormsg;
switch (qno)
{
case 1:
+
/*
- * Simplified query to remove assumptions about number of possible
- * index columns. Courtesy of Tom Lane - thomas 2000-03-21
- */
+ * Simplified query to remove assumptions about number of
+ * possible index columns. Courtesy of Tom Lane - thomas
+ * 2000-03-21
+ */
sprintf(tables_query, "select ta.attname, ia.attnum"
- " from pg_attribute ta, pg_attribute ia, pg_class c, pg_index i"
- " where c.relname = '%s'"
- " AND c.oid = i.indrelid"
- " AND i.indisprimary = 't'"
- " AND ia.attrelid = i.indexrelid"
- " AND ta.attrelid = i.indrelid"
- " AND ta.attnum = i.indkey[ia.attnum-1]"
- " order by ia.attnum", pktab);
+ " from pg_attribute ta, pg_attribute ia, pg_class c, pg_index i"
+ " where c.relname = '%s'"
+ " AND c.oid = i.indrelid"
+ " AND i.indisprimary = 't'"
+ " AND ia.attrelid = i.indexrelid"
+ " AND ta.attrelid = i.indrelid"
+ " AND ta.attnum = i.indkey[ia.attnum-1]"
+ " order by ia.attnum", pktab);
break;
case 2:
+
/*
- * Simplified query to search old fashoned primary key
- */
+ * Simplified query to search old fashoned primary key
+ */
sprintf(tables_query, "select ta.attname, ia.attnum"
- " from pg_attribute ta, pg_attribute ia, pg_class c, pg_index i"
- " where c.relname = '%s_pkey'"
- " AND c.oid = i.indexrelid"
- " AND ia.attrelid = i.indexrelid"
- " AND ta.attrelid = i.indrelid"
- " AND ta.attnum = i.indkey[ia.attnum-1]"
- " order by ia.attnum", pktab);
+ " from pg_attribute ta, pg_attribute ia, pg_class c, pg_index i"
+ " where c.relname = '%s_pkey'"
+ " AND c.oid = i.indexrelid"
+ " AND ia.attrelid = i.indexrelid"
+ " AND ta.attrelid = i.indrelid"
+ " AND ta.attnum = i.indkey[ia.attnum-1]"
+ " order by ia.attnum", pktab);
break;
}
mylog("%s: tables_query='%s'\n", func, tables_query);
while ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO))
{
- row = (TupleNode *) malloc(sizeof(TupleNode) + (result_cols - 1) *sizeof(TupleField));
+ row = (TupleNode *) malloc(sizeof(TupleNode) + (result_cols - 1) * sizeof(TupleField));
set_tuplefield_null(&row->tuple[0]);
* There may be much more effective way in the
* future version. The way is very forcive currently.
*/
-static BOOL isMultibyte(const unsigned char *str)
+static BOOL
+isMultibyte(const unsigned char *str)
{
for (; *str; str++)
{
}
return FALSE;
}
-static char *getClientTableName(ConnectionClass *conn, char *serverTableName, BOOL *nameAlloced)
+static char *
+getClientTableName(ConnectionClass * conn, char *serverTableName, BOOL * nameAlloced)
{
- char query[1024], saveoid[24], *ret = serverTableName;
- BOOL continueExec = TRUE, bError = FALSE;
- QResultClass *res;
+ char query[1024],
+ saveoid[24],
+ *ret = serverTableName;
+ BOOL continueExec = TRUE,
+ bError = FALSE;
+ QResultClass *res;
*nameAlloced = FALSE;
if (!conn->client_encoding || !isMultibyte(serverTableName))
}
return ret;
}
-static char *getClientColumnName(ConnectionClass *conn, const char *serverTableName, char *serverColumnName, BOOL *nameAlloced)
+static char *
+getClientColumnName(ConnectionClass * conn, const char *serverTableName, char *serverColumnName, BOOL * nameAlloced)
{
- char query[1024], saveattrelid[24], saveattnum[16], *ret = serverColumnName;
- BOOL continueExec = TRUE, bError = FALSE;
- QResultClass *res;
+ char query[1024],
+ saveattrelid[24],
+ saveattnum[16],
+ *ret = serverColumnName;
+ BOOL continueExec = TRUE,
+ bError = FALSE;
+ QResultClass *res;
*nameAlloced = FALSE;
if (!conn->client_encoding || !isMultibyte(serverColumnName))
if (!bError && continueExec)
{
sprintf(query, "select attrelid, attnum from pg_class, pg_attribute "
- "where relname = '%s' and attrelid = pg_class.oid "
- "and attname = '%s'", serverTableName, serverColumnName);
+ "where relname = '%s' and attrelid = pg_class.oid "
+ "and attname = '%s'", serverTableName, serverColumnName);
if (res = CC_send_query(conn, query, NULL), res)
{
if (QR_get_num_tuples(res) > 0)
}
return ret;
}
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_ForeignKeys(
- HSTMT hstmt,
- UCHAR FAR *szPkTableQualifier,
- SWORD cbPkTableQualifier,
- UCHAR FAR *szPkTableOwner,
- SWORD cbPkTableOwner,
- UCHAR FAR *szPkTableName,
- SWORD cbPkTableName,
- UCHAR FAR *szFkTableQualifier,
- SWORD cbFkTableQualifier,
- UCHAR FAR *szFkTableOwner,
- SWORD cbFkTableOwner,
- UCHAR FAR *szFkTableName,
- SWORD cbFkTableName)
+ HSTMT hstmt,
+ UCHAR FAR * szPkTableQualifier,
+ SWORD cbPkTableQualifier,
+ UCHAR FAR * szPkTableOwner,
+ SWORD cbPkTableOwner,
+ UCHAR FAR * szPkTableName,
+ SWORD cbPkTableName,
+ UCHAR FAR * szFkTableQualifier,
+ SWORD cbFkTableQualifier,
+ UCHAR FAR * szFkTableOwner,
+ SWORD cbFkTableOwner,
+ UCHAR FAR * szFkTableName,
+ SWORD cbFkTableName)
{
static char *func = "PGAPI_ForeignKeys";
StatementClass *stmt = (StatementClass *) hstmt;
del_rule[MAX_TABLE_LEN];
char pk_table_needed[MAX_TABLE_LEN + 1];
char fk_table_needed[MAX_TABLE_LEN + 1];
- char *pkey_ptr, *pkey_text,
- *fkey_ptr, *fkey_text,
- *pk_table, *pkt_text,
- *fk_table, *fkt_text;
+ char *pkey_ptr,
+ *pkey_text,
+ *fkey_ptr,
+ *fkey_text,
+ *pk_table,
+ *pkt_text,
+ *fk_table,
+ *fkt_text;
+
#ifdef MULTIBYTE
- BOOL pkey_alloced, fkey_alloced, pkt_alloced, fkt_alloced;
- ConnectionClass *conn;
-#endif /* MULTIBYTE */
+ BOOL pkey_alloced,
+ fkey_alloced,
+ pkt_alloced,
+ fkt_alloced;
+ ConnectionClass *conn;
+#endif /* MULTIBYTE */
int i,
j,
k,
#if (ODBCVER >= 0x0300)
SWORD defer_type;
-
#endif
char pkey[MAX_INFO_STRING];
Int2 result_cols;
#ifdef MULTIBYTE
pkey_alloced = fkey_alloced = pkt_alloced = fkt_alloced = FALSE;
conn = SC_get_conn(stmt);
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
+
/*
* Case #2 -- Get the foreign keys in the specified table (fktab) that
* refer to the primary keys of other table(s).
}
result = PGAPI_BindCol(htbl_stmt, 1, SQL_C_BINARY,
- trig_args, sizeof(trig_args), NULL);
+ trig_args, sizeof(trig_args), NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = tbl_stmt->errormsg;
}
result = PGAPI_BindCol(htbl_stmt, 2, SQL_C_SHORT,
- &trig_nargs, 0, NULL);
+ &trig_nargs, 0, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = tbl_stmt->errormsg;
}
result = PGAPI_BindCol(htbl_stmt, 5, SQL_C_CHAR,
- upd_rule, sizeof(upd_rule), NULL);
+ upd_rule, sizeof(upd_rule), NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = tbl_stmt->errormsg;
}
result = PGAPI_BindCol(htbl_stmt, 6, SQL_C_CHAR,
- del_rule, sizeof(del_rule), NULL);
+ del_rule, sizeof(del_rule), NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = tbl_stmt->errormsg;
}
keyresult = PGAPI_BindCol(hpkey_stmt, 4, SQL_C_CHAR,
- pkey, sizeof(pkey), NULL);
+ pkey, sizeof(pkey), NULL);
if (keyresult != SQL_SUCCESS)
{
stmt->errornumber = STMT_NO_MEMORY_ERROR;
pkt_text = getClientTableName(conn, pk_table, &pkt_alloced);
#else
pkt_text = pk_table;
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
/* If there is a pk table specified, then check it. */
if (pk_table_needed[0] != '\0')
{
pkey_text = getClientColumnName(conn, pk_table, pkey_ptr, &pkey_alloced);
#else
pkey_text = pkey_ptr;
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
mylog("%s: pkey_ptr='%s', pkey='%s'\n", func, pkey_text, pkey);
if (strcmp(pkey_text, pkey))
{
#ifdef MULTIBYTE
if (pkey_alloced)
free(pkey_text);
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
/* Get to next primary key */
for (k = 0; k < 2; k++)
pkey_ptr += strlen(pkey_ptr) + 1;
for (k = 0; k < num_keys; k++)
{
- row = (TupleNode *) malloc(sizeof(TupleNode) + (result_cols - 1) *sizeof(TupleField));
+ row = (TupleNode *) malloc(sizeof(TupleNode) + (result_cols - 1) * sizeof(TupleField));
#ifdef MULTIBYTE
pkey_text = getClientColumnName(conn, pk_table, pkey_ptr, &pkey_alloced);
#else
pkey_text = pkey_ptr;
fkey_text = fkey_ptr;
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
mylog("%s: pk_table = '%s', pkey_ptr = '%s'\n", func, pkt_text, pkey_text);
set_tuplefield_null(&row->tuple[0]);
set_tuplefield_string(&row->tuple[1], "");
if (pkey_alloced)
free(pkey_text);
pkey_alloced = FALSE;
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
/* next primary/foreign key */
for (i = 0; i < 2; i++)
{
if (pkt_alloced)
free(pkt_text);
pkt_alloced = FALSE;
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
result = PGAPI_Fetch(htbl_stmt);
}
}
result = PGAPI_BindCol(htbl_stmt, 1, SQL_C_BINARY,
- trig_args, sizeof(trig_args), NULL);
+ trig_args, sizeof(trig_args), NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = tbl_stmt->errormsg;
}
result = PGAPI_BindCol(htbl_stmt, 2, SQL_C_SHORT,
- &trig_nargs, 0, NULL);
+ &trig_nargs, 0, NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = tbl_stmt->errormsg;
}
result = PGAPI_BindCol(htbl_stmt, 5, SQL_C_CHAR,
- upd_rule, sizeof(upd_rule), NULL);
+ upd_rule, sizeof(upd_rule), NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = tbl_stmt->errormsg;
}
result = PGAPI_BindCol(htbl_stmt, 6, SQL_C_CHAR,
- del_rule, sizeof(del_rule), NULL);
+ del_rule, sizeof(del_rule), NULL);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
{
stmt->errormsg = tbl_stmt->errormsg;
fkt_text = getClientTableName(conn, fk_table, &fkt_alloced);
#else
fkt_text = fk_table;
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
/* Get to first foreign key */
fkey_ptr = trig_args;
#else
pkey_text = pkey_ptr;
fkey_text = fkey_ptr;
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
mylog("pkey_ptr = '%s', fk_table = '%s', fkey_ptr = '%s'\n", pkey_text, fkt_text, fkey_text);
- row = (TupleNode *) malloc(sizeof(TupleNode) + (result_cols - 1) *sizeof(TupleField));
+ row = (TupleNode *) malloc(sizeof(TupleNode) + (result_cols - 1) * sizeof(TupleField));
mylog("pk_table_needed = '%s', pkey_ptr = '%s'\n", pk_table_needed, pkey_text);
set_tuplefield_null(&row->tuple[0]);
if (fkey_alloced)
free(fkey_text);
fkey_alloced = FALSE;
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
/* next primary/foreign key */
for (j = 0; j < 2; j++)
if (fkt_alloced)
free(fkt_text);
fkt_alloced = FALSE;
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
result = PGAPI_Fetch(htbl_stmt);
}
}
free(fkt_text);
if (fkey_alloced)
free(fkey_text);
-#endif /* MULTIBYTE */
+#endif /* MULTIBYTE */
PGAPI_FreeStmt(htbl_stmt, SQL_DROP);
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_ProcedureColumns(
- HSTMT hstmt,
- UCHAR FAR *szProcQualifier,
- SWORD cbProcQualifier,
- UCHAR FAR *szProcOwner,
- SWORD cbProcOwner,
- UCHAR FAR *szProcName,
- SWORD cbProcName,
- UCHAR FAR *szColumnName,
- SWORD cbColumnName)
+ HSTMT hstmt,
+ UCHAR FAR * szProcQualifier,
+ SWORD cbProcQualifier,
+ UCHAR FAR * szProcOwner,
+ SWORD cbProcOwner,
+ UCHAR FAR * szProcName,
+ SWORD cbProcName,
+ UCHAR FAR * szColumnName,
+ SWORD cbColumnName)
{
static char *func = "PGAPI_ProcedureColumns";
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_Procedures(
- HSTMT hstmt,
- UCHAR FAR *szProcQualifier,
- SWORD cbProcQualifier,
- UCHAR FAR *szProcOwner,
- SWORD cbProcOwner,
- UCHAR FAR *szProcName,
- SWORD cbProcName)
+ HSTMT hstmt,
+ UCHAR FAR * szProcQualifier,
+ SWORD cbProcQualifier,
+ UCHAR FAR * szProcOwner,
+ SWORD cbProcOwner,
+ UCHAR FAR * szProcName,
+ SWORD cbProcName)
{
static char *func = "PGAPI_Procedures";
- StatementClass *stmt = (StatementClass *) hstmt;
- ConnectionClass *conn = SC_get_conn(stmt);
+ StatementClass *stmt = (StatementClass *) hstmt;
+ ConnectionClass *conn = SC_get_conn(stmt);
char proc_query[INFO_INQUIRY_LEN];
- QResultClass *res;
+ QResultClass *res;
mylog("%s: entering...\n", func);
-
+
if (PG_VERSION_LT(conn, 6.5))
{
stmt->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
}
if (!SC_recycle_statement(stmt))
return SQL_ERROR;
+
/*
- * The following seems the simplest implementation
+ * The following seems the simplest implementation
*/
- strcpy(proc_query, "select '' as ""PROCEDURE_CAT"", '' as ""PROCEDURE_SCHEM"","
- " proname as ""PROCEDURE_NAME"", '' as ""NUM_INPUT_PARAMS"","
- " '' as ""NUM_OUTPUT_PARAMS"", '' as ""NUM_RESULT_SETS"","
- " '' as ""REMARKS"","
- " case when prorettype =0 then 1::int2 else 2::int2 end as ""PROCEDURE_TYPE"" from pg_proc");
+ strcpy(proc_query, "select '' as " "PROCEDURE_CAT" ", '' as " "PROCEDURE_SCHEM" ","
+ " proname as " "PROCEDURE_NAME" ", '' as " "NUM_INPUT_PARAMS" ","
+ " '' as " "NUM_OUTPUT_PARAMS" ", '' as " "NUM_RESULT_SETS" ","
+ " '' as " "REMARKS" ","
+ " case when prorettype =0 then 1::int2 else 2::int2 end as " "PROCEDURE_TYPE" " from pg_proc");
my_strcat(proc_query, " where proname like '%.*s'", szProcName, cbProcName);
res = CC_send_query(conn, proc_query, NULL);
return SQL_ERROR;
}
stmt->result = res;
+
/*
* also, things need to think that this statement is finished so the
* results can be retrieved.
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_TablePrivileges(
- HSTMT hstmt,
- UCHAR FAR *szTableQualifier,
- SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
- SWORD cbTableOwner,
- UCHAR FAR *szTableName,
- SWORD cbTableName)
+ HSTMT hstmt,
+ UCHAR FAR * szTableQualifier,
+ SWORD cbTableQualifier,
+ UCHAR FAR * szTableOwner,
+ SWORD cbTableOwner,
+ UCHAR FAR * szTableName,
+ SWORD cbTableName)
{
- StatementClass *stmt = (StatementClass *) hstmt;
+ StatementClass *stmt = (StatementClass *) hstmt;
static char *func = "PGAPI_TablePrivileges";
Int2 result_cols;
mylog("%s: entering...\n", func);
/*
- * a statement is actually executed, so we'll have to do this
- * ourselves.
- */
+ * a statement is actually executed, so we'll have to do this
+ * ourselves.
+ */
result_cols = 7;
extend_bindings(stmt, result_cols);
QR_set_field_info(stmt->result, 4, "GRANTEE", PG_TYPE_TEXT, MAX_INFO_STRING);
QR_set_field_info(stmt->result, 5, "PRIVILEGE", PG_TYPE_TEXT, MAX_INFO_STRING);
QR_set_field_info(stmt->result, 6, "IS_GRANTABLE", PG_TYPE_TEXT, MAX_INFO_STRING);
-
+
SC_log_error(func, "Function not implemented", (StatementClass *) hstmt);
return SQL_ERROR;
}
#include <sys/types.h>
#define MEM_ALLOC(size) (malloc((size_t)(size)))
-#define MEM_FREE(ptr) \
+#define MEM_FREE(ptr) \
do { \
if(ptr) \
free(ptr); \
typedef DWORD LPARAM;
typedef void *HWND;
typedef int BOOL;
-
#endif /* _UNIX_ */
#if defined(WIN32) || defined(WIN32_SYSTEM)
#define STRLEN(str) ((str)? _fstrlen((char FAR*)(str)):0)
#define STREQ(a, b) (_fstrcmp((char FAR*)(a), (char FAR*)(b) == 0)
#endif
-
#endif /* WIN32 */
#define SYSERR (-1)
#ifndef NULL
#define NULL ((void FAR*)0UL)
#endif
-
#endif
#endif
RETCODE SQL_API SQLAllocConnect(HENV henv,
- HDBC FAR *phdbc);
- RETCODE SQL_API SQLAllocEnv(HENV FAR *phenv);
+ HDBC FAR * phdbc);
+ RETCODE SQL_API SQLAllocEnv(HENV FAR * phenv);
RETCODE SQL_API SQLAllocStmt(HDBC hdbc,
- HSTMT FAR *phstmt);
+ HSTMT FAR * phstmt);
RETCODE SQL_API SQLBindCol(HSTMT hstmt,
UWORD icol,
SWORD fCType,
PTR rgbValue,
SDWORD cbValueMax,
- SDWORD FAR *pcbValue);
+ SDWORD FAR * pcbValue);
RETCODE SQL_API SQLCancel(HSTMT hstmt);
UWORD fDescType,
PTR rgbDesc,
SWORD cbDescMax,
- SWORD FAR *pcbDesc,
- SDWORD FAR *pfDesc);
+ SWORD FAR * pcbDesc,
+ SDWORD FAR * pfDesc);
RETCODE SQL_API SQLConnect(HDBC hdbc,
- UCHAR FAR *szDSN,
+ UCHAR FAR * szDSN,
SWORD cbDSN,
- UCHAR FAR *szUID,
+ UCHAR FAR * szUID,
SWORD cbUID,
- UCHAR FAR *szAuthStr,
+ UCHAR FAR * szAuthStr,
SWORD cbAuthStr);
RETCODE SQL_API SQLDescribeCol(HSTMT hstmt,
UWORD icol,
- UCHAR FAR *szColName,
+ UCHAR FAR * szColName,
SWORD cbColNameMax,
- SWORD FAR *pcbColName,
- SWORD FAR *pfSqlType,
- UDWORD FAR *pcbColDef,
- SWORD FAR *pibScale,
- SWORD FAR *pfNullable);
+ SWORD FAR * pcbColName,
+ SWORD FAR * pfSqlType,
+ UDWORD FAR * pcbColDef,
+ SWORD FAR * pibScale,
+ SWORD FAR * pfNullable);
RETCODE SQL_API SQLDisconnect(HDBC hdbc);
RETCODE SQL_API SQLError(HENV henv,
HDBC hdbc,
HSTMT hstmt,
- UCHAR FAR *szSqlState,
- SDWORD FAR *pfNativeError,
- UCHAR FAR *szErrorMsg,
+ UCHAR FAR * szSqlState,
+ SDWORD FAR * pfNativeError,
+ UCHAR FAR * szErrorMsg,
SWORD cbErrorMsgMax,
- SWORD FAR *pcbErrorMsg);
+ SWORD FAR * pcbErrorMsg);
RETCODE SQL_API SQLExecDirect(HSTMT hstmt,
- UCHAR FAR *szSqlStr,
+ UCHAR FAR * szSqlStr,
SDWORD cbSqlStr);
RETCODE SQL_API SQLExecute(HSTMT hstmt);
UWORD fOption);
RETCODE SQL_API SQLGetCursorName(HSTMT hstmt,
- UCHAR FAR *szCursor,
+ UCHAR FAR * szCursor,
SWORD cbCursorMax,
- SWORD FAR *pcbCursor);
+ SWORD FAR * pcbCursor);
RETCODE SQL_API SQLNumResultCols(HSTMT hstmt,
- SWORD FAR *pccol);
+ SWORD FAR * pccol);
RETCODE SQL_API SQLPrepare(HSTMT hstmt,
- UCHAR FAR *szSqlStr,
+ UCHAR FAR * szSqlStr,
SDWORD cbSqlStr);
RETCODE SQL_API SQLRowCount(HSTMT hstmt,
- SDWORD FAR *pcrow);
+ SDWORD FAR * pcrow);
RETCODE SQL_API SQLSetCursorName(HSTMT hstmt,
- UCHAR FAR *szCursor,
+ UCHAR FAR * szCursor,
SWORD cbCursor);
RETCODE SQL_API SQLTransact(HENV henv,
UDWORD cbColDef,
SWORD ibScale,
PTR rgbValue,
- SDWORD FAR *pcbValue);
+ SDWORD FAR * pcbValue);
#ifdef __cplusplus
}
-
#endif
#endif
{
SQLUINTEGER dwLowWord;
SQLUINTEGER dwHighWord;
-} SQLUBIGINT;
+} SQLUBIGINT;
typedef struct
{
SQLUINTEGER dwLowWord;
SQLINTEGER dwHighWord;
-} SQLBIGINT;
-
+} SQLBIGINT;
#endif /* GCC */
typedef struct tagDATE_STRUCT
SQLSMALLINT year;
SQLUSMALLINT month;
SQLUSMALLINT day;
-} DATE_STRUCT,
-SQL_DATE_STRUCT;
+} DATE_STRUCT,
+
+ SQL_DATE_STRUCT;
typedef struct tagTIME_STRUCT
{
SQLUSMALLINT hour;
SQLUSMALLINT minute;
SQLUSMALLINT second;
-} TIME_STRUCT,
-SQL_TIME_STRUCT;
+} TIME_STRUCT,
+
+ SQL_TIME_STRUCT;
typedef struct tagTIMESTAMP_STRUCT
{
SQLUSMALLINT minute;
SQLUSMALLINT second;
SQLUINTEGER fraction;
-} TIMESTAMP_STRUCT,
-SQL_TIMESTAMP_STRUCT;
+} TIMESTAMP_STRUCT,
+
+ SQL_TIMESTAMP_STRUCT;
/* postodbc doesn't use these but what the heck */
/* Don't know what SQL_MAX_NUMERIC_LEN should be so I can't include this. It's
WORD Data2;
WORD Data3;
BYTE Data4[8];
-} SQLGUID;
+} SQLGUID;
typedef enum
{
- SQL_IS_YEAR = 1,
- SQL_IS_MONTH = 2,
- SQL_IS_DAY = 3,
- SQL_IS_HOUR = 4,
- SQL_IS_MINUTE = 5,
- SQL_IS_SECOND = 6,
- SQL_IS_YEAR_TO_MONTH = 7,
- SQL_IS_DAY_TO_HOUR = 8,
- SQL_IS_DAY_TO_MINUTE = 9,
- SQL_IS_DAY_TO_SECOND = 10,
- SQL_IS_HOUR_TO_MINUTE = 11,
- SQL_IS_HOUR_TO_SECOND = 12,
- SQL_IS_MINUTE_TO_SECOND = 13
-} SQLINTERVAL;
+ SQL_IS_YEAR = 1,
+ SQL_IS_MONTH = 2,
+ SQL_IS_DAY = 3,
+ SQL_IS_HOUR = 4,
+ SQL_IS_MINUTE = 5,
+ SQL_IS_SECOND = 6,
+ SQL_IS_YEAR_TO_MONTH = 7,
+ SQL_IS_DAY_TO_HOUR = 8,
+ SQL_IS_DAY_TO_MINUTE = 9,
+ SQL_IS_DAY_TO_SECOND = 10,
+ SQL_IS_HOUR_TO_MINUTE = 11,
+ SQL_IS_HOUR_TO_SECOND = 12,
+ SQL_IS_MINUTE_TO_SECOND = 13
+} SQLINTERVAL;
typedef struct tagSQL_YEAR_MONTH
{
SQLUINTEGER year;
SQLUINTEGER month;
-} SQL_YEAR_MONTH_STRUCT;
+} SQL_YEAR_MONTH_STRUCT;
typedef struct tagSQL_DAY_SECOND
{
SQLUINTEGER minute;
SQLUINTEGER second;
SQLUINTEGER fraction;
-} SQL_DAY_SECOND_STRUCT;
+} SQL_DAY_SECOND_STRUCT;
typedef struct tagSQL_INTERVAL_STRUCT
{
SQL_YEAR_MONTH_STRUCT year_month;
SQL_DAY_SECOND_STRUCT day_second;
} intval;
-} SQL_INTERVAL_STRUCT;
+} SQL_INTERVAL_STRUCT;
#define SQL_MAX_OPTION_STRING_LENGTH 256
#define SQL_NUM_EXTENSIONS (SQL_EXT_API_LAST - SQL_EXT_API_START + 1)
* function prototypes previously missing from isqlext.h
*/
RETCODE SQL_API SQLColumns(HSTMT hstmt,
- UCHAR FAR *szTableQualifier,
+ UCHAR FAR * szTableQualifier,
SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
+ UCHAR FAR * szTableOwner,
SWORD cbTableOwner,
- UCHAR FAR *szTableName,
+ UCHAR FAR * szTableName,
SWORD cbTableName,
- UCHAR FAR *szColumnName,
+ UCHAR FAR * szColumnName,
SWORD cbColumnName);
RETCODE SQL_API SQLDriverConnect(HDBC hdbc,
HWND hwnd,
- UCHAR FAR *szConnStrIn,
+ UCHAR FAR * szConnStrIn,
SWORD cbConnStrIn,
- UCHAR FAR *szConnStrOut,
+ UCHAR FAR * szConnStrOut,
SWORD cbConnStrOutMax,
- SWORD FAR *pcbConnStrOut,
+ SWORD FAR * pcbConnStrOut,
UWORD fDriverCompletion);
RETCODE SQL_API SQLGetConnectOption(HDBC hdbc,
SWORD fCType,
PTR rgbValue,
SDWORD cbValueMax,
- SDWORD FAR *pcbValue);
+ SDWORD FAR * pcbValue);
RETCODE SQL_API SQLGetFunctions(HDBC hdbc,
UWORD fFunction,
- UWORD FAR *pfExists);
+ UWORD FAR * pfExists);
RETCODE SQL_API SQLGetInfo(HDBC hdbc,
UWORD fInfoType,
PTR rgbInfoValue,
SWORD cbInfoValueMax,
- SWORD FAR *pcbInfoValue);
+ SWORD FAR * pcbInfoValue);
RETCODE SQL_API SQLGetStmtOption(HSTMT hstmt,
UWORD fOption,
SWORD fSqlType);
RETCODE SQL_API SQLParamData(HSTMT hstmt,
- PTR FAR *prgbValue);
+ PTR FAR * prgbValue);
RETCODE SQL_API SQLPutData(HSTMT hstmt,
PTR rgbValue,
RETCODE SQL_API SQLSpecialColumns(HSTMT hstmt,
UWORD fColType,
- UCHAR FAR *szTableQualifier,
+ UCHAR FAR * szTableQualifier,
SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
+ UCHAR FAR * szTableOwner,
SWORD cbTableOwner,
- UCHAR FAR *szTableName,
+ UCHAR FAR * szTableName,
SWORD cbTableName,
UWORD fScope,
UWORD fNullable);
RETCODE SQL_API SQLStatistics(HSTMT hstmt,
- UCHAR FAR *szTableQualifier,
+ UCHAR FAR * szTableQualifier,
SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
+ UCHAR FAR * szTableOwner,
SWORD cbTableOwner,
- UCHAR FAR *szTableName,
+ UCHAR FAR * szTableName,
SWORD cbTableName,
UWORD fUnique,
UWORD fAccuracy);
RETCODE SQL_API SQLTables(HSTMT hstmt,
- UCHAR FAR *szTableQualifier,
+ UCHAR FAR * szTableQualifier,
SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
+ UCHAR FAR * szTableOwner,
SWORD cbTableOwner,
- UCHAR FAR *szTableName,
+ UCHAR FAR * szTableName,
SWORD cbTableName,
- UCHAR FAR *szTableType,
+ UCHAR FAR * szTableType,
SWORD cbTableType);
RETCODE SQL_API SQLBrowseConnect(HDBC hdbc,
- UCHAR FAR *szConnStrIn,
+ UCHAR FAR * szConnStrIn,
SWORD cbConnStrIn,
- UCHAR FAR *szConnStrOut,
+ UCHAR FAR * szConnStrOut,
SWORD cbConnStrOutMax,
- SWORD FAR *pcbConnStrOut);
+ SWORD FAR * pcbConnStrOut);
RETCODE SQL_API SQLColumnPrivileges(HSTMT hstmt,
- UCHAR FAR *szTableQualifier,
+ UCHAR FAR * szTableQualifier,
SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
+ UCHAR FAR * szTableOwner,
SWORD cbTableOwner,
- UCHAR FAR *szTableName,
+ UCHAR FAR * szTableName,
SWORD cbTableName,
- UCHAR FAR *szColumnName,
+ UCHAR FAR * szColumnName,
SWORD cbColumnName);
RETCODE SQL_API SQLDescribeParam(HSTMT hstmt,
UWORD ipar,
- SWORD FAR *pfSqlType,
- UDWORD FAR *pcbColDef,
- SWORD FAR *pibScale,
- SWORD FAR *pfNullable);
+ SWORD FAR * pfSqlType,
+ UDWORD FAR * pcbColDef,
+ SWORD FAR * pibScale,
+ SWORD FAR * pfNullable);
RETCODE SQL_API SQLExtendedFetch(HSTMT hstmt,
UWORD fFetchType,
SDWORD irow,
- UDWORD FAR *pcrow,
- UWORD FAR *rgfRowStatus);
+ UDWORD FAR * pcrow,
+ UWORD FAR * rgfRowStatus);
RETCODE SQL_API SQLForeignKeys(HSTMT hstmt,
- UCHAR FAR *szPkTableQualifier,
+ UCHAR FAR * szPkTableQualifier,
SWORD cbPkTableQualifier,
- UCHAR FAR *szPkTableOwner,
+ UCHAR FAR * szPkTableOwner,
SWORD cbPkTableOwner,
- UCHAR FAR *szPkTableName,
+ UCHAR FAR * szPkTableName,
SWORD cbPkTableName,
- UCHAR FAR *szFkTableQualifier,
+ UCHAR FAR * szFkTableQualifier,
SWORD cbFkTableQualifier,
- UCHAR FAR *szFkTableOwner,
+ UCHAR FAR * szFkTableOwner,
SWORD cbFkTableOwner,
- UCHAR FAR *szFkTableName,
+ UCHAR FAR * szFkTableName,
SWORD cbFkTableName);
RETCODE SQL_API SQLMoreResults(HSTMT hstmt);
RETCODE SQL_API SQLNativeSql(HDBC hdbc,
- UCHAR FAR *szSqlStrIn,
+ UCHAR FAR * szSqlStrIn,
SDWORD cbSqlStrIn,
- UCHAR FAR *szSqlStr,
+ UCHAR FAR * szSqlStr,
SDWORD cbSqlStrMax,
- SDWORD FAR *pcbSqlStr);
+ SDWORD FAR * pcbSqlStr);
RETCODE SQL_API SQLNumParams(HSTMT hstmt,
- SWORD FAR *pcpar);
+ SWORD FAR * pcpar);
RETCODE SQL_API SQLParamOptions(HSTMT hstmt,
UDWORD crow,
- UDWORD FAR *pirow);
+ UDWORD FAR * pirow);
RETCODE SQL_API SQLPrimaryKeys(HSTMT hstmt,
- UCHAR FAR *szTableQualifier,
+ UCHAR FAR * szTableQualifier,
SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
+ UCHAR FAR * szTableOwner,
SWORD cbTableOwner,
- UCHAR FAR *szTableName,
+ UCHAR FAR * szTableName,
SWORD cbTableName);
RETCODE SQL_API SQLProcedureColumns(HSTMT hstmt,
- UCHAR FAR *szProcQualifier,
+ UCHAR FAR * szProcQualifier,
SWORD cbProcQualifier,
- UCHAR FAR *szProcOwner,
+ UCHAR FAR * szProcOwner,
SWORD cbProcOwner,
- UCHAR FAR *szProcName,
+ UCHAR FAR * szProcName,
SWORD cbProcName,
- UCHAR FAR *szColumnName,
+ UCHAR FAR * szColumnName,
SWORD cbColumnName);
RETCODE SQL_API SQLProcedures(HSTMT hstmt,
- UCHAR FAR *szProcQualifier,
+ UCHAR FAR * szProcQualifier,
SWORD cbProcQualifier,
- UCHAR FAR *szProcOwner,
+ UCHAR FAR * szProcOwner,
SWORD cbProcOwner,
- UCHAR FAR *szProcName,
+ UCHAR FAR * szProcName,
SWORD cbProcName);
RETCODE SQL_API SQLSetPos(HSTMT hstmt,
UWORD fLock);
RETCODE SQL_API SQLTablePrivileges(HSTMT hstmt,
- UCHAR FAR *szTableQualifier,
+ UCHAR FAR * szTableQualifier,
SWORD cbTableQualifier,
- UCHAR FAR *szTableOwner,
+ UCHAR FAR * szTableOwner,
SWORD cbTableOwner,
- UCHAR FAR *szTableName,
+ UCHAR FAR * szTableName,
SWORD cbTableName);
RETCODE SQL_API SQLBindParameter(HSTMT hstmt,
SWORD ibScale,
PTR rgbValue,
SDWORD cbValueMax,
- SDWORD FAR *pcbValue);
+ SDWORD FAR * pcbValue);
RETCODE SQL_API SQLSetScrollOptions(HSTMT hstmt,
UWORD fConcurrency,
#ifdef __cplusplus
}
-
#endif
-
#endif
Oid
-lo_creat(ConnectionClass *conn, int mode)
+lo_creat(ConnectionClass * conn, int mode)
{
LO_ARG argv[1];
int retval,
int
-lo_open(ConnectionClass *conn, int lobjId, int mode)
+lo_open(ConnectionClass * conn, int lobjId, int mode)
{
int fd;
int result_len;
int
-lo_close(ConnectionClass *conn, int fd)
+lo_close(ConnectionClass * conn, int fd)
{
LO_ARG argv[1];
int retval,
int
-lo_read(ConnectionClass *conn, int fd, char *buf, int len)
+lo_read(ConnectionClass * conn, int fd, char *buf, int len)
{
LO_ARG argv[2];
int result_len;
int
-lo_write(ConnectionClass *conn, int fd, char *buf, int len)
+lo_write(ConnectionClass * conn, int fd, char *buf, int len)
{
LO_ARG argv[2];
int retval,
int
-lo_lseek(ConnectionClass *conn, int fd, int offset, int whence)
+lo_lseek(ConnectionClass * conn, int fd, int offset, int whence)
{
LO_ARG argv[3];
int retval,
int
-lo_tell(ConnectionClass *conn, int fd)
+lo_tell(ConnectionClass * conn, int fd)
{
LO_ARG argv[1];
int retval,
int
-lo_unlink(ConnectionClass *conn, Oid lobjId)
+lo_unlink(ConnectionClass * conn, Oid lobjId)
{
LO_ARG argv[1];
int retval,
#define INV_WRITE 0x00020000
#define INV_READ 0x00040000
-Oid lo_creat(ConnectionClass *conn, int mode);
-int lo_open(ConnectionClass *conn, int lobjId, int mode);
-int lo_close(ConnectionClass *conn, int fd);
-int lo_read(ConnectionClass *conn, int fd, char *buf, int len);
-int lo_write(ConnectionClass *conn, int fd, char *buf, int len);
-int lo_lseek(ConnectionClass *conn, int fd, int offset, int len);
-int lo_tell(ConnectionClass *conn, int fd);
-int lo_unlink(ConnectionClass *conn, Oid lobjId);
-
+Oid lo_creat(ConnectionClass * conn, int mode);
+int lo_open(ConnectionClass * conn, int lobjId, int mode);
+int lo_close(ConnectionClass * conn, int fd);
+int lo_read(ConnectionClass * conn, int fd, char *buf, int len);
+int lo_write(ConnectionClass * conn, int fd, char *buf, int len);
+int lo_lseek(ConnectionClass * conn, int fd, int offset, int len);
+int lo_tell(ConnectionClass * conn, int fd);
+int lo_unlink(ConnectionClass * conn, Oid lobjId);
#endif
#endif
extern GLOBAL_VALUES globals;
-void generate_filename(const char *, const char *, char *);
+void generate_filename(const char *, const char *, char *);
void
return;
}
-static int mylog_on = 0, qlog_on = 0;
-void logs_on_off(int cnopen, int mylog_onoff, int qlog_onoff)
+static int mylog_on = 0,
+ qlog_on = 0;
+void
+logs_on_off(int cnopen, int mylog_onoff, int qlog_onoff)
{
- static int mylog_on_count = 0, mylog_off_count = 0,
- qlog_on_count = 0, qlog_off_count = 0;
+ static int mylog_on_count = 0,
+ mylog_off_count = 0,
+ qlog_on_count = 0,
+ qlog_off_count = 0;
if (mylog_onoff)
mylog_on_count += cnopen;
- else
+ else
mylog_off_count += cnopen;
if (mylog_on_count > 0)
mylog_on = 1;
mylog_on = globals.debug;
if (qlog_onoff)
qlog_on_count += cnopen;
- else
+ else
qlog_off_count += cnopen;
if (qlog_on_count > 0)
qlog_on = 1;
{
va_list args;
char filebuf[80];
- static FILE *LOGFP = NULL;
+ static FILE *LOGFP = NULL;
if (mylog_on)
{
va_end(args);
}
}
-
#endif
{
va_list args;
char filebuf[80];
- static FILE *LOGFP = NULL;
+ static FILE *LOGFP = NULL;
if (qlog_on)
{
va_end(args);
}
}
-
#endif
#define STRCPY_NULL (-2)
int my_strcpy(char *dst, int dst_len, const char *src, int src_len);
-
#endif
unsigned char *
check_client_encoding(unsigned char *str)
{
- if (strstr(str, "%27SJIS%27") ||
- strstr(str, "%27Shift_JIS%27") ||
- strstr(str, "'SJIS'") ||
- strstr(str, "'sjis'") ||
- strstr(str, "'Shift_JIS'"))
+ if (strstr(str, "%27SJIS%27") ||
+ strstr(str, "%27Shift_JIS%27") ||
+ strstr(str, "'SJIS'") ||
+ strstr(str, "'sjis'") ||
+ strstr(str, "'Shift_JIS'"))
{
multibyte_client_encoding = SJIS;
return ("SJIS");
}
- if (strstr(str, "%27BIG5%27") ||
- strstr(str, "%27Big5%27") ||
- strstr(str, "'BIG5'") ||
- strstr(str, "'big5'") ||
- strstr(str, "'Big5'"))
+ if (strstr(str, "%27BIG5%27") ||
+ strstr(str, "%27Big5%27") ||
+ strstr(str, "'BIG5'") ||
+ strstr(str, "'big5'") ||
+ strstr(str, "'Big5'"))
{
multibyte_client_encoding = BIG5;
return ("BIG5");
switch (multibyte_client_encoding)
{
/* Japanese Shift-JIS(CP932) Support. */
- case SJIS:
+ case SJIS:
{
if (multibyte_status < 2 && s > 0x80 && !(s > 0x9f && s < 0xE0))
multibyte_status = 2;
SQLSetConnectOption, SQLSetCursorName, SQLSetParam,
SQLSetStmtOption, SQLSpecialColumns, SQLStatistics,
SQLTables, SQLTransact, SQLColAttributes,
- SQLColumnPrivileges, SQLDescribeParam, SQLExtendedFetch,
- SQLForeignKeys, SQLMoreResults, SQLNativeSql,
- SQLNumParams, SQLParamOptions, SQLPrimaryKeys,
- SQLProcedureColumns, SQLProcedures, SQLSetPos,
- SQLTablePrivileges, SQLBindParameter
+ SQLColumnPrivileges, SQLDescribeParam, SQLExtendedFetch,
+ SQLForeignKeys, SQLMoreResults, SQLNativeSql,
+ SQLNumParams, SQLParamOptions, SQLPrimaryKeys,
+ SQLProcedureColumns, SQLProcedures, SQLSetPos,
+ SQLTablePrivileges, SQLBindParameter
*-------
*/
#ifdef WIN32
-#define ODBCVER_REP 0x3000
+#define ODBCVER_REP 0x3000
#endif
#include "psqlodbc.h"
#include <stdio.h>
#include "connection.h"
#include "statement.h"
-RETCODE SQL_API SQLAllocConnect(HENV EnvironmentHandle,
- HDBC FAR *ConnectionHandle)
+RETCODE SQL_API
+SQLAllocConnect(HENV EnvironmentHandle,
+ HDBC FAR * ConnectionHandle)
{
mylog("[SQLAllocConnect]");
return PGAPI_AllocConnect(EnvironmentHandle, ConnectionHandle);
}
-RETCODE SQL_API SQLAllocEnv(HENV FAR *EnvironmentHandle)
+RETCODE SQL_API
+SQLAllocEnv(HENV FAR * EnvironmentHandle)
{
mylog("[SQLAllocEnv]");
return PGAPI_AllocEnv(EnvironmentHandle);
}
-RETCODE SQL_API SQLAllocStmt(HDBC ConnectionHandle,
- HSTMT *StatementHandle)
+RETCODE SQL_API
+SQLAllocStmt(HDBC ConnectionHandle,
+ HSTMT * StatementHandle)
{
mylog("[SQLAllocStmt]");
return PGAPI_AllocStmt(ConnectionHandle, StatementHandle);
}
-RETCODE SQL_API SQLBindCol(HSTMT StatementHandle,
- SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
- PTR TargetValue, SQLINTEGER BufferLength,
- SQLINTEGER *StrLen_or_Ind)
+RETCODE SQL_API
+SQLBindCol(HSTMT StatementHandle,
+ SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
+ PTR TargetValue, SQLINTEGER BufferLength,
+ SQLINTEGER * StrLen_or_Ind)
{
mylog("[SQLBindCol]");
return PGAPI_BindCol(StatementHandle, ColumnNumber,
- TargetType, TargetValue, BufferLength, StrLen_or_Ind);
+ TargetType, TargetValue, BufferLength, StrLen_or_Ind);
}
-RETCODE SQL_API SQLCancel(HSTMT StatementHandle)
+RETCODE SQL_API
+SQLCancel(HSTMT StatementHandle)
{
mylog("[SQLCancel]");
return PGAPI_Cancel(StatementHandle);
}
-RETCODE SQL_API SQLColumns(HSTMT StatementHandle,
- SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
- SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
- SQLCHAR *TableName, SQLSMALLINT NameLength3,
- SQLCHAR *ColumnName, SQLSMALLINT NameLength4)
+RETCODE SQL_API
+SQLColumns(HSTMT StatementHandle,
+ SQLCHAR * CatalogName, SQLSMALLINT NameLength1,
+ SQLCHAR * SchemaName, SQLSMALLINT NameLength2,
+ SQLCHAR * TableName, SQLSMALLINT NameLength3,
+ SQLCHAR * ColumnName, SQLSMALLINT NameLength4)
{
mylog("[SQLColumns]");
return PGAPI_Columns(StatementHandle, CatalogName, NameLength1,
- SchemaName, NameLength2, TableName, NameLength3,
- ColumnName, NameLength4);
+ SchemaName, NameLength2, TableName, NameLength3,
+ ColumnName, NameLength4);
}
-RETCODE SQL_API SQLConnect(HDBC ConnectionHandle,
- SQLCHAR *ServerName, SQLSMALLINT NameLength1,
- SQLCHAR *UserName, SQLSMALLINT NameLength2,
- SQLCHAR *Authentication, SQLSMALLINT NameLength3)
+RETCODE SQL_API
+SQLConnect(HDBC ConnectionHandle,
+ SQLCHAR * ServerName, SQLSMALLINT NameLength1,
+ SQLCHAR * UserName, SQLSMALLINT NameLength2,
+ SQLCHAR * Authentication, SQLSMALLINT NameLength3)
{
mylog("[SQLConnect]");
return PGAPI_Connect(ConnectionHandle, ServerName, NameLength1,
- UserName, NameLength2, Authentication, NameLength3);
+ UserName, NameLength2, Authentication, NameLength3);
}
-RETCODE SQL_API SQLDriverConnect(HDBC hdbc,
- HWND hwnd,
- UCHAR FAR *szConnStrIn,
- SWORD cbConnStrIn,
- UCHAR FAR *szConnStrOut,
- SWORD cbConnStrOutMax,
- SWORD FAR *pcbConnStrOut,
- UWORD fDriverCompletion)
+RETCODE SQL_API
+SQLDriverConnect(HDBC hdbc,
+ HWND hwnd,
+ UCHAR FAR * szConnStrIn,
+ SWORD cbConnStrIn,
+ UCHAR FAR * szConnStrOut,
+ SWORD cbConnStrOutMax,
+ SWORD FAR * pcbConnStrOut,
+ UWORD fDriverCompletion)
{
mylog("[SQLDriverConnect]");
return PGAPI_DriverConnect(hdbc, hwnd, szConnStrIn, cbConnStrIn,
szConnStrOut, cbConnStrOutMax, pcbConnStrOut, fDriverCompletion);
}
-RETCODE SQL_API SQLBrowseConnect(
- HDBC hdbc,
- SQLCHAR *szConnStrIn,
- SQLSMALLINT cbConnStrIn,
- SQLCHAR *szConnStrOut,
- SQLSMALLINT cbConnStrOutMax,
- SQLSMALLINT *pcbConnStrOut)
+RETCODE SQL_API
+SQLBrowseConnect(
+ HDBC hdbc,
+ SQLCHAR * szConnStrIn,
+ SQLSMALLINT cbConnStrIn,
+ SQLCHAR * szConnStrOut,
+ SQLSMALLINT cbConnStrOutMax,
+ SQLSMALLINT * pcbConnStrOut)
{
mylog("[SQLBrowseConnect]");
return PGAPI_BrowseConnect(hdbc, szConnStrIn, cbConnStrIn,
- szConnStrOut, cbConnStrOutMax, pcbConnStrOut);
+ szConnStrOut, cbConnStrOutMax, pcbConnStrOut);
}
-RETCODE SQL_API SQLDataSources(HENV EnvironmentHandle,
- SQLUSMALLINT Direction, SQLCHAR *ServerName,
- SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1,
- SQLCHAR *Description, SQLSMALLINT BufferLength2,
- SQLSMALLINT *NameLength2)
+RETCODE SQL_API
+SQLDataSources(HENV EnvironmentHandle,
+ SQLUSMALLINT Direction, SQLCHAR * ServerName,
+ SQLSMALLINT BufferLength1, SQLSMALLINT * NameLength1,
+ SQLCHAR * Description, SQLSMALLINT BufferLength2,
+ SQLSMALLINT * NameLength2)
{
mylog("[SQLDataSources]");
+
/*
- return PGAPI_DataSources(EnvironmentHandle, Direction, ServerName,
- BufferLength1, NameLength1, Description, BufferLength2,
- NameLength2);
- */
+ * return PGAPI_DataSources(EnvironmentHandle, Direction, ServerName,
+ * BufferLength1, NameLength1, Description, BufferLength2,
+ * NameLength2);
+ */
return SQL_ERROR;
}
-RETCODE SQL_API SQLDescribeCol(HSTMT StatementHandle,
- SQLUSMALLINT ColumnNumber, SQLCHAR *ColumnName,
- SQLSMALLINT BufferLength, SQLSMALLINT *NameLength,
- SQLSMALLINT *DataType, SQLUINTEGER *ColumnSize,
- SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable)
+RETCODE SQL_API
+SQLDescribeCol(HSTMT StatementHandle,
+ SQLUSMALLINT ColumnNumber, SQLCHAR * ColumnName,
+ SQLSMALLINT BufferLength, SQLSMALLINT * NameLength,
+ SQLSMALLINT * DataType, SQLUINTEGER * ColumnSize,
+ SQLSMALLINT * DecimalDigits, SQLSMALLINT * Nullable)
{
mylog("[SQLDescribeCol]");
return PGAPI_DescribeCol(StatementHandle, ColumnNumber,
- ColumnName, BufferLength, NameLength,
- DataType, ColumnSize, DecimalDigits, Nullable);
+ ColumnName, BufferLength, NameLength,
+ DataType, ColumnSize, DecimalDigits, Nullable);
}
-RETCODE SQL_API SQLDisconnect(HDBC ConnectionHandle)
+RETCODE SQL_API
+SQLDisconnect(HDBC ConnectionHandle)
{
mylog("[SQLDisconnect]");
return PGAPI_Disconnect(ConnectionHandle);
}
-RETCODE SQL_API SQLError(HENV EnvironmentHandle,
- HDBC ConnectionHandle, HSTMT StatementHandle,
- SQLCHAR *Sqlstate, SQLINTEGER *NativeError,
- SQLCHAR *MessageText, SQLSMALLINT BufferLength,
- SQLSMALLINT *TextLength)
+RETCODE SQL_API
+SQLError(HENV EnvironmentHandle,
+ HDBC ConnectionHandle, HSTMT StatementHandle,
+ SQLCHAR * Sqlstate, SQLINTEGER * NativeError,
+ SQLCHAR * MessageText, SQLSMALLINT BufferLength,
+ SQLSMALLINT * TextLength)
{
mylog("[SQLError]");
return PGAPI_Error(EnvironmentHandle, ConnectionHandle, StatementHandle,
- Sqlstate, NativeError, MessageText, BufferLength, TextLength);
+ Sqlstate, NativeError, MessageText, BufferLength, TextLength);
}
-RETCODE SQL_API SQLExecDirect(HSTMT StatementHandle,
- SQLCHAR *StatementText, SQLINTEGER TextLength)
+RETCODE SQL_API
+SQLExecDirect(HSTMT StatementHandle,
+ SQLCHAR * StatementText, SQLINTEGER TextLength)
{
mylog("[SQLExecDirect]");
return PGAPI_ExecDirect(StatementHandle, StatementText, TextLength);
}
-RETCODE SQL_API SQLExecute(HSTMT StatementHandle)
+RETCODE SQL_API
+SQLExecute(HSTMT StatementHandle)
{
mylog("[SQLExecute]");
return PGAPI_Execute(StatementHandle);
}
-RETCODE SQL_API SQLFetch(HSTMT StatementHandle)
+RETCODE SQL_API
+SQLFetch(HSTMT StatementHandle)
{
- static char *func = "SQLFetch";
+ static char *func = "SQLFetch";
+
#if (ODBCVER >= 0x3000)
- StatementClass *stmt = (StatementClass *) StatementHandle;
+ StatementClass *stmt = (StatementClass *) StatementHandle;
ConnectionClass *conn = SC_get_conn(stmt);
- if (conn->driver_version >= 0x0300)
+
+ if (conn->driver_version >= 0x0300)
{
- SQLUSMALLINT *rowStatusArray = stmt->options.rowStatusArray;
- SQLINTEGER *pcRow = stmt->options.rowsFetched;
+ SQLUSMALLINT *rowStatusArray = stmt->options.rowStatusArray;
+ SQLINTEGER *pcRow = stmt->options.rowsFetched;
mylog("[[%s]]", func);
- return PGAPI_ExtendedFetch(StatementHandle, SQL_FETCH_NEXT, 0,
- pcRow, rowStatusArray);
+ return PGAPI_ExtendedFetch(StatementHandle, SQL_FETCH_NEXT, 0,
+ pcRow, rowStatusArray);
}
#endif
mylog("[%s]", func);
return PGAPI_Fetch(StatementHandle);
}
-RETCODE SQL_API SQLFreeConnect(HDBC ConnectionHandle)
+RETCODE SQL_API
+SQLFreeConnect(HDBC ConnectionHandle)
{
mylog("[SQLFreeStmt]");
return PGAPI_FreeConnect(ConnectionHandle);
}
-RETCODE SQL_API SQLFreeEnv(HENV EnvironmentHandle)
+RETCODE SQL_API
+SQLFreeEnv(HENV EnvironmentHandle)
{
mylog("[SQLFreeEnv]");
return PGAPI_FreeEnv(EnvironmentHandle);
}
-RETCODE SQL_API SQLFreeStmt(HSTMT StatementHandle,
- SQLUSMALLINT Option)
+RETCODE SQL_API
+SQLFreeStmt(HSTMT StatementHandle,
+ SQLUSMALLINT Option)
{
mylog("[SQLFreeStmt]");
return PGAPI_FreeStmt(StatementHandle, Option);
}
-RETCODE SQL_API SQLGetConnectOption(HDBC ConnectionHandle,
- SQLUSMALLINT Option, PTR Value)
+RETCODE SQL_API
+SQLGetConnectOption(HDBC ConnectionHandle,
+ SQLUSMALLINT Option, PTR Value)
{
mylog("[SQLGetConnectOption]");
return PGAPI_GetConnectOption(ConnectionHandle, Option, Value);
-}
-RETCODE SQL_API SQLGetCursorName(HSTMT StatementHandle,
- SQLCHAR *CursorName, SQLSMALLINT BufferLength,
- SQLSMALLINT *NameLength)
+}
+RETCODE SQL_API
+SQLGetCursorName(HSTMT StatementHandle,
+ SQLCHAR * CursorName, SQLSMALLINT BufferLength,
+ SQLSMALLINT * NameLength)
{
mylog("[SQLGetCursorName]");
return PGAPI_GetCursorName(StatementHandle, CursorName, BufferLength,
- NameLength);
+ NameLength);
}
-RETCODE SQL_API SQLGetData(HSTMT StatementHandle,
- SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
- PTR TargetValue, SQLINTEGER BufferLength,
- SQLINTEGER *StrLen_or_Ind)
+RETCODE SQL_API
+SQLGetData(HSTMT StatementHandle,
+ SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
+ PTR TargetValue, SQLINTEGER BufferLength,
+ SQLINTEGER * StrLen_or_Ind)
{
mylog("[SQLGetData]");
return PGAPI_GetData(StatementHandle, ColumnNumber, TargetType,
- TargetValue, BufferLength, StrLen_or_Ind);
+ TargetValue, BufferLength, StrLen_or_Ind);
}
-RETCODE SQL_API SQLGetFunctions(HDBC ConnectionHandle,
- SQLUSMALLINT FunctionId, SQLUSMALLINT *Supported)
+RETCODE SQL_API
+SQLGetFunctions(HDBC ConnectionHandle,
+ SQLUSMALLINT FunctionId, SQLUSMALLINT * Supported)
{
mylog("[SQLGetFunctions]");
#if (ODBCVER >= 0x3000)
#endif
return PGAPI_GetFunctions(ConnectionHandle, FunctionId, Supported);
}
-RETCODE SQL_API SQLGetInfo(HDBC ConnectionHandle,
- SQLUSMALLINT InfoType, PTR InfoValue,
- SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
+RETCODE SQL_API
+SQLGetInfo(HDBC ConnectionHandle,
+ SQLUSMALLINT InfoType, PTR InfoValue,
+ SQLSMALLINT BufferLength, SQLSMALLINT * StringLength)
{
#if (ODBCVER >= 0x3000)
- RETCODE ret;
+ RETCODE ret;
+
mylog("[SQLGetInfo(30)]");
if ((ret = PGAPI_GetInfo(ConnectionHandle, InfoType, InfoValue,
- BufferLength, StringLength)) == SQL_ERROR)
+ BufferLength, StringLength)) == SQL_ERROR)
{
if (((ConnectionClass *) ConnectionHandle)->driver_version >= 0x3000)
return PGAPI_GetInfo30(ConnectionHandle, InfoType, InfoValue,
- BufferLength, StringLength);
+ BufferLength, StringLength);
}
return ret;
#else
mylog("[SQLGetInfo]");
return PGAPI_GetInfo(ConnectionHandle, InfoType, InfoValue,
- BufferLength, StringLength);
+ BufferLength, StringLength);
#endif
}
-RETCODE SQL_API SQLGetStmtOption(HSTMT StatementHandle,
- SQLUSMALLINT Option, PTR Value)
+RETCODE SQL_API
+SQLGetStmtOption(HSTMT StatementHandle,
+ SQLUSMALLINT Option, PTR Value)
{
mylog("[SQLGetStmtOption]");
return PGAPI_GetStmtOption(StatementHandle, Option, Value);
}
-RETCODE SQL_API SQLGetTypeInfo(HSTMT StatementHandle,
- SQLSMALLINT DataType)
+RETCODE SQL_API
+SQLGetTypeInfo(HSTMT StatementHandle,
+ SQLSMALLINT DataType)
{
mylog("[SQLGetTypeInfo]");
- return PGAPI_GetTypeInfo(StatementHandle,DataType);
+ return PGAPI_GetTypeInfo(StatementHandle, DataType);
}
-RETCODE SQL_API SQLNumResultCols(HSTMT StatementHandle,
- SQLSMALLINT *ColumnCount)
+RETCODE SQL_API
+SQLNumResultCols(HSTMT StatementHandle,
+ SQLSMALLINT * ColumnCount)
{
mylog("[SQLNumResultCols]");
return PGAPI_NumResultCols(StatementHandle, ColumnCount);
}
-RETCODE SQL_API SQLParamData(HSTMT StatementHandle,
- PTR *Value)
+RETCODE SQL_API
+SQLParamData(HSTMT StatementHandle,
+ PTR * Value)
{
mylog("[SQLParamData]");
return PGAPI_ParamData(StatementHandle, Value);
}
-RETCODE SQL_API SQLPrepare(HSTMT StatementHandle,
- SQLCHAR *StatementText, SQLINTEGER TextLength)
+RETCODE SQL_API
+SQLPrepare(HSTMT StatementHandle,
+ SQLCHAR * StatementText, SQLINTEGER TextLength)
{
mylog("[SQLPrepare]");
return PGAPI_Prepare(StatementHandle, StatementText, TextLength);
}
-RETCODE SQL_API SQLPutData(HSTMT StatementHandle,
- PTR Data, SQLINTEGER StrLen_or_Ind)
+RETCODE SQL_API
+SQLPutData(HSTMT StatementHandle,
+ PTR Data, SQLINTEGER StrLen_or_Ind)
{
mylog("[SQLPutData]");
return PGAPI_PutData(StatementHandle, Data, StrLen_or_Ind);
}
-RETCODE SQL_API SQLRowCount(HSTMT StatementHandle,
- SQLINTEGER *RowCount)
+RETCODE SQL_API
+SQLRowCount(HSTMT StatementHandle,
+ SQLINTEGER * RowCount)
{
mylog("[SQLRowCount]");
return PGAPI_RowCount(StatementHandle, RowCount);
}
-RETCODE SQL_API SQLSetConnectOption(HDBC ConnectionHandle,
- SQLUSMALLINT Option, SQLUINTEGER Value)
+RETCODE SQL_API
+SQLSetConnectOption(HDBC ConnectionHandle,
+ SQLUSMALLINT Option, SQLUINTEGER Value)
{
mylog("[SQLSetConnectionOption]");
return PGAPI_SetConnectOption(ConnectionHandle, Option, Value);
}
-RETCODE SQL_API SQLSetCursorName(HSTMT StatementHandle,
- SQLCHAR *CursorName, SQLSMALLINT NameLength)
+RETCODE SQL_API
+SQLSetCursorName(HSTMT StatementHandle,
+ SQLCHAR * CursorName, SQLSMALLINT NameLength)
{
mylog("[SQLSetCursorName]");
return PGAPI_SetCursorName(StatementHandle, CursorName, NameLength);
}
-RETCODE SQL_API SQLSetParam(HSTMT StatementHandle,
- SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
- SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision,
- SQLSMALLINT ParameterScale, PTR ParameterValue,
- SQLINTEGER *StrLen_or_Ind)
+RETCODE SQL_API
+SQLSetParam(HSTMT StatementHandle,
+ SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
+ SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision,
+ SQLSMALLINT ParameterScale, PTR ParameterValue,
+ SQLINTEGER * StrLen_or_Ind)
{
mylog("[SQLSetParam]");
+
/*
- return PGAPI_SetParam(StatementHandle, ParameterNumber, ValueType,
- ParameterType, LengthPrecision, ParameterScale, ParameterValue,
- StrLen_or_Ind);
- */
- return SQL_ERROR;
+ * return PGAPI_SetParam(StatementHandle, ParameterNumber, ValueType,
+ * ParameterType, LengthPrecision, ParameterScale, ParameterValue,
+ * StrLen_or_Ind);
+ */
+ return SQL_ERROR;
}
-RETCODE SQL_API SQLSetStmtOption(HSTMT StatementHandle,
- SQLUSMALLINT Option, SQLUINTEGER Value)
+RETCODE SQL_API
+SQLSetStmtOption(HSTMT StatementHandle,
+ SQLUSMALLINT Option, SQLUINTEGER Value)
{
mylog("[SQLSetStmtOption]");
return PGAPI_SetStmtOption(StatementHandle, Option, Value);
}
-RETCODE SQL_API SQLSpecialColumns(HSTMT StatementHandle,
- SQLUSMALLINT IdentifierType, SQLCHAR *CatalogName,
- SQLSMALLINT NameLength1, SQLCHAR *SchemaName,
- SQLSMALLINT NameLength2, SQLCHAR *TableName,
- SQLSMALLINT NameLength3, SQLUSMALLINT Scope,
- SQLUSMALLINT Nullable)
+RETCODE SQL_API
+SQLSpecialColumns(HSTMT StatementHandle,
+ SQLUSMALLINT IdentifierType, SQLCHAR * CatalogName,
+ SQLSMALLINT NameLength1, SQLCHAR * SchemaName,
+ SQLSMALLINT NameLength2, SQLCHAR * TableName,
+ SQLSMALLINT NameLength3, SQLUSMALLINT Scope,
+ SQLUSMALLINT Nullable)
{
mylog("[SQLSpecialColumns]");
return PGAPI_SpecialColumns(StatementHandle, IdentifierType, CatalogName,
- NameLength1, SchemaName, NameLength2, TableName, NameLength3,
- Scope, Nullable);
+ NameLength1, SchemaName, NameLength2, TableName, NameLength3,
+ Scope, Nullable);
}
-RETCODE SQL_API SQLStatistics(HSTMT StatementHandle,
- SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
- SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
- SQLCHAR *TableName, SQLSMALLINT NameLength3,
- SQLUSMALLINT Unique, SQLUSMALLINT Reserved)
+RETCODE SQL_API
+SQLStatistics(HSTMT StatementHandle,
+ SQLCHAR * CatalogName, SQLSMALLINT NameLength1,
+ SQLCHAR * SchemaName, SQLSMALLINT NameLength2,
+ SQLCHAR * TableName, SQLSMALLINT NameLength3,
+ SQLUSMALLINT Unique, SQLUSMALLINT Reserved)
{
mylog("[SQLStatistics]");
return PGAPI_Statistics(StatementHandle, CatalogName, NameLength1,
- SchemaName, NameLength2, TableName, NameLength3, Unique,
- Reserved);
+ SchemaName, NameLength2, TableName, NameLength3, Unique,
+ Reserved);
}
-RETCODE SQL_API SQLTables(HSTMT StatementHandle,
- SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
- SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
- SQLCHAR *TableName, SQLSMALLINT NameLength3,
- SQLCHAR *TableType, SQLSMALLINT NameLength4)
+RETCODE SQL_API
+SQLTables(HSTMT StatementHandle,
+ SQLCHAR * CatalogName, SQLSMALLINT NameLength1,
+ SQLCHAR * SchemaName, SQLSMALLINT NameLength2,
+ SQLCHAR * TableName, SQLSMALLINT NameLength3,
+ SQLCHAR * TableType, SQLSMALLINT NameLength4)
{
mylog("[SQLTables]");
return PGAPI_Tables(StatementHandle, CatalogName, NameLength1,
- SchemaName, NameLength2, TableName, NameLength3,
- TableType, NameLength4);
+ SchemaName, NameLength2, TableName, NameLength3,
+ TableType, NameLength4);
}
-RETCODE SQL_API SQLTransact(HENV EnvironmentHandle,
- HDBC ConnectionHandle, SQLUSMALLINT CompletionType)
+RETCODE SQL_API
+SQLTransact(HENV EnvironmentHandle,
+ HDBC ConnectionHandle, SQLUSMALLINT CompletionType)
{
mylog("[SQLTransact]");
return PGAPI_Transact(EnvironmentHandle, ConnectionHandle, CompletionType);
}
-RETCODE SQL_API SQLColAttributes(
- HSTMT hstmt,
- SQLUSMALLINT icol,
- SQLUSMALLINT fDescType,
- PTR rgbDesc,
- SQLSMALLINT cbDescMax,
- SQLSMALLINT *pcbDesc,
- SQLINTEGER *pfDesc)
+RETCODE SQL_API
+SQLColAttributes(
+ HSTMT hstmt,
+ SQLUSMALLINT icol,
+ SQLUSMALLINT fDescType,
+ PTR rgbDesc,
+ SQLSMALLINT cbDescMax,
+ SQLSMALLINT * pcbDesc,
+ SQLINTEGER * pfDesc)
{
mylog("[SQLColAttributes]");
return PGAPI_ColAttributes(hstmt, icol, fDescType, rgbDesc,
- cbDescMax, pcbDesc, pfDesc);
+ cbDescMax, pcbDesc, pfDesc);
}
-RETCODE SQL_API SQLColumnPrivileges(
- HSTMT hstmt,
- SQLCHAR *szCatalogName,
- SQLSMALLINT cbCatalogName,
- SQLCHAR *szSchemaName,
- SQLSMALLINT cbSchemaName,
- SQLCHAR *szTableName,
- SQLSMALLINT cbTableName,
- SQLCHAR *szColumnName,
- SQLSMALLINT cbColumnName)
+RETCODE SQL_API
+SQLColumnPrivileges(
+ HSTMT hstmt,
+ SQLCHAR * szCatalogName,
+ SQLSMALLINT cbCatalogName,
+ SQLCHAR * szSchemaName,
+ SQLSMALLINT cbSchemaName,
+ SQLCHAR * szTableName,
+ SQLSMALLINT cbTableName,
+ SQLCHAR * szColumnName,
+ SQLSMALLINT cbColumnName)
{
mylog("[SQLColumnPrivileges]");
return PGAPI_ColumnPrivileges(hstmt, szCatalogName, cbCatalogName,
- szSchemaName, cbSchemaName, szTableName, cbTableName,
- szColumnName, cbColumnName);
+ szSchemaName, cbSchemaName, szTableName, cbTableName,
+ szColumnName, cbColumnName);
}
-RETCODE SQL_API SQLDescribeParam(
- HSTMT hstmt,
- SQLUSMALLINT ipar,
- SQLSMALLINT *pfSqlType,
- SQLUINTEGER *pcbParamDef,
- SQLSMALLINT *pibScale,
- SQLSMALLINT *pfNullable)
+RETCODE SQL_API
+SQLDescribeParam(
+ HSTMT hstmt,
+ SQLUSMALLINT ipar,
+ SQLSMALLINT * pfSqlType,
+ SQLUINTEGER * pcbParamDef,
+ SQLSMALLINT * pibScale,
+ SQLSMALLINT * pfNullable)
{
mylog("[SQLDescribeParam]");
return PGAPI_DescribeParam(hstmt, ipar, pfSqlType, pcbParamDef,
- pibScale, pfNullable);
+ pibScale, pfNullable);
}
-RETCODE SQL_API SQLExtendedFetch(
- HSTMT hstmt,
- SQLUSMALLINT fFetchType,
- SQLINTEGER irow,
- SQLUINTEGER *pcrow,
- SQLUSMALLINT *rgfRowStatus)
+RETCODE SQL_API
+SQLExtendedFetch(
+ HSTMT hstmt,
+ SQLUSMALLINT fFetchType,
+ SQLINTEGER irow,
+ SQLUINTEGER * pcrow,
+ SQLUSMALLINT * rgfRowStatus)
{
mylog("[SQLExtendedFetch]");
return PGAPI_ExtendedFetch(hstmt, fFetchType, irow, pcrow, rgfRowStatus);
}
-RETCODE SQL_API SQLForeignKeys(
- HSTMT hstmt,
- SQLCHAR *szPkCatalogName,
- SQLSMALLINT cbPkCatalogName,
- SQLCHAR *szPkSchemaName,
- SQLSMALLINT cbPkSchemaName,
- SQLCHAR *szPkTableName,
- SQLSMALLINT cbPkTableName,
- SQLCHAR *szFkCatalogName,
- SQLSMALLINT cbFkCatalogName,
- SQLCHAR *szFkSchemaName,
- SQLSMALLINT cbFkSchemaName,
- SQLCHAR *szFkTableName,
- SQLSMALLINT cbFkTableName)
+RETCODE SQL_API
+SQLForeignKeys(
+ HSTMT hstmt,
+ SQLCHAR * szPkCatalogName,
+ SQLSMALLINT cbPkCatalogName,
+ SQLCHAR * szPkSchemaName,
+ SQLSMALLINT cbPkSchemaName,
+ SQLCHAR * szPkTableName,
+ SQLSMALLINT cbPkTableName,
+ SQLCHAR * szFkCatalogName,
+ SQLSMALLINT cbFkCatalogName,
+ SQLCHAR * szFkSchemaName,
+ SQLSMALLINT cbFkSchemaName,
+ SQLCHAR * szFkTableName,
+ SQLSMALLINT cbFkTableName)
{
mylog("[SQLForeignKeys]");
return PGAPI_ForeignKeys(hstmt, szPkCatalogName, cbPkCatalogName,
- szPkSchemaName, cbPkSchemaName, szPkTableName,
- cbPkTableName, szFkCatalogName, cbFkCatalogName,
- szFkSchemaName, cbFkSchemaName, szFkTableName, cbFkTableName);
+ szPkSchemaName, cbPkSchemaName, szPkTableName,
+ cbPkTableName, szFkCatalogName, cbFkCatalogName,
+ szFkSchemaName, cbFkSchemaName, szFkTableName, cbFkTableName);
}
-RETCODE SQL_API SQLMoreResults(HSTMT hstmt)
+RETCODE SQL_API
+SQLMoreResults(HSTMT hstmt)
{
mylog("[SQLMoreResults]");
return PGAPI_MoreResults(hstmt);
}
-
-RETCODE SQL_API SQLNativeSql(
- HDBC hdbc,
- SQLCHAR *szSqlStrIn,
- SQLINTEGER cbSqlStrIn,
- SQLCHAR *szSqlStr,
- SQLINTEGER cbSqlStrMax,
- SQLINTEGER *pcbSqlStr)
+
+RETCODE SQL_API
+SQLNativeSql(
+ HDBC hdbc,
+ SQLCHAR * szSqlStrIn,
+ SQLINTEGER cbSqlStrIn,
+ SQLCHAR * szSqlStr,
+ SQLINTEGER cbSqlStrMax,
+ SQLINTEGER * pcbSqlStr)
{
mylog("[SQLNativeSql]");
return PGAPI_NativeSql(hdbc, szSqlStrIn, cbSqlStrIn, szSqlStr,
- cbSqlStrMax, pcbSqlStr);
+ cbSqlStrMax, pcbSqlStr);
}
-RETCODE SQL_API SQLNumParams(
- HSTMT hstmt,
- SQLSMALLINT *pcpar)
+RETCODE SQL_API
+SQLNumParams(
+ HSTMT hstmt,
+ SQLSMALLINT * pcpar)
{
mylog("[SQLNumParams]");
return PGAPI_NumParams(hstmt, pcpar);
}
-RETCODE SQL_API SQLParamOptions(
- HSTMT hstmt,
- SQLUINTEGER crow,
- SQLUINTEGER *pirow)
+RETCODE SQL_API
+SQLParamOptions(
+ HSTMT hstmt,
+ SQLUINTEGER crow,
+ SQLUINTEGER * pirow)
{
mylog("[SQLParamOptions]");
return PGAPI_ParamOptions(hstmt, crow, pirow);
}
-RETCODE SQL_API SQLPrimaryKeys(
- HSTMT hstmt,
- SQLCHAR *szCatalogName,
- SQLSMALLINT cbCatalogName,
- SQLCHAR *szSchemaName,
- SQLSMALLINT cbSchemaName,
- SQLCHAR *szTableName,
- SQLSMALLINT cbTableName)
+RETCODE SQL_API
+SQLPrimaryKeys(
+ HSTMT hstmt,
+ SQLCHAR * szCatalogName,
+ SQLSMALLINT cbCatalogName,
+ SQLCHAR * szSchemaName,
+ SQLSMALLINT cbSchemaName,
+ SQLCHAR * szTableName,
+ SQLSMALLINT cbTableName)
{
mylog("[SQLPrimaryKeys]");
return PGAPI_PrimaryKeys(hstmt, szCatalogName, cbCatalogName,
- szSchemaName, cbSchemaName, szTableName, cbTableName);
+ szSchemaName, cbSchemaName, szTableName, cbTableName);
}
-RETCODE SQL_API SQLProcedureColumns(
- HSTMT hstmt,
- SQLCHAR *szCatalogName,
- SQLSMALLINT cbCatalogName,
- SQLCHAR *szSchemaName,
- SQLSMALLINT cbSchemaName,
- SQLCHAR *szProcName,
- SQLSMALLINT cbProcName,
- SQLCHAR *szColumnName,
- SQLSMALLINT cbColumnName)
+RETCODE SQL_API
+SQLProcedureColumns(
+ HSTMT hstmt,
+ SQLCHAR * szCatalogName,
+ SQLSMALLINT cbCatalogName,
+ SQLCHAR * szSchemaName,
+ SQLSMALLINT cbSchemaName,
+ SQLCHAR * szProcName,
+ SQLSMALLINT cbProcName,
+ SQLCHAR * szColumnName,
+ SQLSMALLINT cbColumnName)
{
mylog("[SQLProcedureColumns]");
return PGAPI_ProcedureColumns(hstmt, szCatalogName, cbCatalogName,
- szSchemaName, cbSchemaName, szProcName, cbProcName,
- szColumnName, cbColumnName);
+ szSchemaName, cbSchemaName, szProcName, cbProcName,
+ szColumnName, cbColumnName);
}
-RETCODE SQL_API SQLProcedures(
- HSTMT hstmt,
- SQLCHAR *szCatalogName,
- SQLSMALLINT cbCatalogName,
- SQLCHAR *szSchemaName,
- SQLSMALLINT cbSchemaName,
- SQLCHAR *szProcName,
- SQLSMALLINT cbProcName)
+RETCODE SQL_API
+SQLProcedures(
+ HSTMT hstmt,
+ SQLCHAR * szCatalogName,
+ SQLSMALLINT cbCatalogName,
+ SQLCHAR * szSchemaName,
+ SQLSMALLINT cbSchemaName,
+ SQLCHAR * szProcName,
+ SQLSMALLINT cbProcName)
{
mylog("[SQLProcedures]");
return PGAPI_Procedures(hstmt, szCatalogName, cbCatalogName,
- szSchemaName, cbSchemaName, szProcName, cbProcName);
+ szSchemaName, cbSchemaName, szProcName, cbProcName);
}
-RETCODE SQL_API SQLSetPos(
- HSTMT hstmt,
- SQLUSMALLINT irow,
- SQLUSMALLINT fOption,
- SQLUSMALLINT fLock)
+RETCODE SQL_API
+SQLSetPos(
+ HSTMT hstmt,
+ SQLUSMALLINT irow,
+ SQLUSMALLINT fOption,
+ SQLUSMALLINT fLock)
{
mylog("[SQLSetPos]");
return PGAPI_SetPos(hstmt, irow, fOption, fLock);
}
-RETCODE SQL_API SQLTablePrivileges(
- HSTMT hstmt,
- SQLCHAR *szCatalogName,
- SQLSMALLINT cbCatalogName,
- SQLCHAR *szSchemaName,
- SQLSMALLINT cbSchemaName,
- SQLCHAR *szTableName,
- SQLSMALLINT cbTableName)
+RETCODE SQL_API
+SQLTablePrivileges(
+ HSTMT hstmt,
+ SQLCHAR * szCatalogName,
+ SQLSMALLINT cbCatalogName,
+ SQLCHAR * szSchemaName,
+ SQLSMALLINT cbSchemaName,
+ SQLCHAR * szTableName,
+ SQLSMALLINT cbTableName)
{
mylog("[SQLTablePrivileges]");
return PGAPI_TablePrivileges(hstmt, szCatalogName, cbCatalogName,
- szSchemaName, cbSchemaName, szTableName, cbTableName);
-}
-
-RETCODE SQL_API SQLBindParameter(
- HSTMT hstmt,
- SQLUSMALLINT ipar,
- SQLSMALLINT fParamType,
- SQLSMALLINT fCType,
- SQLSMALLINT fSqlType,
- SQLUINTEGER cbColDef,
- SQLSMALLINT ibScale,
- PTR rgbValue,
- SQLINTEGER cbValueMax,
- SQLINTEGER *pcbValue)
+ szSchemaName, cbSchemaName, szTableName, cbTableName);
+}
+
+RETCODE SQL_API
+SQLBindParameter(
+ HSTMT hstmt,
+ SQLUSMALLINT ipar,
+ SQLSMALLINT fParamType,
+ SQLSMALLINT fCType,
+ SQLSMALLINT fSqlType,
+ SQLUINTEGER cbColDef,
+ SQLSMALLINT ibScale,
+ PTR rgbValue,
+ SQLINTEGER cbValueMax,
+ SQLINTEGER * pcbValue)
{
mylog("[SQLBindParameter]");
return PGAPI_BindParameter(hstmt, ipar, fParamType, fCType,
- fSqlType, cbColDef, ibScale, rgbValue, cbValueMax,
- pcbValue);
+ fSqlType, cbColDef, ibScale, rgbValue, cbValueMax,
+ pcbValue);
}
#include "pgapifunc.h"
/* SQLAllocConnect/SQLAllocEnv/SQLAllocStmt -> SQLAllocHandle */
-RETCODE SQL_API SQLAllocHandle(SQLSMALLINT HandleType,
- SQLHANDLE InputHandle, SQLHANDLE *OutputHandle)
+RETCODE SQL_API
+SQLAllocHandle(SQLSMALLINT HandleType,
+ SQLHANDLE InputHandle, SQLHANDLE * OutputHandle)
{
mylog("[[SQLAllocHandle]]");
switch (HandleType)
return PGAPI_AllocConnect(InputHandle, OutputHandle);
case SQL_HANDLE_STMT:
return PGAPI_AllocStmt(InputHandle, OutputHandle);
- default: break;
+ default:
+ break;
}
return SQL_ERROR;
}
+
/* SQLBindParameter/SQLSetParam -> SQLBindParam */
-RETCODE SQL_API SQLBindParam(HSTMT StatementHandle,
- SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
- SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision,
- SQLSMALLINT ParameterScale, PTR ParameterValue,
- SQLINTEGER *StrLen_or_Ind)
+RETCODE SQL_API
+SQLBindParam(HSTMT StatementHandle,
+ SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
+ SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision,
+ SQLSMALLINT ParameterScale, PTR ParameterValue,
+ SQLINTEGER * StrLen_or_Ind)
{
- int BufferLength = 512; /* Is it OK ? */
+ int BufferLength = 512; /* Is it OK ? */
+
mylog("[[SQLBindParam]]");
return PGAPI_BindParameter(StatementHandle, ParameterNumber, SQL_PARAM_INPUT, ValueType, ParameterType, LengthPrecision, ParameterScale, ParameterValue, BufferLength, StrLen_or_Ind);
}
+
/* New function */
-RETCODE SQL_API SQLCloseCursor(HSTMT StatementHandle)
+RETCODE SQL_API
+SQLCloseCursor(HSTMT StatementHandle)
{
mylog("[[SQLCloseCursor]]");
return PGAPI_FreeStmt(StatementHandle, SQL_CLOSE);
}
/* SQLColAttributes -> SQLColAttribute */
-RETCODE SQL_API SQLColAttribute (HSTMT StatementHandle,
- SQLUSMALLINT ColumnNumber, SQLUSMALLINT FieldIdentifier,
- PTR CharacterAttribute, SQLSMALLINT BufferLength,
- SQLSMALLINT *StringLength, PTR NumericAttribute)
+RETCODE SQL_API
+SQLColAttribute(HSTMT StatementHandle,
+ SQLUSMALLINT ColumnNumber, SQLUSMALLINT FieldIdentifier,
+ PTR CharacterAttribute, SQLSMALLINT BufferLength,
+ SQLSMALLINT * StringLength, PTR NumericAttribute)
{
mylog("[[SQLColAttribute]]");
return PGAPI_ColAttributes(StatementHandle, ColumnNumber,
- FieldIdentifier, CharacterAttribute, BufferLength,
- StringLength, NumericAttribute);
+ FieldIdentifier, CharacterAttribute, BufferLength,
+ StringLength, NumericAttribute);
}
+
/* new function */
-RETCODE SQL_API SQLCopyDesc(SQLHDESC SourceDescHandle,
- SQLHDESC TargetDescHandle)
+RETCODE SQL_API
+SQLCopyDesc(SQLHDESC SourceDescHandle,
+ SQLHDESC TargetDescHandle)
{
mylog("[[SQLCopyDesc]]\n");
return SQL_ERROR;
}
-/* SQLTransact -> SQLEndTran */
-RETCODE SQL_API SQLEndTran(SQLSMALLINT HandleType, SQLHANDLE Handle,
- SQLSMALLINT CompletionType)
+
+/* SQLTransact -> SQLEndTran */
+RETCODE SQL_API
+SQLEndTran(SQLSMALLINT HandleType, SQLHANDLE Handle,
+ SQLSMALLINT CompletionType)
{
mylog("[[SQLEndTran]]");
switch (HandleType)
{
- case SQL_HANDLE_ENV:
+ case SQL_HANDLE_ENV:
return PGAPI_Transact(Handle, SQL_NULL_HDBC, CompletionType);
- case SQL_HANDLE_DBC:
+ case SQL_HANDLE_DBC:
return PGAPI_Transact(SQL_NULL_HENV, Handle, CompletionType);
- default:break;
+ default:
+ break;
}
- return SQL_ERROR; /* SQLSTATE HY092 ("Invalid attribute/option identifier")*/
+ return SQL_ERROR; /* SQLSTATE HY092 ("Invalid
+ * attribute/option identifier") */
}
+
/* SQLExtendedFetch -> SQLFetchScroll */
-RETCODE SQL_API SQLFetchScroll(HSTMT StatementHandle,
- SQLSMALLINT FetchOrientation, SQLINTEGER FetchOffset)
+RETCODE SQL_API
+SQLFetchScroll(HSTMT StatementHandle,
+ SQLSMALLINT FetchOrientation, SQLINTEGER FetchOffset)
{
static char *func = "SQLFetchScroll";
- StatementClass *stmt = (StatementClass *) StatementHandle;
- RETCODE ret;
- SQLUSMALLINT *rowStatusArray = stmt->options.rowStatusArray;
- SQLINTEGER *pcRow = stmt->options.rowsFetched;
+ StatementClass *stmt = (StatementClass *) StatementHandle;
+ RETCODE ret;
+ SQLUSMALLINT *rowStatusArray = stmt->options.rowStatusArray;
+ SQLINTEGER *pcRow = stmt->options.rowsFetched;
+
mylog("[[%s]] %d,%d\n", func, FetchOrientation, FetchOffset);
if (FetchOrientation == SQL_FETCH_BOOKMARK)
{
}
}
ret = PGAPI_ExtendedFetch(StatementHandle, FetchOrientation, FetchOffset,
- pcRow, rowStatusArray);
+ pcRow, rowStatusArray);
if (ret != SQL_SUCCESS)
mylog("%s return = %d\n", func, ret);
return ret;
}
+
/* SQLFree(Connect/Env/Stmt) -> SQLFreeHandle */
-RETCODE SQL_API SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
+RETCODE SQL_API
+SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
{
mylog("[[SQLFreeHandle]]");
switch (HandleType)
return PGAPI_FreeConnect(Handle);
case SQL_HANDLE_STMT:
return PGAPI_FreeStmt(Handle, SQL_DROP);
- default: break;
+ default:
+ break;
}
return SQL_ERROR;
}
+
/* new function */
-RETCODE SQL_API SQLGetDescField(SQLHDESC DescriptorHandle,
- SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
- PTR Value, SQLINTEGER BufferLength,
- SQLINTEGER *StringLength)
+RETCODE SQL_API
+SQLGetDescField(SQLHDESC DescriptorHandle,
+ SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
+ PTR Value, SQLINTEGER BufferLength,
+ SQLINTEGER * StringLength)
{
mylog("[[SQLGetDescField]]\n");
return SQL_ERROR;
}
+
/* new function */
-RETCODE SQL_API SQLGetDescRec(SQLHDESC DescriptorHandle,
- SQLSMALLINT RecNumber, SQLCHAR *Name,
- SQLSMALLINT BufferLength, SQLSMALLINT *StringLength,
- SQLSMALLINT *Type, SQLSMALLINT *SubType,
- SQLINTEGER *Length, SQLSMALLINT *Precision,
- SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
+RETCODE SQL_API
+SQLGetDescRec(SQLHDESC DescriptorHandle,
+ SQLSMALLINT RecNumber, SQLCHAR * Name,
+ SQLSMALLINT BufferLength, SQLSMALLINT * StringLength,
+ SQLSMALLINT * Type, SQLSMALLINT * SubType,
+ SQLINTEGER * Length, SQLSMALLINT * Precision,
+ SQLSMALLINT * Scale, SQLSMALLINT * Nullable)
{
mylog("[[SQLGetDescRec]]\n");
return SQL_ERROR;
}
+
/* new function */
-RETCODE SQL_API SQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle,
- SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier,
- PTR DiagInfo, SQLSMALLINT BufferLength,
- SQLSMALLINT *StringLength)
+RETCODE SQL_API
+SQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle,
+ SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier,
+ PTR DiagInfo, SQLSMALLINT BufferLength,
+ SQLSMALLINT * StringLength)
{
mylog("[[SQLGetDiagField]]\n");
return SQL_ERROR;
}
+
/* SQLError -> SQLDiagRec */
-RETCODE SQL_API SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle,
- SQLSMALLINT RecNumber, SQLCHAR *Sqlstate,
- SQLINTEGER *NativeError, SQLCHAR *MessageText,
- SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
+RETCODE SQL_API
+SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle,
+ SQLSMALLINT RecNumber, SQLCHAR * Sqlstate,
+ SQLINTEGER * NativeError, SQLCHAR * MessageText,
+ SQLSMALLINT BufferLength, SQLSMALLINT * TextLength)
{
- RETCODE ret;
+ RETCODE ret;
+
mylog("[[SQLGetDiagRec]]\n");
switch (HandleType)
{
case SQL_HANDLE_ENV:
ret = PGAPI_Error(Handle, NULL, NULL, Sqlstate, NativeError,
- MessageText, BufferLength, TextLength);
+ MessageText, BufferLength, TextLength);
break;
case SQL_HANDLE_DBC:
- ret = PGAPI_Error(NULL, Handle, NULL, Sqlstate, NativeError,
- MessageText, BufferLength, TextLength);
+ ret = PGAPI_Error(NULL, Handle, NULL, Sqlstate, NativeError,
+ MessageText, BufferLength, TextLength);
break;
case SQL_HANDLE_STMT:
ret = PGAPI_Error(NULL, NULL, Handle, Sqlstate, NativeError,
- MessageText, BufferLength, TextLength);
+ MessageText, BufferLength, TextLength);
break;
default:
ret = SQL_ERROR;
}
if (ret == SQL_SUCCESS_WITH_INFO &&
- BufferLength == 0 &&
- *TextLength)
+ BufferLength == 0 &&
+ *TextLength)
{
- SQLSMALLINT BufferLength = *TextLength + 4;
- SQLCHAR *MessageText = malloc(BufferLength);
+ SQLSMALLINT BufferLength = *TextLength + 4;
+ SQLCHAR *MessageText = malloc(BufferLength);
+
ret = SQLGetDiagRec(HandleType, Handle, RecNumber, Sqlstate,
- NativeError, MessageText, BufferLength,
- TextLength);
+ NativeError, MessageText, BufferLength,
+ TextLength);
free(MessageText);
}
return ret;
}
+
/* new function */
-RETCODE SQL_API SQLGetEnvAttr(HENV EnvironmentHandle,
- SQLINTEGER Attribute, PTR Value,
- SQLINTEGER BufferLength, SQLINTEGER *StringLength)
+RETCODE SQL_API
+SQLGetEnvAttr(HENV EnvironmentHandle,
+ SQLINTEGER Attribute, PTR Value,
+ SQLINTEGER BufferLength, SQLINTEGER * StringLength)
{
EnvironmentClass *env = (EnvironmentClass *) EnvironmentHandle;
+
mylog("[[SQLGetEnvAttr]] %d\n", Attribute);
switch (Attribute)
{
}
return SQL_SUCCESS;
}
+
/* SQLGetConnectOption -> SQLGetconnectAttr */
-RETCODE SQL_API SQLGetConnectAttr(HDBC ConnectionHandle,
- SQLINTEGER Attribute, PTR Value,
- SQLINTEGER BufferLength, SQLINTEGER *StringLength)
+RETCODE SQL_API
+SQLGetConnectAttr(HDBC ConnectionHandle,
+ SQLINTEGER Attribute, PTR Value,
+ SQLINTEGER BufferLength, SQLINTEGER * StringLength)
{
- ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
+ ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
+
mylog("[[SQLGetConnectAttr]] %d\n", Attribute);
switch (Attribute)
{
conn->errormsg = "Unsupported connection option (Set)";
return SQL_ERROR;
}
- return PGAPI_GetConnectOption (ConnectionHandle, (UWORD) Attribute, Value);
+ return PGAPI_GetConnectOption(ConnectionHandle, (UWORD) Attribute, Value);
}
+
/* SQLGetStmtOption -> SQLGetStmtAttr */
-RETCODE SQL_API SQLGetStmtAttr(HSTMT StatementHandle,
- SQLINTEGER Attribute, PTR Value,
- SQLINTEGER BufferLength, SQLINTEGER *StringLength)
+RETCODE SQL_API
+SQLGetStmtAttr(HSTMT StatementHandle,
+ SQLINTEGER Attribute, PTR Value,
+ SQLINTEGER BufferLength, SQLINTEGER * StringLength)
{
static char *func = "SQLGetStmtAttr";
- StatementClass *stmt = (StatementClass *) StatementHandle;
- RETCODE ret = SQL_SUCCESS;
- int len = 0;
+ StatementClass *stmt = (StatementClass *) StatementHandle;
+ RETCODE ret = SQL_SUCCESS;
+ int len = 0;
+
mylog("[[%s]] %d\n", func, Attribute);
switch (Attribute)
{
- case SQL_ATTR_FETCH_BOOKMARK_PTR: /* 16 */
+ case SQL_ATTR_FETCH_BOOKMARK_PTR: /* 16 */
Value = stmt->options.bookmark_ptr;
+
len = 4;
- break;
+ break;
case SQL_ATTR_ROW_STATUS_PTR: /* 25 */
Value = stmt->options.rowStatusArray;
+
len = 4;
break;
- case SQL_ATTR_ROWS_FETCHED_PTR: /* 26 */
+ case SQL_ATTR_ROWS_FETCHED_PTR: /* 26 */
Value = stmt->options.rowsFetched;
+
len = 4;
break;
case SQL_ATTR_ROW_ARRAY_SIZE: /* 27 */
*((SQLUINTEGER *) Value) = stmt->options.rowset_size;
len = 4;
- break;
- case SQL_ATTR_APP_ROW_DESC: /* 10010 */
- *((HSTMT *) Value) = StatementHandle; /* this is useless */
+ break;
+ case SQL_ATTR_APP_ROW_DESC: /* 10010 */
+ *((HSTMT *) Value) = StatementHandle; /* this is useless */
len = 4;
- break;
+ break;
case SQL_ATTR_APP_PARAM_DESC: /* 10011 */
- *((HSTMT *) Value) = StatementHandle; /* this is useless */
+ *((HSTMT *) Value) = StatementHandle; /* this is useless */
len = 4;
- break;
- case SQL_ATTR_IMP_ROW_DESC: /* 10012 */
- *((HSTMT *) Value) = StatementHandle; /* this is useless */
+ break;
+ case SQL_ATTR_IMP_ROW_DESC: /* 10012 */
+ *((HSTMT *) Value) = StatementHandle; /* this is useless */
len = 4;
- break;
+ break;
case SQL_ATTR_IMP_PARAM_DESC: /* 10013 */
- *((HSTMT *) Value) = StatementHandle; /* this is useless */
+ *((HSTMT *) Value) = StatementHandle; /* this is useless */
len = 4;
- break;
- case SQL_ATTR_AUTO_IPD: /* 10001 */
+ break;
+ case SQL_ATTR_AUTO_IPD:/* 10001 */
case SQL_ATTR_ROW_BIND_TYPE: /* == SQL_BIND_TYPE */
case SQL_ATTR_PARAMSET_SIZE: /* 22 */
- case SQL_ATTR_PARAM_STATUS_PTR: /* 20 */
- case SQL_ATTR_PARAMS_PROCESSED_PTR: /* 21 */
+ case SQL_ATTR_PARAM_STATUS_PTR: /* 20 */
+ case SQL_ATTR_PARAMS_PROCESSED_PTR: /* 21 */
- case SQL_ATTR_CURSOR_SCROLLABLE: /* -1 */
- case SQL_ATTR_CURSOR_SENSITIVITY: /* -2 */
+ case SQL_ATTR_CURSOR_SCROLLABLE: /* -1 */
+ case SQL_ATTR_CURSOR_SENSITIVITY: /* -2 */
case SQL_ATTR_ENABLE_AUTO_IPD: /* 15 */
- case SQL_ATTR_METADATA_ID: /* 10014 */
- /* case SQL_ATTR_PREDICATE_PTR:
- case SQL_ATTR_PREDICATE_OCTET_LENGTH_PTR: */
+ case SQL_ATTR_METADATA_ID: /* 10014 */
+
+ /*
+ * case SQL_ATTR_PREDICATE_PTR: case
+ * SQL_ATTR_PREDICATE_OCTET_LENGTH_PTR:
+ */
case SQL_ATTR_PARAM_BIND_OFFSET_PTR: /* 17 */
- case SQL_ATTR_PARAM_BIND_TYPE: /* 18 */
- case SQL_ATTR_PARAM_OPERATION_PTR: /* 19 */
- case SQL_ATTR_ROW_BIND_OFFSET_PTR: /* 23 */
- case SQL_ATTR_ROW_OPERATION_PTR: /* 24 */
+ case SQL_ATTR_PARAM_BIND_TYPE: /* 18 */
+ case SQL_ATTR_PARAM_OPERATION_PTR: /* 19 */
+ case SQL_ATTR_ROW_BIND_OFFSET_PTR: /* 23 */
+ case SQL_ATTR_ROW_OPERATION_PTR: /* 24 */
stmt->errornumber = STMT_INVALID_OPTION_IDENTIFIER;
stmt->errormsg = "Unsupported statement option (Get)";
SC_log_error(func, "", stmt);
}
/* SQLSetConnectOption -> SQLSetConnectAttr */
-RETCODE SQL_API SQLSetConnectAttr(HDBC ConnectionHandle,
- SQLINTEGER Attribute, PTR Value,
- SQLINTEGER StringLength)
+RETCODE SQL_API
+SQLSetConnectAttr(HDBC ConnectionHandle,
+ SQLINTEGER Attribute, PTR Value,
+ SQLINTEGER StringLength)
{
- ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
+ ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
mylog("[[SQLSetConnectAttr]] %d\n", Attribute);
switch (Attribute)
}
return PGAPI_SetConnectOption(ConnectionHandle, (UWORD) Attribute, (UDWORD) Value);
}
+
/* new function */
-RETCODE SQL_API SQLSetDescField(SQLHDESC DescriptorHandle,
- SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
- PTR Value, SQLINTEGER BufferLength)
+RETCODE SQL_API
+SQLSetDescField(SQLHDESC DescriptorHandle,
+ SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
+ PTR Value, SQLINTEGER BufferLength)
{
mylog("[[SQLSetDescField]]\n");
return SQL_ERROR;
}
+
/* new fucntion */
-RETCODE SQL_API SQLSetDescRec(SQLHDESC DescriptorHandle,
- SQLSMALLINT RecNumber, SQLSMALLINT Type,
- SQLSMALLINT SubType, SQLINTEGER Length,
- SQLSMALLINT Precision, SQLSMALLINT Scale,
- PTR Data, SQLINTEGER *StringLength,
- SQLINTEGER *Indicator)
+RETCODE SQL_API
+SQLSetDescRec(SQLHDESC DescriptorHandle,
+ SQLSMALLINT RecNumber, SQLSMALLINT Type,
+ SQLSMALLINT SubType, SQLINTEGER Length,
+ SQLSMALLINT Precision, SQLSMALLINT Scale,
+ PTR Data, SQLINTEGER * StringLength,
+ SQLINTEGER * Indicator)
{
mylog("[[SQLsetDescRec]]\n");
return SQL_ERROR;
}
+
/* new function */
-RETCODE SQL_API SQLSetEnvAttr(HENV EnvironmentHandle,
- SQLINTEGER Attribute, PTR Value,
- SQLINTEGER StringLength)
+RETCODE SQL_API
+SQLSetEnvAttr(HENV EnvironmentHandle,
+ SQLINTEGER Attribute, PTR Value,
+ SQLINTEGER StringLength)
{
EnvironmentClass *env = (EnvironmentClass *) EnvironmentHandle;
+
mylog("[[SQLSetEnvAttr]] att=%d,%u\n", Attribute, Value);
switch (Attribute)
{
env->errormsg = "SetEnv changed to ";
return SQL_SUCCESS_WITH_INFO;
}
+
/* SQLSet(Param/Scroll/Stmt)Option -> SQLSetStmtAttr */
-RETCODE SQL_API SQLSetStmtAttr(HSTMT StatementHandle,
- SQLINTEGER Attribute, PTR Value,
- SQLINTEGER StringLength)
+RETCODE SQL_API
+SQLSetStmtAttr(HSTMT StatementHandle,
+ SQLINTEGER Attribute, PTR Value,
+ SQLINTEGER StringLength)
{
static char *func = "SQLSetStmtAttr";
- StatementClass *stmt = (StatementClass *) StatementHandle;
- UDWORD rowcount;
+ StatementClass *stmt = (StatementClass *) StatementHandle;
+ UDWORD rowcount;
+
mylog("[[%s]] %d,%u\n", func, Attribute, Value);
switch (Attribute)
{
case SQL_ATTR_PARAMSET_SIZE: /* 22 */
return PGAPI_ParamOptions(StatementHandle, (UWORD) Value, &rowcount);
- case SQL_ATTR_PARAM_STATUS_PTR: /* 20 */
- case SQL_ATTR_PARAMS_PROCESSED_PTR: /* 21 */
+ case SQL_ATTR_PARAM_STATUS_PTR: /* 20 */
+ case SQL_ATTR_PARAMS_PROCESSED_PTR: /* 21 */
- case SQL_ATTR_CURSOR_SCROLLABLE: /* -1 */
- case SQL_ATTR_CURSOR_SENSITIVITY: /* -2 */
+ case SQL_ATTR_CURSOR_SCROLLABLE: /* -1 */
+ case SQL_ATTR_CURSOR_SENSITIVITY: /* -2 */
case SQL_ATTR_ENABLE_AUTO_IPD: /* 15 */
- case SQL_ATTR_APP_ROW_DESC: /* 10010 */
+ case SQL_ATTR_APP_ROW_DESC: /* 10010 */
case SQL_ATTR_APP_PARAM_DESC: /* 10011 */
- case SQL_ATTR_AUTO_IPD: /* 10001 */
- /*case SQL_ATTR_ROW_BIND_TYPE:*/ /* == SQL_BIND_TYPE */
- case SQL_ATTR_IMP_ROW_DESC: /* 10012 */
+ case SQL_ATTR_AUTO_IPD:/* 10001 */
+ /* case SQL_ATTR_ROW_BIND_TYPE: *//* == SQL_BIND_TYPE */
+ case SQL_ATTR_IMP_ROW_DESC: /* 10012 */
case SQL_ATTR_IMP_PARAM_DESC: /* 10013 */
- case SQL_ATTR_METADATA_ID: /* 10014 */
- /* case SQL_ATTR_PREDICATE_PTR:
- case SQL_ATTR_PREDICATE_OCTET_LENGTH_PTR: */
+ case SQL_ATTR_METADATA_ID: /* 10014 */
+
+ /*
+ * case SQL_ATTR_PREDICATE_PTR: case
+ * SQL_ATTR_PREDICATE_OCTET_LENGTH_PTR:
+ */
case SQL_ATTR_PARAM_BIND_OFFSET_PTR: /* 17 */
- case SQL_ATTR_PARAM_BIND_TYPE: /* 18 */
- case SQL_ATTR_PARAM_OPERATION_PTR: /* 19 */
- case SQL_ATTR_ROW_BIND_OFFSET_PTR: /* 23 */
- case SQL_ATTR_ROW_OPERATION_PTR: /* 24 */
+ case SQL_ATTR_PARAM_BIND_TYPE: /* 18 */
+ case SQL_ATTR_PARAM_OPERATION_PTR: /* 19 */
+ case SQL_ATTR_ROW_BIND_OFFSET_PTR: /* 23 */
+ case SQL_ATTR_ROW_OPERATION_PTR: /* 24 */
stmt->errornumber = STMT_INVALID_OPTION_IDENTIFIER;
stmt->errormsg = "Unsupported statement option (Set)";
SC_log_error(func, "", stmt);
return SQL_ERROR;
-
- case SQL_ATTR_FETCH_BOOKMARK_PTR: /* 16 */
+
+ case SQL_ATTR_FETCH_BOOKMARK_PTR: /* 16 */
stmt->options.bookmark_ptr = Value;
+
break;
case SQL_ATTR_ROW_STATUS_PTR: /* 25 */
stmt->options.rowStatusArray = (SQLUSMALLINT *) Value;
+
break;
- case SQL_ATTR_ROWS_FETCHED_PTR: /* 26 */
+ case SQL_ATTR_ROWS_FETCHED_PTR: /* 26 */
stmt->options.rowsFetched = (SQLUINTEGER *) Value;
+
break;
- case SQL_ATTR_ROW_ARRAY_SIZE: /* 27 */
+ case SQL_ATTR_ROW_ARRAY_SIZE: /* 27 */
stmt->options.rowset_size = (SQLUINTEGER) Value;
+
break;
- default:
+ default:
return PGAPI_SetStmtOption(StatementHandle, (UWORD) Attribute, (UDWORD) Value);
}
return SQL_SUCCESS;
(*(((UWORD*) (pfExists)) + ((uwAPI) >> 4)) \
|= (1 << ((uwAPI) & 0x000F)) \
)
-RETCODE SQL_API
-PGAPI_GetFunctions30(HDBC hdbc, UWORD fFunction, UWORD FAR *pfExists)
+RETCODE SQL_API
+PGAPI_GetFunctions30(HDBC hdbc, UWORD fFunction, UWORD FAR * pfExists)
{
if (fFunction != SQL_API_ODBC3_ALL_FUNCTIONS)
return SQL_ERROR;
/* SQL_FUNC_ESET(pfExists, SQL_API_SQLALLOCCONNECT); 1 deprecated */
/* SQL_FUNC_ESET(pfExists, SQL_API_SQLALLOCENV); 2 deprecated */
/* SQL_FUNC_ESET(pfExists, SQL_API_SQLALLOCSTMT); 3 deprecated */
- /* for (i = SQL_API_SQLBINDCOL; i <= 23; i++)
- SQL_FUNC_ESET(pfExists, i); */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLBINDCOL); /* 4 */
+
+ /*
+ * for (i = SQL_API_SQLBINDCOL; i <= 23; i++) SQL_FUNC_ESET(pfExists,
+ * i);
+ */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLBINDCOL); /* 4 */
SQL_FUNC_ESET(pfExists, SQL_API_SQLCANCEL); /* 5 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLCOLATTRIBUTE); /* 6 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLCONNECT); /* 7 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLDESCRIBECOL); /* 8 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLDISCONNECT); /* 9 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLCOLATTRIBUTE); /* 6 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLCONNECT); /* 7 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLDESCRIBECOL); /* 8 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLDISCONNECT); /* 9 */
/* SQL_FUNC_ESET(pfExists, SQL_API_SQLERROR); 10 deprecated */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLEXECDIRECT); /* 11 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLEXECUTE); /* 12 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLFETCH); /* 13 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLEXECDIRECT); /* 11 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLEXECUTE); /* 12 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLFETCH); /* 13 */
/* SQL_FUNC_ESET(pfExists, SQL_API_SQLFREECONNECT); 14 deprecated */
/* SQL_FUNC_ESET(pfExists, SQL_API_SQLFREEENV); 15 deprecated */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLFREESTMT); /* 16 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLGETCURSORNAME); /* 17 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLNUMRESULTCOLS); /* 18 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLPREPARE); /* 19 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLROWCOUNT); /* 20 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLSETCURSORNAME); /* 21 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLFREESTMT); /* 16 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLGETCURSORNAME); /* 17 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLNUMRESULTCOLS); /* 18 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLPREPARE); /* 19 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLROWCOUNT); /* 20 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLSETCURSORNAME); /* 21 */
/* SQL_FUNC_ESET(pfExists, SQL_API_SQLSETPARAM); 22 deprecated */
/* SQL_FUNC_ESET(pfExists, SQL_API_SQLTRANSACT); 23 deprecated */
- /*for (i = 40; i < SQL_API_SQLEXTENDEDFETCH; i++)
- SQL_FUNC_ESET(pfExists, i);*/
- SQL_FUNC_ESET(pfExists, SQL_API_SQLCOLUMNS); /* 40 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLDRIVERCONNECT); /* 41 */
+
+ /*
+ * for (i = 40; i < SQL_API_SQLEXTENDEDFETCH; i++)
+ * SQL_FUNC_ESET(pfExists, i);
+ */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLCOLUMNS); /* 40 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLDRIVERCONNECT); /* 41 */
/* SQL_FUNC_ESET(pfExists, SQL_API_SQLGETCONNECTOPTION); 42 deprecated */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDATA); /* 43 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLGETFUNCTIONS); /* 44 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLGETINFO); /* 45 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDATA); /* 43 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLGETFUNCTIONS); /* 44 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLGETINFO); /* 45 */
/* SQL_FUNC_ESET(pfExists, SQL_API_SQLGETSTMTOPTION); 46 deprecated */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLGETTYPEINFO); /* 47 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLPARAMDATA); /* 48 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLPUTDATA); /* 49 */
- /* SQL_FUNC_ESET(pfExists, SQL_API_SQLSETCONNECTIONOPTION); 50 deprecated */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLGETTYPEINFO); /* 47 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLPARAMDATA); /* 48 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLPUTDATA); /* 49 */
+
+ /*
+ * SQL_FUNC_ESET(pfExists, SQL_API_SQLSETCONNECTIONOPTION); 50
+ * deprecated
+ */
/* SQL_FUNC_ESET(pfExists, SQL_API_SQLSETSTMTOPTION); 51 deprecated */
SQL_FUNC_ESET(pfExists, SQL_API_SQLSPECIALCOLUMNS); /* 52 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLSTATISTICS); /* 53 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLSTATISTICS); /* 53 */
SQL_FUNC_ESET(pfExists, SQL_API_SQLTABLES); /* 54 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLBROWSECONNECT); /* 55 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLCOLUMNPRIVILEGES); /* 56 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLDATASOURCES); /* 57 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLDESCRIBEPARAM); /* 58 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLBROWSECONNECT); /* 55 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLCOLUMNPRIVILEGES); /* 56 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLDATASOURCES); /* 57 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLDESCRIBEPARAM); /* 58 */
/* SQL_FUNC_ESET(pfExists, SQL_API_SQLEXTENDEDFETCH); 59 deprecated */
- /*for (++i; i < SQL_API_SQLBINDPARAMETER; i++)
- SQL_FUNC_ESET(pfExists, i);*/
- SQL_FUNC_ESET(pfExists, SQL_API_SQLFOREIGNKEYS); /* 60 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLMORERESULTS); /* 61 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLNATIVESQL); /* 62 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLNUMPARAMS); /* 63 */
+
+ /*
+ * for (++i; i < SQL_API_SQLBINDPARAMETER; i++)
+ * SQL_FUNC_ESET(pfExists, i);
+ */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLFOREIGNKEYS); /* 60 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLMORERESULTS); /* 61 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLNATIVESQL); /* 62 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLNUMPARAMS); /* 63 */
/* SQL_FUNC_ESET(pfExists, SQL_API_SQLPARAMOPTIONS); 64 deprecated */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLPRIMARYKEYS); /* 65 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLPROCEDURECOLUMNS); /* 66 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLPROCEDURES); /* 67 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLPRIMARYKEYS); /* 65 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLPROCEDURECOLUMNS); /* 66 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLPROCEDURES); /* 67 */
SQL_FUNC_ESET(pfExists, SQL_API_SQLSETPOS); /* 68 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLSETSCROLLOPTIONS); /* 69 deprecated */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLTABLEPRIVILEGES); /* 70 */
- /*SQL_FUNC_ESET(pfExists, SQL_API_SQLDRIVERS);*/ /* 71 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLBINDPARAMETER); /* 72 */
-
- SQL_FUNC_ESET(pfExists, SQL_API_SQLALLOCHANDLE); /* 1001 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLBINDPARAM); /* 1002 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLCLOSECURSOR); /* 1003 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLCOPYDESC);/* 1004 not implemented yet */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLENDTRAN); /* 1005 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLFREEHANDLE); /* 1006 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLSETSCROLLOPTIONS); /* 69 deprecated */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLTABLEPRIVILEGES); /* 70 */
+ /* SQL_FUNC_ESET(pfExists, SQL_API_SQLDRIVERS); *//* 71 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLBINDPARAMETER); /* 72 */
+
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLALLOCHANDLE); /* 1001 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLBINDPARAM); /* 1002 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLCLOSECURSOR); /* 1003 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLCOPYDESC); /* 1004 not implemented
+ * yet */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLENDTRAN); /* 1005 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLFREEHANDLE); /* 1006 */
SQL_FUNC_ESET(pfExists, SQL_API_SQLGETCONNECTATTR); /* 1007 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDESCFIELD);/* 1008 not implemented yet */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDESCREC);/* 1009 not implemented yet */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDIAGFIELD);/* 1010 not implemented yet */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDIAGREC); /* 1011 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLGETENVATTR); /* 1012 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLGETSTMTATTR); /* 1014 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDESCFIELD); /* 1008 not implemented
+ * yet */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDESCREC); /* 1009 not implemented
+ * yet */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDIAGFIELD); /* 1010 not implemented
+ * yet */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDIAGREC); /* 1011 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLGETENVATTR); /* 1012 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLGETSTMTATTR); /* 1014 */
SQL_FUNC_ESET(pfExists, SQL_API_SQLSETCONNECTATTR); /* 1016 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLSETDESCFIELD); /* 1017 not implemeted yet */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLSETDESCREC); /* 1018 not implemented yet */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLSETENVATTR); /* 1019 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLSETSTMTATTR); /* 1020 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLFETCHSCROLL); /* 1021 */
- SQL_FUNC_ESET(pfExists, SQL_API_SQLBULKOPERATIONS);/* 24 not implemented yet */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLSETDESCFIELD); /* 1017 not implemeted
+ * yet */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLSETDESCREC); /* 1018 not implemented
+ * yet */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLSETENVATTR); /* 1019 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLSETSTMTATTR); /* 1020 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLFETCHSCROLL); /* 1021 */
+ SQL_FUNC_ESET(pfExists, SQL_API_SQLBULKOPERATIONS); /* 24 not implemented
+ * yet */
return SQL_SUCCESS;
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_GetInfo30(HDBC hdbc, UWORD fInfoType, PTR rgbInfoValue,
- SWORD cbInfoValueMax, SWORD FAR *pcbInfoValue)
+ SWORD cbInfoValueMax, SWORD FAR * pcbInfoValue)
{
static char *func = "PGAPI_GetInfo30";
ConnectionClass *conn = (ConnectionClass *) hdbc;
- char *p = NULL;
- int len = 0, value = 0;
- RETCODE result;
+ char *p = NULL;
+ int len = 0,
+ value = 0;
+ RETCODE result;
switch (fInfoType)
{
-RETCODE set_statement_option(ConnectionClass *conn,
- StatementClass *stmt,
+RETCODE set_statement_option(ConnectionClass * conn,
+ StatementClass * stmt,
UWORD fOption,
UDWORD vParam);
RETCODE
-set_statement_option(ConnectionClass *conn,
- StatementClass *stmt,
+set_statement_option(ConnectionClass * conn,
+ StatementClass * stmt,
UWORD fOption,
UDWORD vParam)
{
static char *func = "set_statement_option";
char changed = FALSE;
- ConnInfo *ci = NULL;
+ ConnInfo *ci = NULL;
if (conn)
ci = &(conn->connInfo);
if (ci->drivers.lie || vParam == SQL_CONCUR_READ_ONLY || vParam == SQL_CONCUR_ROWVER)
{
if (conn)
- conn->stmtOptions.scroll_concurrency = vParam;
- if (stmt)
- stmt->options.scroll_concurrency = vParam;
+ conn->stmtOptions.scroll_concurrency = vParam;
+ if (stmt)
+ stmt->options.scroll_concurrency = vParam;
}
- else
+ else
{
- if (conn)
- conn->stmtOptions.scroll_concurrency = SQL_CONCUR_ROWVER;
- if (stmt)
- stmt->options.scroll_concurrency = SQL_CONCUR_ROWVER;
- changed = TRUE;
- }
- break;
+ if (conn)
+ conn->stmtOptions.scroll_concurrency = SQL_CONCUR_ROWVER;
+ if (stmt)
+ stmt->options.scroll_concurrency = SQL_CONCUR_ROWVER;
+ changed = TRUE;
+ }
+ break;
case SQL_CURSOR_TYPE:
/* Implements only SQL_AUTOCOMMIT */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_SetConnectOption(
- HDBC hdbc,
- UWORD fOption,
- UDWORD vParam)
+ HDBC hdbc,
+ UWORD fOption,
+ UDWORD vParam)
{
static char *func = "PGAPI_SetConnectOption";
ConnectionClass *conn = (ConnectionClass *) hdbc;
switch (fOption)
{
-
/*
* Statement Options (apply to all stmts on the connection and
* become defaults for new stmts)
/* This function just can tell you whether you are in Autcommit mode or not */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_GetConnectOption(
- HDBC hdbc,
- UWORD fOption,
- PTR pvParam)
+ HDBC hdbc,
+ UWORD fOption,
+ PTR pvParam)
{
static char *func = "PGAPI_GetConnectOption";
ConnectionClass *conn = (ConnectionClass *) hdbc;
- ConnInfo *ci = &(conn->connInfo);
+ ConnInfo *ci = &(conn->connInfo);
mylog("%s: entering...\n", func);
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_SetStmtOption(
- HSTMT hstmt,
- UWORD fOption,
- UDWORD vParam)
+ HSTMT hstmt,
+ UWORD fOption,
+ UDWORD vParam)
{
static char *func = "PGAPI_SetStmtOption";
StatementClass *stmt = (StatementClass *) hstmt;
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_GetStmtOption(
- HSTMT hstmt,
- UWORD fOption,
- PTR pvParam)
+ HSTMT hstmt,
+ UWORD fOption,
+ PTR pvParam)
{
static char *func = "PGAPI_GetStmtOption";
StatementClass *stmt = (StatementClass *) hstmt;
QResultClass *res;
- ConnInfo *ci = &(SC_get_conn(stmt)->connInfo);
+ ConnInfo *ci = &(SC_get_conn(stmt)->connInfo);
mylog("%s: entering...\n", func);
#define COL_INCR 16
char *getNextToken(char *s, char *token, int smax, char *delim, char *quote, char *dquote, char *numeric);
-void getColInfo(COL_INFO *col_info, FIELD_INFO *fi, int k);
-char searchColInfo(COL_INFO *col_info, FIELD_INFO *fi);
+void getColInfo(COL_INFO * col_info, FIELD_INFO * fi, int k);
+char searchColInfo(COL_INFO * col_info, FIELD_INFO * fi);
char *
token[out++] = s[i++];
continue;
}
-#endif
+#endif
/* Handle quoted stuff */
if (out == 0 && (s[i] == '\"' || s[i] == '\''))
{
token[out++] = s[i++];
continue;
}
-#endif
+#endif
if (s[i] == qc && !in_escape)
break;
if (s[i] == '\\' && !in_escape)
- {
in_escape = TRUE;
- }
else
{
in_escape = FALSE;
#endif
void
-getColInfo(COL_INFO *col_info, FIELD_INFO *fi, int k)
+getColInfo(COL_INFO * col_info, FIELD_INFO * fi, int k)
{
- char *str;
+ char *str;
+
if (fi->name[0] == '\0')
strcpy(fi->name, QR_get_value_manual(col_info->result, k, 3));
char
-searchColInfo(COL_INFO *col_info, FIELD_INFO *fi)
+searchColInfo(COL_INFO * col_info, FIELD_INFO * fi)
{
int k,
cmp;
char
-parse_statement(StatementClass *stmt)
+parse_statement(StatementClass * stmt)
{
static char *func = "parse_statement";
char token[256];
dquote,
numeric,
unquoted;
- char *ptr, *pptr = NULL;
+ char *ptr,
+ *pptr = NULL;
char in_select = FALSE,
in_distinct = FALSE,
in_on = FALSE,
in_select = FALSE;
in_from = TRUE;
if (!from_found &&
- (!strnicmp(pptr, "from", 4)))
+ (!strnicmp(pptr, "from", 4)))
{
mylog("First ");
from_found = TRUE;
if (unquoted && blevel == 0)
{
if ((!stricmp(token, "where") ||
- !stricmp(token, "union") ||
- !stricmp(token, "intersect") ||
- !stricmp(token, "except") ||
- !stricmp(token, "order") ||
- !stricmp(token, "group") ||
- !stricmp(token, "having")))
+ !stricmp(token, "union") ||
+ !stricmp(token, "intersect") ||
+ !stricmp(token, "except") ||
+ !stricmp(token, "order") ||
+ !stricmp(token, "group") ||
+ !stricmp(token, "having")))
{
in_select = FALSE;
in_from = FALSE;
in_where = TRUE;
if (!first_where &&
- (!stricmp(token, "where")))
+ (!stricmp(token, "where")))
first_where = ptr - stmt->statement;
-
+
mylog("WHERE...\n");
break;
}
if (quote)
{
fi[stmt->nfld++]->quote = TRUE;
-in_expr = TRUE;
+ in_expr = TRUE;
continue;
}
else if (numeric)
if ((unsigned char) *ptr >= 0x80)
ptr++;
else
-#endif /* MULTIBYTE */
- *ptr = tolower((unsigned char) *ptr);
+#endif /* MULTIBYTE */
+ *ptr = tolower((unsigned char) *ptr);
}
}
mylog("got table = '%s'\n", ti[stmt->ntab]->name);
else if (fi[i]->quote)
{ /* handle as text */
fi[i]->ti = NULL;
+
/*
- fi[i]->type = PG_TYPE_TEXT;
- fi[i]->precision = 0;
- the following may be better */
+ * fi[i]->type = PG_TYPE_TEXT; fi[i]->precision = 0; the
+ * following may be better
+ */
fi[i]->type = PG_TYPE_UNKNOWN;
fi[i]->precision = 254;
continue;
*
*-------
*/
-#ifndef _PG_API_FUNC_H__
-#define _PG_API_FUNC_H__
+#ifndef _PG_API_FUNC_H__
+#define _PG_API_FUNC_H__
#include "psqlodbc.h"
#include <stdio.h>
#include <string.h>
-RETCODE SQL_API PGAPI_AllocConnect(HENV EnvironmentHandle,
- HDBC FAR *ConnectionHandle);
-RETCODE SQL_API PGAPI_AllocEnv(HENV FAR *EnvironmentHandle);
-RETCODE SQL_API PGAPI_AllocStmt(HDBC ConnectionHandle,
- HSTMT *StatementHandle);
-RETCODE SQL_API PGAPI_BindCol(HSTMT StatementHandle,
- SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
- PTR TargetValue, SQLINTEGER BufferLength,
- SQLINTEGER *StrLen_or_Ind);
-RETCODE SQL_API PGAPI_Cancel(HSTMT StatementHandle);
-RETCODE SQL_API PGAPI_Columns(HSTMT StatementHandle,
- SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
- SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
- SQLCHAR *TableName, SQLSMALLINT NameLength3,
- SQLCHAR *ColumnName, SQLSMALLINT NameLength4);
-RETCODE SQL_API PGAPI_Connect(HDBC ConnectionHandle,
- SQLCHAR *ServerName, SQLSMALLINT NameLength1,
- SQLCHAR *UserName, SQLSMALLINT NameLength2,
- SQLCHAR *Authentication, SQLSMALLINT NameLength3);
-RETCODE SQL_API PGAPI_DriverConnect(HDBC hdbc, HWND hwnd,
- UCHAR FAR *szConnStrIn, SWORD cbConnStrIn,
- UCHAR FAR *szConnStrOut, SWORD cbConnStrOutMax,
- SWORD FAR *pcbConnStrOut, UWORD fDriverCompletion);
+RETCODE SQL_API PGAPI_AllocConnect(HENV EnvironmentHandle,
+ HDBC FAR * ConnectionHandle);
+RETCODE SQL_API PGAPI_AllocEnv(HENV FAR * EnvironmentHandle);
+RETCODE SQL_API PGAPI_AllocStmt(HDBC ConnectionHandle,
+ HSTMT * StatementHandle);
+RETCODE SQL_API PGAPI_BindCol(HSTMT StatementHandle,
+ SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
+ PTR TargetValue, SQLINTEGER BufferLength,
+ SQLINTEGER * StrLen_or_Ind);
+RETCODE SQL_API PGAPI_Cancel(HSTMT StatementHandle);
+RETCODE SQL_API PGAPI_Columns(HSTMT StatementHandle,
+ SQLCHAR * CatalogName, SQLSMALLINT NameLength1,
+ SQLCHAR * SchemaName, SQLSMALLINT NameLength2,
+ SQLCHAR * TableName, SQLSMALLINT NameLength3,
+ SQLCHAR * ColumnName, SQLSMALLINT NameLength4);
+RETCODE SQL_API PGAPI_Connect(HDBC ConnectionHandle,
+ SQLCHAR * ServerName, SQLSMALLINT NameLength1,
+ SQLCHAR * UserName, SQLSMALLINT NameLength2,
+ SQLCHAR * Authentication, SQLSMALLINT NameLength3);
+RETCODE SQL_API PGAPI_DriverConnect(HDBC hdbc, HWND hwnd,
+ UCHAR FAR * szConnStrIn, SWORD cbConnStrIn,
+ UCHAR FAR * szConnStrOut, SWORD cbConnStrOutMax,
+ SWORD FAR * pcbConnStrOut, UWORD fDriverCompletion);
RETCODE SQL_API PGAPI_BrowseConnect(HDBC hdbc,
- SQLCHAR *szConnStrIn, SQLSMALLINT cbConnStrIn,
- SQLCHAR *szConnStrOut, SQLSMALLINT cbConnStrOutMax,
- SQLSMALLINT *pcbConnStrOut);
-RETCODE SQL_API PGAPI_DataSources(HENV EnvironmentHandle,
- SQLUSMALLINT Direction, SQLCHAR *ServerName,
- SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1,
- SQLCHAR *Description, SQLSMALLINT BufferLength2,
- SQLSMALLINT *NameLength2);
-RETCODE SQL_API PGAPI_DescribeCol(HSTMT StatementHandle,
- SQLUSMALLINT ColumnNumber, SQLCHAR *ColumnName,
- SQLSMALLINT BufferLength, SQLSMALLINT *NameLength,
- SQLSMALLINT *DataType, SQLUINTEGER *ColumnSize,
- SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable);
-RETCODE SQL_API PGAPI_Disconnect(HDBC ConnectionHandle);
-RETCODE SQL_API PGAPI_Error(HENV EnvironmentHandle,
- HDBC ConnectionHandle, HSTMT StatementHandle,
- SQLCHAR *Sqlstate, SQLINTEGER *NativeError,
- SQLCHAR *MessageText, SQLSMALLINT BufferLength,
- SQLSMALLINT *TextLength);
-RETCODE SQL_API PGAPI_ExecDirect(HSTMT StatementHandle,
- SQLCHAR *StatementText, SQLINTEGER TextLength);
-RETCODE SQL_API PGAPI_Execute(HSTMT StatementHandle);
-RETCODE SQL_API PGAPI_Fetch(HSTMT StatementHandle);
-RETCODE SQL_API PGAPI_FreeConnect(HDBC ConnectionHandle);
-RETCODE SQL_API PGAPI_FreeEnv(HENV EnvironmentHandle);
-RETCODE SQL_API PGAPI_FreeStmt(HSTMT StatementHandle,
- SQLUSMALLINT Option);
-RETCODE SQL_API PGAPI_GetConnectOption(HDBC ConnectionHandle,
- SQLUSMALLINT Option, PTR Value);
-RETCODE SQL_API PGAPI_GetCursorName(HSTMT StatementHandle,
- SQLCHAR *CursorName, SQLSMALLINT BufferLength,
- SQLSMALLINT *NameLength);
-RETCODE SQL_API PGAPI_GetData(HSTMT StatementHandle,
- SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
- PTR TargetValue, SQLINTEGER BufferLength,
- SQLINTEGER *StrLen_or_Ind);
-RETCODE SQL_API PGAPI_GetFunctions(HDBC ConnectionHandle,
- SQLUSMALLINT FunctionId, SQLUSMALLINT *Supported);
-RETCODE SQL_API PGAPI_GetFunctions30(HDBC ConnectionHandle,
- SQLUSMALLINT FunctionId, SQLUSMALLINT *Supported);
-RETCODE SQL_API PGAPI_GetInfo(HDBC ConnectionHandle,
- SQLUSMALLINT InfoType, PTR InfoValue,
- SQLSMALLINT BufferLength, SQLSMALLINT *StringLength);
-RETCODE SQL_API PGAPI_GetInfo30(HDBC ConnectionHandle,
- SQLUSMALLINT InfoType, PTR InfoValue,
- SQLSMALLINT BufferLength, SQLSMALLINT *StringLength);
-RETCODE SQL_API PGAPI_GetStmtOption(HSTMT StatementHandle,
- SQLUSMALLINT Option, PTR Value);
-RETCODE SQL_API PGAPI_GetTypeInfo(HSTMT StatementHandle,
- SQLSMALLINT DataType);
-RETCODE SQL_API PGAPI_NumResultCols(HSTMT StatementHandle,
- SQLSMALLINT *ColumnCount);
-RETCODE SQL_API PGAPI_ParamData(HSTMT StatementHandle,
- PTR *Value);
-RETCODE SQL_API PGAPI_Prepare(HSTMT StatementHandle,
- SQLCHAR *StatementText, SQLINTEGER TextLength);
-RETCODE SQL_API PGAPI_PutData(HSTMT StatementHandle,
- PTR Data, SQLINTEGER StrLen_or_Ind);
-RETCODE SQL_API PGAPI_RowCount(HSTMT StatementHandle,
- SQLINTEGER *RowCount);
-RETCODE SQL_API PGAPI_SetConnectOption(HDBC ConnectionHandle,
- SQLUSMALLINT Option, SQLUINTEGER Value);
-RETCODE SQL_API PGAPI_SetCursorName(HSTMT StatementHandle,
- SQLCHAR *CursorName, SQLSMALLINT NameLength);
-RETCODE SQL_API PGAPI_SetParam(HSTMT StatementHandle,
- SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
- SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision,
- SQLSMALLINT ParameterScale, PTR ParameterValue,
- SQLINTEGER *StrLen_or_Ind);
-RETCODE SQL_API PGAPI_SetStmtOption(HSTMT StatementHandle,
- SQLUSMALLINT Option, SQLUINTEGER Value);
-RETCODE SQL_API PGAPI_SpecialColumns(HSTMT StatementHandle,
- SQLUSMALLINT IdentifierType, SQLCHAR *CatalogName,
- SQLSMALLINT NameLength1, SQLCHAR *SchemaName,
- SQLSMALLINT NameLength2, SQLCHAR *TableName,
- SQLSMALLINT NameLength3, SQLUSMALLINT Scope,
- SQLUSMALLINT Nullable);
-RETCODE SQL_API PGAPI_Statistics(HSTMT StatementHandle,
- SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
- SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
- SQLCHAR *TableName, SQLSMALLINT NameLength3,
- SQLUSMALLINT Unique, SQLUSMALLINT Reserved);
-RETCODE SQL_API PGAPI_Tables(HSTMT StatementHandle,
- SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
- SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
- SQLCHAR *TableName, SQLSMALLINT NameLength3,
- SQLCHAR *TableType, SQLSMALLINT NameLength4);
-RETCODE SQL_API PGAPI_Transact(HENV EnvironmentHandle,
- HDBC ConnectionHandle, SQLUSMALLINT CompletionType);
+ SQLCHAR * szConnStrIn, SQLSMALLINT cbConnStrIn,
+ SQLCHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax,
+ SQLSMALLINT * pcbConnStrOut);
+RETCODE SQL_API PGAPI_DataSources(HENV EnvironmentHandle,
+ SQLUSMALLINT Direction, SQLCHAR * ServerName,
+ SQLSMALLINT BufferLength1, SQLSMALLINT * NameLength1,
+ SQLCHAR * Description, SQLSMALLINT BufferLength2,
+ SQLSMALLINT * NameLength2);
+RETCODE SQL_API PGAPI_DescribeCol(HSTMT StatementHandle,
+ SQLUSMALLINT ColumnNumber, SQLCHAR * ColumnName,
+ SQLSMALLINT BufferLength, SQLSMALLINT * NameLength,
+ SQLSMALLINT * DataType, SQLUINTEGER * ColumnSize,
+ SQLSMALLINT * DecimalDigits, SQLSMALLINT * Nullable);
+RETCODE SQL_API PGAPI_Disconnect(HDBC ConnectionHandle);
+RETCODE SQL_API PGAPI_Error(HENV EnvironmentHandle,
+ HDBC ConnectionHandle, HSTMT StatementHandle,
+ SQLCHAR * Sqlstate, SQLINTEGER * NativeError,
+ SQLCHAR * MessageText, SQLSMALLINT BufferLength,
+ SQLSMALLINT * TextLength);
+RETCODE SQL_API PGAPI_ExecDirect(HSTMT StatementHandle,
+ SQLCHAR * StatementText, SQLINTEGER TextLength);
+RETCODE SQL_API PGAPI_Execute(HSTMT StatementHandle);
+RETCODE SQL_API PGAPI_Fetch(HSTMT StatementHandle);
+RETCODE SQL_API PGAPI_FreeConnect(HDBC ConnectionHandle);
+RETCODE SQL_API PGAPI_FreeEnv(HENV EnvironmentHandle);
+RETCODE SQL_API PGAPI_FreeStmt(HSTMT StatementHandle,
+ SQLUSMALLINT Option);
+RETCODE SQL_API PGAPI_GetConnectOption(HDBC ConnectionHandle,
+ SQLUSMALLINT Option, PTR Value);
+RETCODE SQL_API PGAPI_GetCursorName(HSTMT StatementHandle,
+ SQLCHAR * CursorName, SQLSMALLINT BufferLength,
+ SQLSMALLINT * NameLength);
+RETCODE SQL_API PGAPI_GetData(HSTMT StatementHandle,
+ SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
+ PTR TargetValue, SQLINTEGER BufferLength,
+ SQLINTEGER * StrLen_or_Ind);
+RETCODE SQL_API PGAPI_GetFunctions(HDBC ConnectionHandle,
+ SQLUSMALLINT FunctionId, SQLUSMALLINT * Supported);
+RETCODE SQL_API PGAPI_GetFunctions30(HDBC ConnectionHandle,
+ SQLUSMALLINT FunctionId, SQLUSMALLINT * Supported);
+RETCODE SQL_API PGAPI_GetInfo(HDBC ConnectionHandle,
+ SQLUSMALLINT InfoType, PTR InfoValue,
+ SQLSMALLINT BufferLength, SQLSMALLINT * StringLength);
+RETCODE SQL_API PGAPI_GetInfo30(HDBC ConnectionHandle,
+ SQLUSMALLINT InfoType, PTR InfoValue,
+ SQLSMALLINT BufferLength, SQLSMALLINT * StringLength);
+RETCODE SQL_API PGAPI_GetStmtOption(HSTMT StatementHandle,
+ SQLUSMALLINT Option, PTR Value);
+RETCODE SQL_API PGAPI_GetTypeInfo(HSTMT StatementHandle,
+ SQLSMALLINT DataType);
+RETCODE SQL_API PGAPI_NumResultCols(HSTMT StatementHandle,
+ SQLSMALLINT * ColumnCount);
+RETCODE SQL_API PGAPI_ParamData(HSTMT StatementHandle,
+ PTR * Value);
+RETCODE SQL_API PGAPI_Prepare(HSTMT StatementHandle,
+ SQLCHAR * StatementText, SQLINTEGER TextLength);
+RETCODE SQL_API PGAPI_PutData(HSTMT StatementHandle,
+ PTR Data, SQLINTEGER StrLen_or_Ind);
+RETCODE SQL_API PGAPI_RowCount(HSTMT StatementHandle,
+ SQLINTEGER * RowCount);
+RETCODE SQL_API PGAPI_SetConnectOption(HDBC ConnectionHandle,
+ SQLUSMALLINT Option, SQLUINTEGER Value);
+RETCODE SQL_API PGAPI_SetCursorName(HSTMT StatementHandle,
+ SQLCHAR * CursorName, SQLSMALLINT NameLength);
+RETCODE SQL_API PGAPI_SetParam(HSTMT StatementHandle,
+ SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
+ SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision,
+ SQLSMALLINT ParameterScale, PTR ParameterValue,
+ SQLINTEGER * StrLen_or_Ind);
+RETCODE SQL_API PGAPI_SetStmtOption(HSTMT StatementHandle,
+ SQLUSMALLINT Option, SQLUINTEGER Value);
+RETCODE SQL_API PGAPI_SpecialColumns(HSTMT StatementHandle,
+ SQLUSMALLINT IdentifierType, SQLCHAR * CatalogName,
+ SQLSMALLINT NameLength1, SQLCHAR * SchemaName,
+ SQLSMALLINT NameLength2, SQLCHAR * TableName,
+ SQLSMALLINT NameLength3, SQLUSMALLINT Scope,
+ SQLUSMALLINT Nullable);
+RETCODE SQL_API PGAPI_Statistics(HSTMT StatementHandle,
+ SQLCHAR * CatalogName, SQLSMALLINT NameLength1,
+ SQLCHAR * SchemaName, SQLSMALLINT NameLength2,
+ SQLCHAR * TableName, SQLSMALLINT NameLength3,
+ SQLUSMALLINT Unique, SQLUSMALLINT Reserved);
+RETCODE SQL_API PGAPI_Tables(HSTMT StatementHandle,
+ SQLCHAR * CatalogName, SQLSMALLINT NameLength1,
+ SQLCHAR * SchemaName, SQLSMALLINT NameLength2,
+ SQLCHAR * TableName, SQLSMALLINT NameLength3,
+ SQLCHAR * TableType, SQLSMALLINT NameLength4);
+RETCODE SQL_API PGAPI_Transact(HENV EnvironmentHandle,
+ HDBC ConnectionHandle, SQLUSMALLINT CompletionType);
RETCODE SQL_API PGAPI_ColAttributes(
- HSTMT hstmt,
- SQLUSMALLINT icol,
- SQLUSMALLINT fDescType,
- PTR rgbDesc,
- SQLSMALLINT cbDescMax,
- SQLSMALLINT *pcbDesc,
- SQLINTEGER *pfDesc);
+ HSTMT hstmt,
+ SQLUSMALLINT icol,
+ SQLUSMALLINT fDescType,
+ PTR rgbDesc,
+ SQLSMALLINT cbDescMax,
+ SQLSMALLINT * pcbDesc,
+ SQLINTEGER * pfDesc);
RETCODE SQL_API PGAPI_ColumnPrivileges(
- HSTMT hstmt,
- SQLCHAR *szCatalogName,
- SQLSMALLINT cbCatalogName,
- SQLCHAR *szSchemaName,
- SQLSMALLINT cbSchemaName,
- SQLCHAR *szTableName,
- SQLSMALLINT cbTableName,
- SQLCHAR *szColumnName,
- SQLSMALLINT cbColumnName);
+ HSTMT hstmt,
+ SQLCHAR * szCatalogName,
+ SQLSMALLINT cbCatalogName,
+ SQLCHAR * szSchemaName,
+ SQLSMALLINT cbSchemaName,
+ SQLCHAR * szTableName,
+ SQLSMALLINT cbTableName,
+ SQLCHAR * szColumnName,
+ SQLSMALLINT cbColumnName);
RETCODE SQL_API PGAPI_DescribeParam(
- HSTMT hstmt,
- SQLUSMALLINT ipar,
- SQLSMALLINT *pfSqlType,
- SQLUINTEGER *pcbParamDef,
- SQLSMALLINT *pibScale,
- SQLSMALLINT *pfNullable);
+ HSTMT hstmt,
+ SQLUSMALLINT ipar,
+ SQLSMALLINT * pfSqlType,
+ SQLUINTEGER * pcbParamDef,
+ SQLSMALLINT * pibScale,
+ SQLSMALLINT * pfNullable);
RETCODE SQL_API PGAPI_ExtendedFetch(
- HSTMT hstmt,
- SQLUSMALLINT fFetchType,
- SQLINTEGER irow,
- SQLUINTEGER *pcrow,
- SQLUSMALLINT *rgfRowStatus);
+ HSTMT hstmt,
+ SQLUSMALLINT fFetchType,
+ SQLINTEGER irow,
+ SQLUINTEGER * pcrow,
+ SQLUSMALLINT * rgfRowStatus);
RETCODE SQL_API PGAPI_ForeignKeys(
- HSTMT hstmt,
- SQLCHAR *szPkCatalogName,
- SQLSMALLINT cbPkCatalogName,
- SQLCHAR *szPkSchemaName,
- SQLSMALLINT cbPkSchemaName,
- SQLCHAR *szPkTableName,
- SQLSMALLINT cbPkTableName,
- SQLCHAR *szFkCatalogName,
- SQLSMALLINT cbFkCatalogName,
- SQLCHAR *szFkSchemaName,
- SQLSMALLINT cbFkSchemaName,
- SQLCHAR *szFkTableName,
- SQLSMALLINT cbFkTableName);
+ HSTMT hstmt,
+ SQLCHAR * szPkCatalogName,
+ SQLSMALLINT cbPkCatalogName,
+ SQLCHAR * szPkSchemaName,
+ SQLSMALLINT cbPkSchemaName,
+ SQLCHAR * szPkTableName,
+ SQLSMALLINT cbPkTableName,
+ SQLCHAR * szFkCatalogName,
+ SQLSMALLINT cbFkCatalogName,
+ SQLCHAR * szFkSchemaName,
+ SQLSMALLINT cbFkSchemaName,
+ SQLCHAR * szFkTableName,
+ SQLSMALLINT cbFkTableName);
RETCODE SQL_API PGAPI_MoreResults(
- HSTMT hstmt);
+ HSTMT hstmt);
RETCODE SQL_API PGAPI_NativeSql(
- HDBC hdbc,
- SQLCHAR *szSqlStrIn,
- SQLINTEGER cbSqlStrIn,
- SQLCHAR *szSqlStr,
- SQLINTEGER cbSqlStrMax,
- SQLINTEGER *pcbSqlStr);
+ HDBC hdbc,
+ SQLCHAR * szSqlStrIn,
+ SQLINTEGER cbSqlStrIn,
+ SQLCHAR * szSqlStr,
+ SQLINTEGER cbSqlStrMax,
+ SQLINTEGER * pcbSqlStr);
RETCODE SQL_API PGAPI_NumParams(
- HSTMT hstmt,
- SQLSMALLINT *pcpar);
+ HSTMT hstmt,
+ SQLSMALLINT * pcpar);
RETCODE SQL_API PGAPI_ParamOptions(
- HSTMT hstmt,
- SQLUINTEGER crow,
- SQLUINTEGER *pirow);
+ HSTMT hstmt,
+ SQLUINTEGER crow,
+ SQLUINTEGER * pirow);
RETCODE SQL_API PGAPI_PrimaryKeys(
- HSTMT hstmt,
- SQLCHAR *szCatalogName,
- SQLSMALLINT cbCatalogName,
- SQLCHAR *szSchemaName,
- SQLSMALLINT cbSchemaName,
- SQLCHAR *szTableName,
- SQLSMALLINT cbTableName);
+ HSTMT hstmt,
+ SQLCHAR * szCatalogName,
+ SQLSMALLINT cbCatalogName,
+ SQLCHAR * szSchemaName,
+ SQLSMALLINT cbSchemaName,
+ SQLCHAR * szTableName,
+ SQLSMALLINT cbTableName);
RETCODE SQL_API PGAPI_ProcedureColumns(
- HSTMT hstmt,
- SQLCHAR *szCatalogName,
- SQLSMALLINT cbCatalogName,
- SQLCHAR *szSchemaName,
- SQLSMALLINT cbSchemaName,
- SQLCHAR *szProcName,
- SQLSMALLINT cbProcName,
- SQLCHAR *szColumnName,
- SQLSMALLINT cbColumnName);
+ HSTMT hstmt,
+ SQLCHAR * szCatalogName,
+ SQLSMALLINT cbCatalogName,
+ SQLCHAR * szSchemaName,
+ SQLSMALLINT cbSchemaName,
+ SQLCHAR * szProcName,
+ SQLSMALLINT cbProcName,
+ SQLCHAR * szColumnName,
+ SQLSMALLINT cbColumnName);
RETCODE SQL_API PGAPI_Procedures(
- HSTMT hstmt,
- SQLCHAR *szCatalogName,
- SQLSMALLINT cbCatalogName,
- SQLCHAR *szSchemaName,
- SQLSMALLINT cbSchemaName,
- SQLCHAR *szProcName,
- SQLSMALLINT cbProcName);
+ HSTMT hstmt,
+ SQLCHAR * szCatalogName,
+ SQLSMALLINT cbCatalogName,
+ SQLCHAR * szSchemaName,
+ SQLSMALLINT cbSchemaName,
+ SQLCHAR * szProcName,
+ SQLSMALLINT cbProcName);
RETCODE SQL_API PGAPI_SetPos(
- HSTMT hstmt,
- SQLUSMALLINT irow,
- SQLUSMALLINT fOption,
- SQLUSMALLINT fLock);
+ HSTMT hstmt,
+ SQLUSMALLINT irow,
+ SQLUSMALLINT fOption,
+ SQLUSMALLINT fLock);
RETCODE SQL_API PGAPI_TablePrivileges(
- HSTMT hstmt,
- SQLCHAR *szCatalogName,
- SQLSMALLINT cbCatalogName,
- SQLCHAR *szSchemaName,
- SQLSMALLINT cbSchemaName,
- SQLCHAR *szTableName,
- SQLSMALLINT cbTableName);
+ HSTMT hstmt,
+ SQLCHAR * szCatalogName,
+ SQLSMALLINT cbCatalogName,
+ SQLCHAR * szSchemaName,
+ SQLSMALLINT cbSchemaName,
+ SQLCHAR * szTableName,
+ SQLSMALLINT cbTableName);
RETCODE SQL_API PGAPI_BindParameter(
- HSTMT hstmt,
- SQLUSMALLINT ipar,
- SQLSMALLINT fParamType,
- SQLSMALLINT fCType,
- SQLSMALLINT fSqlType,
- SQLUINTEGER cbColDef,
- SQLSMALLINT ibScale,
- PTR rgbValue,
- SQLINTEGER cbValueMax,
- SQLINTEGER *pcbValue);
+ HSTMT hstmt,
+ SQLUSMALLINT ipar,
+ SQLSMALLINT fParamType,
+ SQLSMALLINT fCType,
+ SQLSMALLINT fSqlType,
+ SQLUINTEGER cbColDef,
+ SQLSMALLINT ibScale,
+ PTR rgbValue,
+ SQLINTEGER cbValueMax,
+ SQLINTEGER * pcbValue);
RETCODE SQL_API PGAPI_SetScrollOptions(
- HSTMT hstmt,
- UWORD fConcurrency,
- SDWORD crowKeyset,
- UWORD crowRowset);
-#endif /* define_PG_API_FUNC_H__ */
+ HSTMT hstmt,
+ UWORD fConcurrency,
+ SDWORD crowKeyset,
+ UWORD crowRowset);
+#endif /* define_PG_API_FUNC_H__ */
-Int4 getCharPrecision(StatementClass *stmt, Int4 type, int col, int handle_unknown_size_as);
+Int4 getCharPrecision(StatementClass * stmt, Int4 type, int col, int handle_unknown_size_as);
/*
* these are the types we support. all of the pgtype_ functions should
Int4
-sqltype_to_pgtype(StatementClass *stmt, SWORD fSqlType)
+sqltype_to_pgtype(StatementClass * stmt, SWORD fSqlType)
{
Int4 pgType;
- ConnInfo *ci = &(SC_get_conn(stmt)->connInfo);
+ ConnInfo *ci = &(SC_get_conn(stmt)->connInfo);
switch (fSqlType)
{
* types that are unknown. All other pg routines in here return a suitable default.
*/
Int2
-pgtype_to_sqltype(StatementClass *stmt, Int4 type)
+pgtype_to_sqltype(StatementClass * stmt, Int4 type)
{
- ConnInfo *ci = &(SC_get_conn(stmt)->connInfo);
+ ConnInfo *ci = &(SC_get_conn(stmt)->connInfo);
+
switch (type)
{
case PG_TYPE_CHAR:
Int2
-pgtype_to_ctype(StatementClass *stmt, Int4 type)
+pgtype_to_ctype(StatementClass * stmt, Int4 type)
{
- ConnInfo *ci = &(SC_get_conn(stmt)->connInfo);
+ ConnInfo *ci = &(SC_get_conn(stmt)->connInfo);
+
switch (type)
{
case PG_TYPE_INT8:
char *
-pgtype_to_name(StatementClass *stmt, Int4 type)
+pgtype_to_name(StatementClass * stmt, Int4 type)
{
switch (type)
{
static Int2
-getNumericScale(StatementClass *stmt, Int4 type, int col)
+getNumericScale(StatementClass * stmt, Int4 type, int col)
{
Int4 atttypmod;
QResultClass *result;
static Int4
-getNumericPrecision(StatementClass *stmt, Int4 type, int col)
+getNumericPrecision(StatementClass * stmt, Int4 type, int col)
{
Int4 atttypmod;
QResultClass *result;
Int4
-getCharPrecision(StatementClass *stmt, Int4 type, int col, int handle_unknown_size_as)
+getCharPrecision(StatementClass * stmt, Int4 type, int col, int handle_unknown_size_as)
{
int p = -1,
maxsize;
QResultClass *result;
ColumnInfoClass *flds;
- ConnInfo *ci = &(SC_get_conn(stmt)->connInfo);
+ ConnInfo *ci = &(SC_get_conn(stmt)->connInfo);
mylog("getCharPrecision: type=%d, col=%d, unknown = %d\n", type, col, handle_unknown_size_as);
{
if (PG_VERSION_GE(SC_get_conn(stmt), 7.1))
maxsize = 0;
- else
+ else
maxsize = TEXT_FIELD_SIZE;
}
if (col < 0)
* This is used for functions SQLDescribeCol and SQLColAttributes.
*/
Int4
-pgtype_precision(StatementClass *stmt, Int4 type, int col, int handle_unknown_size_as)
+pgtype_precision(StatementClass * stmt, Int4 type, int col, int handle_unknown_size_as)
{
switch (type)
{
Int4
-pgtype_display_size(StatementClass *stmt, Int4 type, int col, int handle_unknown_size_as)
+pgtype_display_size(StatementClass * stmt, Int4 type, int col, int handle_unknown_size_as)
{
switch (type)
{
* override this length with the atttypmod length from pg_attribute
*/
Int4
-pgtype_length(StatementClass *stmt, Int4 type, int col, int handle_unknown_size_as)
+pgtype_length(StatementClass * stmt, Int4 type, int col, int handle_unknown_size_as)
{
switch (type)
{
case PG_TYPE_DATE:
case PG_TYPE_TIME:
- return 6; /* sizeof(DATE(TIME)_STRUCT) */
+ return 6; /* sizeof(DATE(TIME)_STRUCT) */
case PG_TYPE_ABSTIME:
case PG_TYPE_DATETIME:
case PG_TYPE_TIMESTAMP:
- return 16; /* sizeof(TIMESTAMP_STRUCT) */
+ return 16; /* sizeof(TIMESTAMP_STRUCT) */
/* Character types (and NUMERIC) use the default precision */
case PG_TYPE_VARCHAR:
else
#else
/* CR -> CR/LF */
- return 2 * pgtype_precision(stmt, type, col, handle_unknown_size_as);
-#endif /* MULTIBYTE */
+ return 2 * pgtype_precision(stmt, type, col, handle_unknown_size_as);
+#endif /* MULTIBYTE */
default:
return pgtype_precision(stmt, type, col, handle_unknown_size_as);
}
Int2
-pgtype_scale(StatementClass *stmt, Int4 type, int col)
+pgtype_scale(StatementClass * stmt, Int4 type, int col)
{
switch (type)
{
Int2
-pgtype_radix(StatementClass *stmt, Int4 type)
+pgtype_radix(StatementClass * stmt, Int4 type)
{
switch (type)
{
Int2
-pgtype_nullable(StatementClass *stmt, Int4 type)
+pgtype_nullable(StatementClass * stmt, Int4 type)
{
return SQL_NULLABLE; /* everything should be nullable */
}
Int2
-pgtype_auto_increment(StatementClass *stmt, Int4 type)
+pgtype_auto_increment(StatementClass * stmt, Int4 type)
{
switch (type)
{
Int2
-pgtype_case_sensitive(StatementClass *stmt, Int4 type)
+pgtype_case_sensitive(StatementClass * stmt, Int4 type)
{
switch (type)
{
Int2
-pgtype_money(StatementClass *stmt, Int4 type)
+pgtype_money(StatementClass * stmt, Int4 type)
{
switch (type)
{
Int2
-pgtype_searchable(StatementClass *stmt, Int4 type)
+pgtype_searchable(StatementClass * stmt, Int4 type)
{
switch (type)
{
Int2
-pgtype_unsigned(StatementClass *stmt, Int4 type)
+pgtype_unsigned(StatementClass * stmt, Int4 type)
{
switch (type)
{
char *
-pgtype_literal_prefix(StatementClass *stmt, Int4 type)
+pgtype_literal_prefix(StatementClass * stmt, Int4 type)
{
switch (type)
{
- case PG_TYPE_INT2:
- case PG_TYPE_OID:
- case PG_TYPE_XID:
- case PG_TYPE_INT4:
- case PG_TYPE_INT8:
- case PG_TYPE_NUMERIC:
- case PG_TYPE_FLOAT4:
- case PG_TYPE_FLOAT8:
- case PG_TYPE_MONEY:return NULL;
+ case PG_TYPE_INT2:
+ case PG_TYPE_OID:
+ case PG_TYPE_XID:
+ case PG_TYPE_INT4:
+ case PG_TYPE_INT8:
+ case PG_TYPE_NUMERIC:
+ case PG_TYPE_FLOAT4:
+ case PG_TYPE_FLOAT8:
+ case PG_TYPE_MONEY:
+ return NULL;
default:
return "'";
char *
-pgtype_literal_suffix(StatementClass *stmt, Int4 type)
+pgtype_literal_suffix(StatementClass * stmt, Int4 type)
{
switch (type)
{
- case PG_TYPE_INT2:
- case PG_TYPE_OID:
- case PG_TYPE_XID:
- case PG_TYPE_INT4:
- case PG_TYPE_INT8:
- case PG_TYPE_NUMERIC:
- case PG_TYPE_FLOAT4:
- case PG_TYPE_FLOAT8:
- case PG_TYPE_MONEY:return NULL;
+ case PG_TYPE_INT2:
+ case PG_TYPE_OID:
+ case PG_TYPE_XID:
+ case PG_TYPE_INT4:
+ case PG_TYPE_INT8:
+ case PG_TYPE_NUMERIC:
+ case PG_TYPE_FLOAT4:
+ case PG_TYPE_FLOAT8:
+ case PG_TYPE_MONEY:
+ return NULL;
default:
return "'";
char *
-pgtype_create_params(StatementClass *stmt, Int4 type)
+pgtype_create_params(StatementClass * stmt, Int4 type)
{
switch (type)
{
- case PG_TYPE_CHAR:
- case PG_TYPE_VARCHAR:return "max. length";
+ case PG_TYPE_CHAR:
+ case PG_TYPE_VARCHAR:
+ return "max. length";
default:
return NULL;
}
Int2
sqltype_to_default_ctype(Int2 sqltype)
{
-
/*
* from the table on page 623 of ODBC 2.0 Programmer's Reference
* (Appendix D)
/* Defines for pgtype_precision */
#define PG_STATIC (-1)
-Int4 sqltype_to_pgtype(StatementClass *stmt, Int2 fSqlType);
+Int4 sqltype_to_pgtype(StatementClass * stmt, Int2 fSqlType);
-Int2 pgtype_to_sqltype(StatementClass *stmt, Int4 type);
-Int2 pgtype_to_ctype(StatementClass *stmt, Int4 type);
-char *pgtype_to_name(StatementClass *stmt, Int4 type);
+Int2 pgtype_to_sqltype(StatementClass * stmt, Int4 type);
+Int2 pgtype_to_ctype(StatementClass * stmt, Int4 type);
+char *pgtype_to_name(StatementClass * stmt, Int4 type);
/* These functions can use static numbers or result sets(col parameter) */
-Int4 pgtype_precision(StatementClass *stmt, Int4 type, int col, int handle_unknown_size_as);
-Int4 pgtype_display_size(StatementClass *stmt, Int4 type, int col, int handle_unknown_size_as);
-Int4 pgtype_length(StatementClass *stmt, Int4 type, int col, int handle_unknown_size_as);
+Int4 pgtype_precision(StatementClass * stmt, Int4 type, int col, int handle_unknown_size_as);
+Int4 pgtype_display_size(StatementClass * stmt, Int4 type, int col, int handle_unknown_size_as);
+Int4 pgtype_length(StatementClass * stmt, Int4 type, int col, int handle_unknown_size_as);
-Int2 pgtype_scale(StatementClass *stmt, Int4 type, int col);
-Int2 pgtype_radix(StatementClass *stmt, Int4 type);
-Int2 pgtype_nullable(StatementClass *stmt, Int4 type);
-Int2 pgtype_auto_increment(StatementClass *stmt, Int4 type);
-Int2 pgtype_case_sensitive(StatementClass *stmt, Int4 type);
-Int2 pgtype_money(StatementClass *stmt, Int4 type);
-Int2 pgtype_searchable(StatementClass *stmt, Int4 type);
-Int2 pgtype_unsigned(StatementClass *stmt, Int4 type);
-char *pgtype_literal_prefix(StatementClass *stmt, Int4 type);
-char *pgtype_literal_suffix(StatementClass *stmt, Int4 type);
-char *pgtype_create_params(StatementClass *stmt, Int4 type);
+Int2 pgtype_scale(StatementClass * stmt, Int4 type, int col);
+Int2 pgtype_radix(StatementClass * stmt, Int4 type);
+Int2 pgtype_nullable(StatementClass * stmt, Int4 type);
+Int2 pgtype_auto_increment(StatementClass * stmt, Int4 type);
+Int2 pgtype_case_sensitive(StatementClass * stmt, Int4 type);
+Int2 pgtype_money(StatementClass * stmt, Int4 type);
+Int2 pgtype_searchable(StatementClass * stmt, Int4 type);
+Int2 pgtype_unsigned(StatementClass * stmt, Int4 type);
+char *pgtype_literal_prefix(StatementClass * stmt, Int4 type);
+char *pgtype_literal_suffix(StatementClass * stmt, Int4 type);
+char *pgtype_create_params(StatementClass * stmt, Int4 type);
Int2 sqltype_to_default_ctype(Int2 sqltype);
Int4 ctype_length(Int2 ctype);
-
#endif
{
return TRUE;
}
-
#endif /* not __GNUC__ */
-
#endif /* not WIN32 */
* Driver Manager do this. Also, the ordinal values of the
* functions must match the value of fFunction in SQLGetFunctions()
*/
-RETCODE SQL_API
+RETCODE SQL_API
SQLDummyOrdinal(void)
{
return SQL_SUCCESS;
*
* Comments: See "notice.txt" for copyright and license information.
*
- * $Id: psqlodbc.h,v 1.51 2001/10/12 09:41:49 inoue Exp $
+ * $Id: psqlodbc.h,v 1.52 2001/10/25 05:50:15 momjian Exp $
*
*/
#define ODBCVER ODBCVER_REP
#else
#define ODBCVER 0x0250
-#endif /* ODBCVER_REP */
+#endif /* ODBCVER_REP */
#if defined(WIN32) || defined(WITH_UNIXODBC) || defined(WITH_IODBC)
char extra_systable_prefixes[MEDIUM_REGISTRY_LEN];
char conn_settings[LARGE_REGISTRY_LEN];
char protocol[SMALL_REGISTRY_LEN];
-} GLOBAL_VALUES;
+} GLOBAL_VALUES;
typedef struct StatementOptions_
{
int bind_size; /* size of each structure if using Row
* Binding */
int use_bookmarks;
- UInt4 *rowsFetched;
- UInt2 *rowStatusArray;
- void *bookmark_ptr;
-} StatementOptions;
+ UInt4 *rowsFetched;
+ UInt2 *rowStatusArray;
+ void *bookmark_ptr;
+} StatementOptions;
/* Used to pass extra query info to send_query */
typedef struct QueryInfo_
int row_size;
QResultClass *result_in;
char *cursor;
-} QueryInfo;
+} QueryInfo;
-void logs_on_off(int cnopen, int, int);
+void logs_on_off(int cnopen, int, int);
#define PG_TYPE_LO (-999) /* hack until permanent
* type available */
#define PG_NUMERIC_MAX_PRECISION 1000
#define PG_NUMERIC_MAX_SCALE 1000
-#define INFO_INQUIRY_LEN 8192 /* this seems sufficiently big for
-queries used in info.c inoue 2001/05/17 */
+#define INFO_INQUIRY_LEN 8192 /* this seems sufficiently big for
+ * queries used in info.c inoue
+ * 2001/05/17 */
#include "misc.h"
#ifdef _MEMORY_DEBUG_
-void * debug_alloc(size_t);
-void * debug_realloc(void *, size_t);
-char * debug_strdup(const char *);
-void debug_free(void *);
-void debug_memory_check(void);
-#define malloc debug_alloc
-#define realloc debug_realloc
-#define strdup debug_strdup
-#define free debug_free
-#endif /* _MEMORY_DEBUG_ */
+void *debug_alloc(size_t);
+void *debug_realloc(void *, size_t);
+char *debug_strdup(const char *);
+void debug_free(void *);
+void debug_memory_check(void);
+
+#define malloc debug_alloc
+#define realloc debug_realloc
+#define strdup debug_strdup
+#define free debug_free
+#endif /* _MEMORY_DEBUG_ */
#endif
* All info functions call this function to create the manual result set.
*/
void
-QR_set_num_fields(QResultClass *self, int new_num_fields)
+QR_set_num_fields(QResultClass * self, int new_num_fields)
{
mylog("in QR_set_num_fields\n");
void
-QR_set_position(QResultClass *self, int pos)
+QR_set_position(QResultClass * self, int pos)
{
self->tupleField = self->backend_tuples + ((self->base + pos) * self->num_fields);
}
void
-QR_set_cache_size(QResultClass *self, int cache_size)
+QR_set_cache_size(QResultClass * self, int cache_size)
{
self->cache_size = cache_size;
}
void
-QR_set_rowset_size(QResultClass *self, int rowset_size)
+QR_set_rowset_size(QResultClass * self, int rowset_size)
{
self->rowset_size = rowset_size;
}
void
-QR_inc_base(QResultClass *self, int base_inc)
+QR_inc_base(QResultClass * self, int base_inc)
{
self->base += base_inc;
}
void
-QR_Destructor(QResultClass *self)
+QR_Destructor(QResultClass * self)
{
mylog("QResult: in DESTRUCTOR\n");
void
-QR_set_command(QResultClass *self, char *msg)
+QR_set_command(QResultClass * self, char *msg)
{
if (self->command)
free(self->command);
void
-QR_set_notice(QResultClass *self, char *msg)
+QR_set_notice(QResultClass * self, char *msg)
{
if (self->notice)
free(self->notice);
void
-QR_free_memory(QResultClass *self)
+QR_free_memory(QResultClass * self)
{
register int lf,
row;
free(tuple[lf].value);
}
}
- tuple += num_fields;/* next row */
+ tuple += num_fields; /* next row */
}
free(self->backend_tuples);
/* This function is called by send_query() */
char
-QR_fetch_tuples(QResultClass *self, ConnectionClass *conn, char *cursor)
+QR_fetch_tuples(QResultClass * self, ConnectionClass * conn, char *cursor)
{
int tuple_size;
*/
if (conn != NULL)
{
- ConnInfo *ci = &(conn->connInfo);
- BOOL fetch_cursor = (ci->drivers.use_declarefetch && cursor && cursor[0]);
+ ConnInfo *ci = &(conn->connInfo);
+ BOOL fetch_cursor = (ci->drivers.use_declarefetch && cursor && cursor[0]);
+
self->conn = conn;
mylog("QR_fetch_tuples: cursor = '%s', self->cursor=%u\n", (cursor == NULL) ? "" : cursor, self->cursor);
}
else
{
-
/*
* Always have to read the field attributes. But we dont have to
* reallocate memory for them!
* We only close cursor/end the transaction if a cursor was used.
*/
int
-QR_close(QResultClass *self)
+QR_close(QResultClass * self)
{
QResultClass *res;
/* This function is called by fetch_tuples() AND SQLFetch() */
int
-QR_next_tuple(QResultClass *self)
+QR_next_tuple(QResultClass * self)
{
int id;
QResultClass *res;
char cmdbuffer[ERROR_MSG_LENGTH + 1];
char fetch[128];
QueryInfo qi;
- ConnInfo *ci = NULL;
+ ConnInfo *ci = NULL;
if (fetch_count < fcount)
{
}
else
{
-
/*
* See if we need to fetch another group of rows. We may be being
* called from send_query(), and if so, don't send another fetch,
if ((!self->cursor || !ci->drivers.use_declarefetch) && self->fcount >= self->count_allocated)
{
- int tuple_size = self->count_allocated;
+ int tuple_size = self->count_allocated;
mylog("REALLOC: old_count = %d, size = %d\n", tuple_size, self->num_fields * sizeof(TupleField) * tuple_size);
tuple_size *= 2;
self->backend_tuples = (TupleField *) realloc(self->backend_tuples,
- tuple_size * self->num_fields * sizeof(TupleField));
+ tuple_size * self->num_fields * sizeof(TupleField));
if (!self->backend_tuples)
{
self->status = PGRES_FATAL_ERROR;
char
-QR_read_tuple(QResultClass *self, char binary)
+QR_read_tuple(QResultClass * self, char binary)
{
Int2 field_lf;
TupleField *this_tuplefield;
}
else
{
-
/*
* NO, the field is not null. so get at first the length of
* the field (four bytes)
enum QueryResultCode_
{
- PGRES_EMPTY_QUERY = 0,
- PGRES_COMMAND_OK, /* a query command that doesn't return */
+ PGRES_EMPTY_QUERY = 0,
+ PGRES_COMMAND_OK, /* a query command that doesn't
+ * return */
/* anything was executed properly by the backend */
- PGRES_TUPLES_OK, /* a query command that returns tuples */
+ PGRES_TUPLES_OK,/* a query command that returns tuples */
/* was executed properly by the backend, PGresult */
/* contains the resulttuples */
- PGRES_COPY_OUT,
- PGRES_COPY_IN,
- PGRES_BAD_RESPONSE, /* an unexpected response was recv'd from
- * the backend */
- PGRES_NONFATAL_ERROR,
- PGRES_FATAL_ERROR,
- PGRES_FIELDS_OK, /* field information from a query was
+ PGRES_COPY_OUT,
+ PGRES_COPY_IN,
+ PGRES_BAD_RESPONSE, /* an unexpected response was
+ * recv'd from the backend */
+ PGRES_NONFATAL_ERROR,
+ PGRES_FATAL_ERROR,
+ PGRES_FIELDS_OK,/* field information from a query was
* successful */
- PGRES_END_TUPLES,
- PGRES_INTERNAL_ERROR
+ PGRES_END_TUPLES,
+ PGRES_INTERNAL_ERROR
};
typedef enum QueryResultCode_ QueryResultCode;
* (backend) */
/* Stuff for declare/fetch tuples */
- int count_allocated; /* m(re)alloced count */
+ int count_allocated; /* m(re)alloced count */
int fetch_count; /* logical rows read so far */
int fcount; /* actual rows read in the fetch */
int currTuple;
/* Core Functions */
QResultClass *QR_Constructor(void);
-void QR_Destructor(QResultClass *self);
-char QR_read_tuple(QResultClass *self, char binary);
-int QR_next_tuple(QResultClass *self);
-int QR_close(QResultClass *self);
-char QR_fetch_tuples(QResultClass *self, ConnectionClass *conn, char *cursor);
-void QR_free_memory(QResultClass *self);
-void QR_set_command(QResultClass *self, char *msg);
-void QR_set_notice(QResultClass *self, char *msg);
-
-void QR_set_num_fields(QResultClass *self, int new_num_fields); /* manual result only */
-
-void QR_inc_base(QResultClass *self, int base_inc);
-void QR_set_cache_size(QResultClass *self, int cache_size);
-void QR_set_rowset_size(QResultClass *self, int rowset_size);
-void QR_set_position(QResultClass *self, int pos);
-
+void QR_Destructor(QResultClass * self);
+char QR_read_tuple(QResultClass * self, char binary);
+int QR_next_tuple(QResultClass * self);
+int QR_close(QResultClass * self);
+char QR_fetch_tuples(QResultClass * self, ConnectionClass * conn, char *cursor);
+void QR_free_memory(QResultClass * self);
+void QR_set_command(QResultClass * self, char *msg);
+void QR_set_notice(QResultClass * self, char *msg);
+
+void QR_set_num_fields(QResultClass * self, int new_num_fields); /* manual result only */
+
+void QR_inc_base(QResultClass * self, int base_inc);
+void QR_set_cache_size(QResultClass * self, int cache_size);
+void QR_set_rowset_size(QResultClass * self, int rowset_size);
+void QR_set_position(QResultClass * self, int pos);
#endif
-//{{NO_DEPENDENCIES}}\r
-// Microsoft Developer Studio generated include file.\r
-// Used by psqlodbc.rc\r
-//\r
-#define IDS_BADDSN 1\r
-#define IDS_MSGTITLE 2\r
-#define DLG_OPTIONS_DRV 102\r
-#define DLG_OPTIONS_DS 103\r
-#define IDC_DSNAME 400\r
-#define IDC_DSNAMETEXT 401\r
-#define IDC_DESC 404\r
-#define IDC_SERVER 407\r
-#define IDC_DATABASE 408\r
-#define DLG_CONFIG 1001\r
-#define IDC_PORT 1002\r
-#define IDC_USER 1006\r
-#define IDC_PASSWORD 1009\r
-#define DS_READONLY 1011\r
-#define DS_SHOWOIDCOLUMN 1012\r
-#define DS_FAKEOIDINDEX 1013\r
-#define DRV_COMMLOG 1014\r
-#define DS_PG62 1016\r
-#define IDC_DATASOURCE 1018\r
-#define DRV_OPTIMIZER 1019\r
-#define DS_CONNSETTINGS 1020\r
-#define IDC_DRIVER 1021\r
-#define DRV_CONNSETTINGS 1031\r
-#define DRV_UNIQUEINDEX 1032\r
-#define DRV_UNKNOWN_MAX 1035\r
-#define DRV_UNKNOWN_DONTKNOW 1036\r
-#define DRV_READONLY 1037\r
-#define IDC_DESCTEXT 1039\r
-#define DRV_MSG_LABEL 1040\r
-#define DRV_UNKNOWN_LONGEST 1041\r
-#define DRV_TEXT_LONGVARCHAR 1043\r
-#define DRV_UNKNOWNS_LONGVARCHAR 1044\r
-#define DRV_CACHE_SIZE 1045\r
-#define DRV_VARCHAR_SIZE 1046\r
-#define DRV_LONGVARCHAR_SIZE 1047\r
-#define IDDEFAULTS 1048\r
-#define DRV_USEDECLAREFETCH 1049\r
-#define DRV_BOOLS_CHAR 1050\r
-#define DS_SHOWSYSTEMTABLES 1051\r
-#define DRV_EXTRASYSTABLEPREFIXES 1051\r
-#define DS_ROWVERSIONING 1052\r
-#define DRV_PARSE 1052\r
-#define DRV_CANCELASFREESTMT 1053\r
-#define IDC_OPTIONS 1054\r
-#define DRV_KSQO 1055\r
-#define DS_PG64 1057\r
-#define DS_PG63 1058\r
-#define DRV_OR_DSN 1059\r
+/* {{NO_DEPENDENCIES}}\r */
+/* Microsoft Developer Studio generated include file.\r */
+/* Used by psqlodbc.rc\r */
+/*\r */
+#define IDS_BADDSN 1\r
+#define IDS_MSGTITLE 2\r
+#define DLG_OPTIONS_DRV 102\r
+#define DLG_OPTIONS_DS 103\r
+#define IDC_DSNAME 400\r
+#define IDC_DSNAMETEXT 401\r
+#define IDC_DESC 404\r
+#define IDC_SERVER 407\r
+#define IDC_DATABASE 408\r
+#define DLG_CONFIG 1001\r
+#define IDC_PORT 1002\r
+#define IDC_USER 1006\r
+#define IDC_PASSWORD 1009\r
+#define DS_READONLY 1011\r
+#define DS_SHOWOIDCOLUMN 1012\r
+#define DS_FAKEOIDINDEX 1013\r
+#define DRV_COMMLOG 1014\r
+#define DS_PG62 1016\r
+#define IDC_DATASOURCE 1018\r
+#define DRV_OPTIMIZER 1019\r
+#define DS_CONNSETTINGS 1020\r
+#define IDC_DRIVER 1021\r
+#define DRV_CONNSETTINGS 1031\r
+#define DRV_UNIQUEINDEX 1032\r
+#define DRV_UNKNOWN_MAX 1035\r
+#define DRV_UNKNOWN_DONTKNOW 1036\r
+#define DRV_READONLY 1037\r
+#define IDC_DESCTEXT 1039\r
+#define DRV_MSG_LABEL 1040\r
+#define DRV_UNKNOWN_LONGEST 1041\r
+#define DRV_TEXT_LONGVARCHAR 1043\r
+#define DRV_UNKNOWNS_LONGVARCHAR 1044\r
+#define DRV_CACHE_SIZE 1045\r
+#define DRV_VARCHAR_SIZE 1046\r
+#define DRV_LONGVARCHAR_SIZE 1047\r
+#define IDDEFAULTS 1048\r
+#define DRV_USEDECLAREFETCH 1049\r
+#define DRV_BOOLS_CHAR 1050\r
+#define DS_SHOWSYSTEMTABLES 1051\r
+#define DRV_EXTRASYSTABLEPREFIXES 1051\r
+#define DS_ROWVERSIONING 1052\r
+#define DRV_PARSE 1052\r
+#define DRV_CANCELASFREESTMT 1053\r
+#define IDC_OPTIONS 1054\r
+#define DRV_KSQO 1055\r
+#define DS_PG64 1057\r
+#define DS_PG63 1058\r
+#define DRV_OR_DSN 1059\r
#define DRV_DEBUG 1060\r
#define DS_DISALLOWPREMATURE 1061\r
\r
-// Next default values for new objects\r
-// \r
+/* Next default values for new objects\r */
+/*\r */
#ifdef APSTUDIO_INVOKED\r
#ifndef APSTUDIO_READONLY_SYMBOLS\r
-#define _APS_NEXT_RESOURCE_VALUE 105\r
-#define _APS_NEXT_COMMAND_VALUE 40001\r
-#define _APS_NEXT_CONTROL_VALUE 1062\r
-#define _APS_NEXT_SYMED_VALUE 101\r
-#endif\r
-#endif\r
+#define _APS_NEXT_RESOURCE_VALUE 105\r
+#define _APS_NEXT_COMMAND_VALUE 40001\r
+#define _APS_NEXT_CONTROL_VALUE 1062\r
+#define _APS_NEXT_SYMED_VALUE 101\r
+#endif /*\r */
+#endif /*\r */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_RowCount(
- HSTMT hstmt,
- SDWORD FAR *pcrow)
+ HSTMT hstmt,
+ SDWORD FAR * pcrow)
{
static char *func = "PGAPI_RowCount";
StatementClass *stmt = (StatementClass *) hstmt;
QResultClass *res;
char *msg,
*ptr;
- ConnInfo *ci;
+ ConnInfo *ci;
if (!stmt)
{
* This returns the number of columns associated with the database
* attached to "hstmt".
*/
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_NumResultCols(
- HSTMT hstmt,
- SWORD FAR *pccol)
+ HSTMT hstmt,
+ SWORD FAR * pccol)
{
static char *func = "PGAPI_NumResultCols";
StatementClass *stmt = (StatementClass *) hstmt;
QResultClass *result;
char parse_ok;
- ConnInfo *ci;
+ ConnInfo *ci;
if (!stmt)
{
*pccol = QR_NumResultCols(result);
/* updatable cursors */
if (ci->updatable_cursors &&
- stmt->options.scroll_concurrency != SQL_CONCUR_READ_ONLY)
- {
+ stmt->options.scroll_concurrency != SQL_CONCUR_READ_ONLY)
*pccol -= 2;
- }
}
return SQL_SUCCESS;
* Return information about the database column the user wants
* information about.
*/
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_DescribeCol(
- HSTMT hstmt,
- UWORD icol,
- UCHAR FAR *szColName,
- SWORD cbColNameMax,
- SWORD FAR *pcbColName,
- SWORD FAR *pfSqlType,
- UDWORD FAR *pcbColDef,
- SWORD FAR *pibScale,
- SWORD FAR *pfNullable)
+ HSTMT hstmt,
+ UWORD icol,
+ UCHAR FAR * szColName,
+ SWORD cbColNameMax,
+ SWORD FAR * pcbColName,
+ SWORD FAR * pfSqlType,
+ UDWORD FAR * pcbColDef,
+ SWORD FAR * pibScale,
+ SWORD FAR * pfNullable)
{
static char *func = "PGAPI_DescribeCol";
QResultClass *res;
char *col_name = NULL;
Int4 fieldtype = 0;
- int precision = 0, scale = 0;
+ int precision = 0,
+ scale = 0;
ConnInfo *ci;
char parse_ok;
char buf[255];
/* Returns result column descriptor information for a result set. */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_ColAttributes(
- HSTMT hstmt,
- UWORD icol,
- UWORD fDescType,
- PTR rgbDesc,
- SWORD cbDescMax,
- SWORD FAR *pcbDesc,
- SDWORD FAR *pfDesc)
+ HSTMT hstmt,
+ UWORD icol,
+ UWORD fDescType,
+ PTR rgbDesc,
+ SWORD cbDescMax,
+ SWORD FAR * pcbDesc,
+ SDWORD FAR * pfDesc)
{
static char *func = "PGAPI_ColAttributes";
StatementClass *stmt = (StatementClass *) hstmt;
/* Returns result data for a single column in the current row. */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_GetData(
- HSTMT hstmt,
- UWORD icol,
- SWORD fCType,
- PTR rgbValue,
- SDWORD cbValueMax,
- SDWORD FAR *pcbValue)
+ HSTMT hstmt,
+ UWORD icol,
+ SWORD fCType,
+ PTR rgbValue,
+ SDWORD cbValueMax,
+ SDWORD FAR * pcbValue)
{
static char *func = "PGAPI_GetData";
QResultClass *res;
void *value = NULL;
int result;
char get_bookmark = FALSE;
- ConnInfo *ci;
+ ConnInfo *ci;
mylog("PGAPI_GetData: enter, stmt=%u\n", stmt);
* Returns data for bound columns in the current row ("hstmt->iCursor"),
* advances the cursor.
*/
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_Fetch(
- HSTMT hstmt)
+ HSTMT hstmt)
{
static char *func = "PGAPI_Fetch";
StatementClass *stmt = (StatementClass *) hstmt;
/* This fetchs a block of data (rowset). */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_ExtendedFetch(
- HSTMT hstmt,
- UWORD fFetchType,
- SDWORD irow,
- UDWORD FAR *pcrow,
- UWORD FAR *rgfRowStatus)
+ HSTMT hstmt,
+ UWORD fFetchType,
+ SDWORD irow,
+ UDWORD FAR * pcrow,
+ UWORD FAR * rgfRowStatus)
{
static char *func = "PGAPI_ExtendedFetch";
StatementClass *stmt = (StatementClass *) hstmt;
RETCODE result;
char truncated,
error;
- ConnInfo *ci;
+ ConnInfo *ci;
mylog("PGAPI_ExtendedFetch: stmt=%u\n", stmt);
/* this should be refined */
else if (result > 10 && result < 20)
*(rgfRowStatus + i) = result - 10;
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+#endif /* DRIVER_CURSOR_IMPLEMENT */
else
*(rgfRowStatus + i) = SQL_ROW_SUCCESS;
}
* the "hstmt".
*/
/* CC: return SQL_NO_DATA_FOUND since we do not support multiple result sets */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_MoreResults(
- HSTMT hstmt)
+ HSTMT hstmt)
{
return SQL_NO_DATA_FOUND;
}
#ifdef DRIVER_CURSOR_IMPLEMENT
/*
- * Stuff for updatable cursors.
+ * Stuff for updatable cursors.
*/
static QResultClass *
-positioned_load(StatementClass *stmt, BOOL latest, int res_cols, UInt4 oid, const char *tidval)
+positioned_load(StatementClass * stmt, BOOL latest, int res_cols, UInt4 oid, const char *tidval)
{
- int i;
- QResultClass *qres;
- char selstr[4096];
+ int i;
+ QResultClass *qres;
+ char selstr[4096];
sprintf(selstr, "select");
for (i = 0; i < res_cols; i++)
{
if (latest)
sprintf(selstr, "%s ctid = currtid2('%s', '%s') and",
- selstr, stmt->ti[0]->name, tidval);
+ selstr, stmt->ti[0]->name, tidval);
else
sprintf(selstr, "%s ctid = '%s' and", selstr, tidval);
}
- sprintf(selstr, "%s oid = %u", selstr, oid),
- mylog("selstr=%s\n", selstr);
+ sprintf(selstr, "%s oid = %u", selstr, oid),
+ mylog("selstr=%s\n", selstr);
qres = CC_send_query(SC_get_conn(stmt), selstr, NULL);
if (qres && QR_aborted(qres))
{
return qres;
}
-RETCODE SQL_API
-SC_pos_reload(StatementClass *stmt, UWORD irow, UWORD *count)
+RETCODE SQL_API
+SC_pos_reload(StatementClass * stmt, UWORD irow, UWORD * count)
{
- int i, res_cols;
- UWORD rcnt, global_ridx;
- UInt4 oid;
- QResultClass *res, *qres;
- RETCODE ret = SQL_ERROR;
- char *tidval, *oidval;
+ int i,
+ res_cols;
+ UWORD rcnt,
+ global_ridx;
+ UInt4 oid;
+ QResultClass *res,
+ *qres;
+ RETCODE ret = SQL_ERROR;
+ char *tidval,
+ *oidval;
mylog("positioned load fi=%x ti=%x\n", stmt->fi, stmt->ti);
rcnt = 0;
if (!(res = stmt->result))
return SQL_ERROR;
if (!stmt->ti)
- parse_statement(stmt); /* not preferable */
+ parse_statement(stmt); /* not preferable */
if (!stmt->ti || stmt->ntab != 1)
{
stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
global_ridx = irow + stmt->rowset_start;
res_cols = QR_NumResultCols(res);
if (!(oidval = QR_get_value_backend_row(res, global_ridx, res_cols - 1)))
- {
return SQL_SUCCESS_WITH_INFO;
- }
- sscanf(oidval, "%u", &oid);
+ sscanf(oidval, "%u", &oid);
tidval = QR_get_value_backend_row(res, global_ridx, res_cols - 2);
res_cols -= 2;
if (qres = positioned_load(stmt, TRUE, res_cols, oid, tidval), qres)
{
- TupleField *tupleo, *tuplen;
+ TupleField *tupleo,
+ *tuplen;
rcnt = QR_get_num_tuples(qres);
tupleo = res->backend_tuples + res->num_fields * global_ridx;
return ret;
}
-RETCODE SQL_API
-SC_pos_newload(StatementClass *stmt, UInt4 oid, const char *tidval)
+RETCODE SQL_API
+SC_pos_newload(StatementClass * stmt, UInt4 oid, const char *tidval)
{
- int i;
- QResultClass *res, *qres;
- RETCODE ret = SQL_ERROR;
+ int i;
+ QResultClass *res,
+ *qres;
+ RETCODE ret = SQL_ERROR;
mylog("positioned new fi=%x ti=%x\n", stmt->fi, stmt->ti);
if (!(res = stmt->result))
return SQL_ERROR;
if (!stmt->ti)
- parse_statement(stmt); /* not preferable */
+ parse_statement(stmt); /* not preferable */
if (!stmt->ti || stmt->ntab != 1)
{
stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
return SQL_ERROR;
}
if (qres = positioned_load(stmt, TRUE, QR_NumResultCols(res) - 2, oid, tidval), qres)
- {
- TupleField *tupleo, *tuplen;
- int count = QR_get_num_tuples(qres);
+ {
+ TupleField *tupleo,
+ *tuplen;
+ int count = QR_get_num_tuples(qres);
+
QR_set_position(qres, 0);
if (count == 1)
{
tuplen = qres->tupleField;
if (res->fcount >= res->count_allocated)
{
- int tuple_size;
+ int tuple_size;
+
if (!res->count_allocated)
tuple_size = TUPLE_MALLOC_INC;
else
tuple_size = res->count_allocated * 2;
res->backend_tuples = (TupleField *) realloc(
- res->backend_tuples,
- res->num_fields * sizeof(TupleField) * tuple_size);
+ res->backend_tuples,
+ res->num_fields * sizeof(TupleField) * tuple_size);
if (!res->backend_tuples)
{
stmt->errornumber = res->status = PGRES_FATAL_ERROR;
}
res->count_allocated = tuple_size;
}
- tupleo = res->backend_tuples + res->num_fields * res->fcount;
+ tupleo = res->backend_tuples + res->num_fields * res->fcount;
for (i = 0; i < res->num_fields; i++)
{
tupleo[i].len = tuplen[i].len;
ret = SQL_SUCCESS_WITH_INFO;
}
QR_Destructor(qres);
- /*stmt->currTuple = stmt->rowset_start + irow;*/
+ /* stmt->currTuple = stmt->rowset_start + irow; */
}
return ret;
}
-RETCODE SQL_API
-SC_pos_update(StatementClass *stmt,
- UWORD irow)
+RETCODE SQL_API
+SC_pos_update(StatementClass * stmt,
+ UWORD irow)
{
- int i, res_cols, num_cols, upd_cols;
- UWORD global_ridx;
- QResultClass *res;
+ int i,
+ res_cols,
+ num_cols,
+ upd_cols;
+ UWORD global_ridx;
+ QResultClass *res;
BindInfoClass *bindings = stmt->bindings;
- char updstr[4096];
- RETCODE ret;
- char *tidval, *oidval;
+ char updstr[4096];
+ RETCODE ret;
+ char *tidval,
+ *oidval;
mylog("POS UPDATE %d+%d fi=%x ti=%x\n", irow, stmt->result->base, stmt->fi, stmt->ti);
if (!(res = stmt->result))
return SQL_ERROR;
if (!stmt->ti)
- parse_statement(stmt); /* not preferable */
+ parse_statement(stmt); /* not preferable */
if (!stmt->ti || stmt->ntab != 1)
{
stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
{
stmt->errormsg = "The row is already deleted";
return SQL_ERROR;
- }
+ }
tidval = QR_get_value_backend_row(res, global_ridx, res_cols - 2);
sprintf(updstr, "update \"%s\" set", stmt->ti[0]->name);
}
if (upd_cols > 0)
{
- HSTMT hstmt;
- int j;
- int res_cols = QR_NumResultCols(res);
- StatementClass *qstmt;
+ HSTMT hstmt;
+ int j;
+ int res_cols = QR_NumResultCols(res);
+ StatementClass *qstmt;
sprintf(updstr, "%s where ctid = '%s' and oid = %s", updstr,
- tidval, oidval);
+ tidval, oidval);
mylog("updstr=%s\n", updstr);
if (PGAPI_AllocStmt(SC_get_conn(stmt), &hstmt) != SQL_SUCCESS)
return SQL_ERROR;
mylog("%d used=%d\n", i, *bindings[i].used);
if (*bindings[i].used != SQL_IGNORE)
{
- PGAPI_BindParameter(hstmt, (SQLUSMALLINT) ++j,
- SQL_PARAM_INPUT, bindings[i].returntype,
- pgtype_to_sqltype(stmt, QR_get_field_type(res, i)),
- QR_get_fieldsize(res, i),
- (SQLSMALLINT) stmt->fi[i]->precision,
- bindings[i].buffer,
- bindings[i].buflen,
- bindings[i].used);
+ PGAPI_BindParameter(hstmt, (SQLUSMALLINT)++ j,
+ SQL_PARAM_INPUT, bindings[i].returntype,
+ pgtype_to_sqltype(stmt, QR_get_field_type(res, i)),
+ QR_get_fieldsize(res, i),
+ (SQLSMALLINT) stmt->fi[i]->precision,
+ bindings[i].buffer,
+ bindings[i].buflen,
+ bindings[i].used);
}
}
}
stmt->errornumber = qstmt->errornumber;
stmt->errormsg = qstmt->errormsg;
}
- else if (ret == SQL_NEED_DATA) /* must be fixed */
+ else if (ret == SQL_NEED_DATA) /* must be fixed */
{
stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
stmt->errornumber = STMT_INVALID_CURSOR_STATE_ERROR;
}
if (ret != SQL_ERROR)
{
- int updcnt;
+ int updcnt;
const char *cmdstr = QR_get_command(qstmt->result);
+
if (cmdstr &&
- sscanf(cmdstr, "UPDATE %d", &updcnt) == 1)
- {
+ sscanf(cmdstr, "UPDATE %d", &updcnt) == 1)
+ {
if (updcnt == 1)
SC_pos_reload(stmt, irow, (UWORD *) 0);
else if (updcnt == 0)
else
ret = SQL_ERROR;
stmt->currTuple = stmt->rowset_start + irow;
- }
+ }
else
ret = SQL_ERROR;
if (ret == SQL_ERROR && stmt->errornumber == 0)
ret = SQL_SUCCESS_WITH_INFO;
return ret;
}
-RETCODE SQL_API
-SC_pos_delete(StatementClass *stmt,
- UWORD irow)
+RETCODE SQL_API
+SC_pos_delete(StatementClass * stmt,
+ UWORD irow)
{
- int res_cols;
- UWORD global_ridx;
- QResultClass *res, *qres;
+ int res_cols;
+ UWORD global_ridx;
+ QResultClass *res,
+ *qres;
BindInfoClass *bindings = stmt->bindings;
- char dltstr[4096];
- RETCODE ret;
- char *oidval;
+ char dltstr[4096];
+ RETCODE ret;
+ char *oidval;
mylog("POS DELETE fi=%x ti=%x\n", stmt->fi, stmt->ti);
if (!(res = stmt->result))
return SQL_ERROR;
if (!stmt->ti)
- parse_statement(stmt); /* not preferable */
+ parse_statement(stmt); /* not preferable */
if (!stmt->ti || stmt->ntab != 1)
{
stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
{
stmt->errormsg = "The row is already deleted";
return SQL_ERROR;
- }
+ }
sprintf(dltstr, "delete from \"%s\" where ctid = '%s' and oid = %s",
stmt->ti[0]->name,
- QR_get_value_backend_row(stmt->result, global_ridx, res_cols - 2),
- oidval);
+ QR_get_value_backend_row(stmt->result, global_ridx, res_cols - 2),
+ oidval);
mylog("dltstr=%s\n", dltstr);
qres = CC_send_query(SC_get_conn(stmt), dltstr, NULL);
if (qres && QR_command_successful(qres))
{
- int dltcnt;
+ int dltcnt;
const char *cmdstr = QR_get_command(qres);
+
if (cmdstr &&
- sscanf(cmdstr, "DELETE %d", &dltcnt) == 1)
+ sscanf(cmdstr, "DELETE %d", &dltcnt) == 1)
{
if (dltcnt == 1)
SC_pos_reload(stmt, irow, (UWORD *) 0);
QR_Destructor(qres);
return ret;
}
-RETCODE SQL_API
-SC_pos_add(StatementClass *stmt,
- UWORD irow)
+RETCODE SQL_API
+SC_pos_add(StatementClass * stmt,
+ UWORD irow)
{
- int num_cols, add_cols, i;
- HSTMT hstmt;
- QResultClass *res;
+ int num_cols,
+ add_cols,
+ i;
+ HSTMT hstmt;
+ QResultClass *res;
BindInfoClass *bindings = stmt->bindings;
- char addstr[4096];
- RETCODE ret;
+ char addstr[4096];
+ RETCODE ret;
mylog("POS ADD fi=%x ti=%x\n", stmt->fi, stmt->ti);
if (!(res = stmt->result))
return SQL_ERROR;
if (!stmt->ti)
- parse_statement(stmt); /* not preferable */
+ parse_statement(stmt); /* not preferable */
if (!stmt->ti || stmt->ntab != 1)
{
stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
sprintf(addstr, "%s, \"%s\"", addstr, stmt->fi[i]->name);
else
sprintf(addstr, "%s\"%s\"", addstr, stmt->fi[i]->name);
- PGAPI_BindParameter(hstmt, (SQLUSMALLINT) ++add_cols,
- SQL_PARAM_INPUT, bindings[i].returntype,
- pgtype_to_sqltype(stmt, QR_get_field_type(res, i)),
- QR_get_fieldsize(res, i),
- (SQLSMALLINT) stmt->fi[i]->precision,
- bindings[i].buffer,
- bindings[i].buflen,
- bindings[i].used);
+ PGAPI_BindParameter(hstmt, (SQLUSMALLINT)++ add_cols,
+ SQL_PARAM_INPUT, bindings[i].returntype,
+ pgtype_to_sqltype(stmt, QR_get_field_type(res, i)),
+ QR_get_fieldsize(res, i),
+ (SQLSMALLINT) stmt->fi[i]->precision,
+ bindings[i].buffer,
+ bindings[i].buflen,
+ bindings[i].used);
}
}
else
}
if (add_cols > 0)
{
- StatementClass *qstmt = (StatementClass *) hstmt;
+ StatementClass *qstmt = (StatementClass *) hstmt;
sprintf(addstr, "%s) values (", addstr);
for (i = 0; i < add_cols; i++)
strcat(addstr, ")");
mylog("addstr=%s\n", addstr);
ret = PGAPI_ExecDirect(hstmt, addstr, strlen(addstr));
- if (ret == SQL_NEED_DATA) /* must be fixed */
+ if (ret == SQL_NEED_DATA) /* must be fixed */
{
stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
stmt->errornumber = STMT_INVALID_CURSOR_STATE_ERROR;
}
if (ret == SQL_ERROR)
{
- stmt->errornumber = qstmt->errornumber;
- stmt->errormsg = qstmt->errormsg;
+ stmt->errornumber = qstmt->errornumber;
+ stmt->errormsg = qstmt->errormsg;
}
else
{
- int addcnt;
- UInt4 oid;
+ int addcnt;
+ UInt4 oid;
const char *cmdstr = QR_get_command(qstmt->result);
+
if (cmdstr &&
- sscanf(cmdstr, "INSERT %u %d", &oid, &addcnt) == 2 &&
- addcnt == 1)
+ sscanf(cmdstr, "INSERT %u %d", &oid, &addcnt) == 2 &&
+ addcnt == 1)
{
SC_pos_newload(stmt, oid, NULL);
- if (stmt->bookmark.buffer)
- {
- char buf[32];
-
- sprintf(buf, "%ld", res->fcount);
- copy_and_convert_field(stmt, 0, buf,
- SQL_C_ULONG, stmt->bookmark.buffer,
- 0, stmt->bookmark.used);
- }
+ if (stmt->bookmark.buffer)
+ {
+ char buf[32];
+
+ sprintf(buf, "%ld", res->fcount);
+ copy_and_convert_field(stmt, 0, buf,
+ SQL_C_ULONG, stmt->bookmark.buffer,
+ 0, stmt->bookmark.used);
+ }
}
else
{
PGAPI_FreeStmt(hstmt, SQL_DROP);
return ret;
}
+
/*
- * Stuff for updatable cursors end.
+ * Stuff for updatable cursors end.
*/
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+#endif /* DRIVER_CURSOR_IMPLEMENT */
/*
* This positions the cursor within a rowset, that was positioned using SQLExtendedFetch.
* This will be useful (so far) only when using SQLGetData after SQLExtendedFetch.
*/
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_SetPos(
- HSTMT hstmt,
- UWORD irow,
- UWORD fOption,
- UWORD fLock)
+ HSTMT hstmt,
+ UWORD irow,
+ UWORD fOption,
+ UWORD fLock)
{
static char *func = "PGAPI_SetPos";
StatementClass *stmt = (StatementClass *) hstmt;
if (stmt->options.scroll_concurrency != SQL_CONCUR_READ_ONLY)
;
else
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+#endif /* DRIVER_CURSOR_IMPLEMENT */
if (fOption != SQL_POSITION && fOption != SQL_REFRESH)
{
stmt->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
case SQL_ADD:
return SC_pos_add(stmt, irow);
}
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+#endif /* DRIVER_CURSOR_IMPLEMENT */
/* Reset for SQLGetData */
for (i = 0; i < num_cols; i++)
bindings[i].data_left = -1;
if (fOption == SQL_REFRESH)
{
/* save the last_fetch_count */
- int last_fetch = stmt->last_fetch_count;
- int bind_save = stmt->bind_row;
+ int last_fetch = stmt->last_fetch_count;
+ int bind_save = stmt->bind_row;
#ifdef DRIVER_CURSOR_IMPLEMENT
if (stmt->options.cursor_type == SQL_CURSOR_KEYSET_DRIVEN)
- SC_pos_reload(stmt, irow, (UWORD *) 0);
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+ SC_pos_reload(stmt, irow, (UWORD *) 0);
+#endif /* DRIVER_CURSOR_IMPLEMENT */
stmt->currTuple = stmt->rowset_start + irow - 1;
stmt->bind_row = irow;
SC_fetch(stmt);
/* Sets options that control the behavior of cursors. */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_SetScrollOptions(
- HSTMT hstmt,
- UWORD fConcurrency,
- SDWORD crowKeyset,
- UWORD crowRowset)
+ HSTMT hstmt,
+ UWORD fConcurrency,
+ SDWORD crowKeyset,
+ UWORD crowRowset)
{
static char *func = "PGAPI_SetScrollOptions";
StatementClass *stmt = (StatementClass *) hstmt;
+
mylog("PGAPI_SetScrollOptions fConcurrency=%d crowKeyset=%d crowRowset=%d\n",
- fConcurrency, crowKeyset, crowRowset);
+ fConcurrency, crowKeyset, crowRowset);
stmt->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
stmt->errormsg = "SetScroll option not implemeted";
/* Set the cursor name on a statement handle */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_SetCursorName(
- HSTMT hstmt,
- UCHAR FAR *szCursor,
- SWORD cbCursor)
+ HSTMT hstmt,
+ UCHAR FAR * szCursor,
+ SWORD cbCursor)
{
static char *func = "PGAPI_SetCursorName";
StatementClass *stmt = (StatementClass *) hstmt;
/* Return the cursor name for a statement handle */
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_GetCursorName(
- HSTMT hstmt,
- UCHAR FAR *szCursor,
- SWORD cbCursorMax,
- SWORD FAR *pcbCursor)
+ HSTMT hstmt,
+ UCHAR FAR * szCursor,
+ SWORD cbCursorMax,
+ SWORD FAR * pcbCursor)
{
static char *func = "PGAPI_GetCursorName";
StatementClass *stmt = (StatementClass *) hstmt;
#define INTFUNC __stdcall
-extern HINSTANCE NEAR s_hModule;/* Saved module handle. */
+extern HINSTANCE NEAR s_hModule; /* Saved module handle. */
/* Constants */
#define MIN(x,y) ((x) < (y) ? (x) : (y))
BOOL fNewDSN; /* New data source flag */
BOOL fDefault; /* Default data source flag */
-} SETUPDLG, FAR *LPSETUPDLG;
+} SETUPDLG, FAR * LPSETUPDLG;
LPARAM lParam)
{
LPSETUPDLG lpsetupdlg;
- ConnInfo *ci;
+ ConnInfo *ci;
+
switch (wMsg)
{
- /* Initialize the dialog */
+ /* Initialize the dialog */
case WM_INITDIALOG:
lpsetupdlg = (LPSETUPDLG) lParam;
ci = &lpsetupdlg->ci;
ShowWindow(GetDlgItem(hdlg, DRV_MSG_LABEL), SW_HIDE);
SetWindowLong(hdlg, DWL_USER, lParam);
- CenterDialog(hdlg); /* Center dialog */
+ CenterDialog(hdlg); /* Center dialog */
/*
- * NOTE: Values supplied in the attribute string will
- * always
+ * NOTE: Values supplied in the attribute string will always
*/
/* override settings in ODBC.INI */
}
else
SendDlgItemMessage(hdlg, IDC_DSNAME,
- EM_LIMITTEXT, (WPARAM) (MAXDSNAME - 1), 0L);
+ EM_LIMITTEXT, (WPARAM) (MAXDSNAME - 1), 0L);
SendDlgItemMessage(hdlg, IDC_DESC,
- EM_LIMITTEXT, (WPARAM) (MAXDESC - 1), 0L);
- return TRUE; /* Focus was not set */
+ EM_LIMITTEXT, (WPARAM) (MAXDESC - 1), 0L);
+ return TRUE; /* Focus was not set */
/* Process buttons */
case WM_COMMAND:
switch (GET_WM_COMMAND_ID(wParam, lParam))
{
-
/*
* Ensure the OK button is enabled only when a data
* source name
/* Retrieve dialog values */
if (!lpsetupdlg->fDefault)
GetDlgItemText(hdlg, IDC_DSNAME,
- lpsetupdlg->ci.dsn,
- sizeof(lpsetupdlg->ci.dsn));
+ lpsetupdlg->ci.dsn,
+ sizeof(lpsetupdlg->ci.dsn));
/* Get Dialog Values */
GetDlgStuff(hdlg, &lpsetupdlg->ci);
case IDC_DRIVER:
lpsetupdlg = (LPSETUPDLG) GetWindowLong(hdlg, DWL_USER);
DialogBoxParam(s_hModule, MAKEINTRESOURCE(DLG_OPTIONS_DRV),
- hdlg, driver_optionsProc, (LPARAM) &lpsetupdlg->ci);
+ hdlg, driver_optionsProc, (LPARAM) & lpsetupdlg->ci);
return TRUE;
case IDC_DATASOURCE:
lpsetupdlg = (LPSETUPDLG) GetWindowLong(hdlg, DWL_USER);
DialogBoxParam(s_hModule, MAKEINTRESOURCE(DLG_OPTIONS_DS),
- hdlg, ds_optionsProc, (LPARAM) &lpsetupdlg->ci);
+ hdlg, ds_optionsProc, (LPARAM) & lpsetupdlg->ci);
return TRUE;
}
for (lpsz = lpszAttributes; *lpsz; lpsz++)
{
-
/*
* Extract key name (e.g., DSN), it must be terminated by an
* equals
void
-SOCK_clear_error(SocketClass *self)
+SOCK_clear_error(SocketClass * self)
{
self->errornumber = 0;
self->errormsg = NULL;
SocketClass *
-SOCK_Constructor(const ConnectionClass *conn)
+SOCK_Constructor(const ConnectionClass * conn)
{
SocketClass *rv;
void
-SOCK_Destructor(SocketClass *self)
+SOCK_Destructor(SocketClass * self)
{
-mylog("SOCK_Destructor\n");
+ mylog("SOCK_Destructor\n");
if (self->socket != -1)
{
SOCK_put_char(self, 'X');
char
-SOCK_connect_to(SocketClass *self, unsigned short port, char *hostname)
+SOCK_connect_to(SocketClass * self, unsigned short port, char *hostname)
{
struct hostent *host;
struct sockaddr_in sadr;
void
-SOCK_get_n_char(SocketClass *self, char *buffer, int len)
+SOCK_get_n_char(SocketClass * self, char *buffer, int len)
{
int lf;
void
-SOCK_put_n_char(SocketClass *self, char *buffer, int len)
+SOCK_put_n_char(SocketClass * self, char *buffer, int len)
{
int lf;
* returns TRUE if truncation occurs.
*/
BOOL
-SOCK_get_string(SocketClass *self, char *buffer, int bufsize)
+SOCK_get_string(SocketClass * self, char *buffer, int bufsize)
{
register int lf = 0;
void
-SOCK_put_string(SocketClass *self, char *string)
+SOCK_put_string(SocketClass * self, char *string)
{
register int lf;
int len;
int
-SOCK_get_int(SocketClass *self, short len)
+SOCK_get_int(SocketClass * self, short len)
{
switch (len)
{
- case 2:
+ case 2:
{
unsigned short buf;
void
-SOCK_put_int(SocketClass *self, int value, short len)
+SOCK_put_int(SocketClass * self, int value, short len)
{
unsigned int rv;
void
-SOCK_flush_output(SocketClass *self)
+SOCK_flush_output(SocketClass * self)
{
int written;
unsigned char
-SOCK_get_next_byte(SocketClass *self)
+SOCK_get_next_byte(SocketClass * self)
{
if (self->buffer_read_in >= self->buffer_filled_in)
{
-
/*
* there are no more bytes left in the buffer so reload the buffer
*/
void
-SOCK_put_next_byte(SocketClass *self, unsigned char next_byte)
+SOCK_put_next_byte(SocketClass * self, unsigned char next_byte)
{
int bytes_sent;
#ifndef _IN_ADDR_T
#define _IN_ADDR_T
typedef unsigned int in_addr_t;
-
#endif
#define INADDR_NONE ((in_addr_t)-1)
#endif
/* Socket prototypes */
-SocketClass *SOCK_Constructor(const ConnectionClass *conn);
-void SOCK_Destructor(SocketClass *self);
-char SOCK_connect_to(SocketClass *self, unsigned short port, char *hostname);
-void SOCK_get_n_char(SocketClass *self, char *buffer, int len);
-void SOCK_put_n_char(SocketClass *self, char *buffer, int len);
-BOOL SOCK_get_string(SocketClass *self, char *buffer, int bufsize);
-void SOCK_put_string(SocketClass *self, char *string);
-int SOCK_get_int(SocketClass *self, short len);
-void SOCK_put_int(SocketClass *self, int value, short len);
-void SOCK_flush_output(SocketClass *self);
-unsigned char SOCK_get_next_byte(SocketClass *self);
-void SOCK_put_next_byte(SocketClass *self, unsigned char next_byte);
-void SOCK_clear_error(SocketClass *self);
-
+SocketClass *SOCK_Constructor(const ConnectionClass * conn);
+void SOCK_Destructor(SocketClass * self);
+char SOCK_connect_to(SocketClass * self, unsigned short port, char *hostname);
+void SOCK_get_n_char(SocketClass * self, char *buffer, int len);
+void SOCK_put_n_char(SocketClass * self, char *buffer, int len);
+BOOL SOCK_get_string(SocketClass * self, char *buffer, int bufsize);
+void SOCK_put_string(SocketClass * self, char *string);
+int SOCK_get_int(SocketClass * self, short len);
+void SOCK_put_int(SocketClass * self, int value, short len);
+void SOCK_flush_output(SocketClass * self);
+unsigned char SOCK_get_next_byte(SocketClass * self);
+void SOCK_put_next_byte(SocketClass * self, unsigned char next_byte);
+void SOCK_clear_error(SocketClass * self);
#endif
};
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_AllocStmt(HDBC hdbc,
- HSTMT FAR *phstmt)
+ HSTMT FAR * phstmt)
{
static char *func = "PGAPI_AllocStmt";
ConnectionClass *conn = (ConnectionClass *) hdbc;
}
-RETCODE SQL_API
+RETCODE SQL_API
PGAPI_FreeStmt(HSTMT hstmt,
- UWORD fOption)
+ UWORD fOption)
{
static char *func = "PGAPI_FreeStmt";
StatementClass *stmt = (StatementClass *) hstmt;
SC_unbind_cols(stmt);
else if (fOption == SQL_CLOSE)
{
-
/*
* this should discard all the results, but leave the statement
* itself in place (it can be executed again)
* StatementClass implementation
*/
void
-InitializeStatementOptions(StatementOptions *opt)
+InitializeStatementOptions(StatementOptions * opt)
{
opt->maxRows = 0; /* driver returns all rows */
opt->maxLength = 0; /* driver returns all data for char/binary */
char
-SC_Destructor(StatementClass *self)
+SC_Destructor(StatementClass * self)
{
mylog("SC_Destructor: self=%u, self->result=%u, self->hdbc=%u\n", self, self->result, self->hdbc);
SC_clear_error(self);
* data-at-execution parameters that was allocated in SQLPutData.
*/
void
-SC_free_params(StatementClass *self, char option)
+SC_free_params(StatementClass * self, char option)
{
int i;
* from SQLFreeStmt(SQL_CLOSE)
*/
char
-SC_recycle_statement(StatementClass *self)
+SC_recycle_statement(StatementClass * self)
{
ConnectionClass *conn;
conn = SC_get_conn(self);
if (!CC_is_in_autocommit(conn) && CC_is_in_trans(conn))
{
- if (SC_is_pre_executable(self) && !conn->connInfo.disallow_premature)
+ if (SC_is_pre_executable(self) && !conn->connInfo.disallow_premature)
CC_abort(conn);
}
break;
* Reset only parameters that have anything to do with results
*/
self->status = STMT_READY;
- self->manual_result = FALSE;/* very important */
+ self->manual_result = FALSE; /* very important */
self->currTuple = -1;
self->rowset_start = -1;
/* Pre-execute a statement (SQLPrepare/SQLDescribeCol) */
void
-SC_pre_execute(StatementClass *self)
+SC_pre_execute(StatementClass * self)
{
mylog("SC_pre_execute: status = %d\n", self->status);
/* This is only called from SQLFreeStmt(SQL_UNBIND) */
char
-SC_unbind_cols(StatementClass *self)
+SC_unbind_cols(StatementClass * self)
{
Int2 lf;
void
-SC_clear_error(StatementClass *self)
+SC_clear_error(StatementClass * self)
{
if (self->errormsg_malloced && self->errormsg)
free(self->errormsg);
* of the result, statement, connection, and socket messages.
*/
char *
-SC_create_errormsg(StatementClass *self)
+SC_create_errormsg(StatementClass * self)
{
QResultClass *res = self->result;
ConnectionClass *conn = self->hdbc;
char
-SC_get_error(StatementClass *self, int *number, char **message)
+SC_get_error(StatementClass * self, int *number, char **message)
{
char rv;
* someday, such as mapping a key to a 32 bit value
*/
unsigned long
-SC_get_bookmark(StatementClass *self)
+SC_get_bookmark(StatementClass * self)
{
return (self->currTuple + 1);
}
RETCODE
-SC_fetch(StatementClass *self)
+SC_fetch(StatementClass * self)
{
static char *func = "SC_fetch";
QResultClass *res = self->result;
int retval,
result;
+
#ifdef DRIVER_CURSOR_IMPLEMENT
- int updret;
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+ int updret;
+#endif /* DRIVER_CURSOR_IMPLEMENT */
Int2 num_cols,
lf;
Oid type;
char *value;
ColumnInfoClass *coli;
+
/* TupleField *tupleField; */
- ConnInfo *ci = &(SC_get_conn(self)->connInfo);
+ ConnInfo *ci = &(SC_get_conn(self)->connInfo);
self->last_fetch_count = 0;
coli = QR_get_fields(res); /* the column info */
if (self->currTuple >= QR_get_num_tuples(res) - 1 ||
(self->options.maxRows > 0 && self->currTuple == self->options.maxRows - 1))
{
-
/*
* if at the end of the tuples, return "no data found" and set
* the cursor past the end of the result set
return SQL_NO_DATA_FOUND;
}
else if (retval > 0)
- (self->currTuple)++;/* all is well */
+ (self->currTuple)++; /* all is well */
else
{
mylog("SC_fetch: error\n");
updret = SQL_ROW_DELETED;
num_cols -= 2;
}
-#endif /* DRIVER_CURSOR_IMPLEMENT */
- if (self->options.retrieve_data == SQL_RD_OFF) /* data isn't required */
+#endif /* DRIVER_CURSOR_IMPLEMENT */
+ if (self->options.retrieve_data == SQL_RD_OFF) /* data isn't required */
#ifdef DRIVER_CURSOR_IMPLEMENT
return updret ? updret + 10 : SQL_SUCCESS;
#else
- return SQL_SUCCESS;
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+ return SQL_SUCCESS;
+#endif /* DRIVER_CURSOR_IMPLEMENT */
for (lf = 0; lf < num_cols; lf++)
{
mylog("fetch: cols=%d, lf=%d, self = %u, self->bindings = %u, buffer[] = %u\n", num_cols, lf, self, self->bindings, self->bindings[lf].buffer);
/* this column has a binding */
/* type = QR_get_field_type(res, lf); */
- type = CI_get_oid(coli, lf); /* speed things up */
+ type = CI_get_oid(coli, lf); /* speed things up */
mylog("type = %d\n", type);
case COPY_RESULT_TRUNCATED:
self->errornumber = STMT_TRUNCATED;
self->errormsg = "Fetched item was truncated.";
- qlog("The %dth item was truncated\n", lf + 1);
+ qlog("The %dth item was truncated\n", lf + 1);
qlog("The buffer size = %d", self->bindings[lf].buflen);
qlog(" and the value is '%s'\n", value);
result = SQL_SUCCESS_WITH_INFO;
#ifdef DRIVER_CURSOR_IMPLEMENT
if (updret)
result = updret + 10;
-#endif /* DRIVER_CURSOR_IMPLEMENT */
+#endif /* DRIVER_CURSOR_IMPLEMENT */
return result;
}
RETCODE
-SC_execute(StatementClass *self)
+SC_execute(StatementClass * self)
{
static char *func = "SC_execute";
ConnectionClass *conn;
Int2 oldstatus,
numcols;
QueryInfo qi;
- ConnInfo *ci;
+ ConnInfo *ci;
conn = SC_get_conn(self);
* OTHER.
*/
if (!self->internal && !CC_is_in_trans(conn) &&
- (SC_is_fetchcursor(self) ||
- (!CC_is_in_autocommit(conn) && self->statement_type != STMT_TYPE_OTHER)))
+ (SC_is_fetchcursor(self) ||
+ (!CC_is_in_autocommit(conn) && self->statement_type != STMT_TYPE_OTHER)))
{
mylog(" about to begin a transaction on statement = %u\n", self);
res = CC_send_query(conn, "BEGIN", NULL);
}
if (self->statement_type == STMT_TYPE_PROCCALL &&
- (self->errornumber == STMT_OK ||
- self->errornumber == STMT_INFO_ONLY) &&
- self->parameters &&
- self->parameters[0].buffer &&
- self->parameters[0].paramType == SQL_PARAM_OUTPUT)
- { /* get the return value of the procedure call */
- RETCODE ret;
- HSTMT hstmt = (HSTMT) self;
+ (self->errornumber == STMT_OK ||
+ self->errornumber == STMT_INFO_ONLY) &&
+ self->parameters &&
+ self->parameters[0].buffer &&
+ self->parameters[0].paramType == SQL_PARAM_OUTPUT)
+ { /* get the return value of the procedure
+ * call */
+ RETCODE ret;
+ HSTMT hstmt = (HSTMT) self;
+
ret = SC_fetch(hstmt);
if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO)
- {
+ {
ret = PGAPI_GetData(hstmt, 1, self->parameters[0].CType, self->parameters[0].buffer, self->parameters[0].buflen, self->parameters[0].used);
- if (ret != SQL_SUCCESS)
+ if (ret != SQL_SUCCESS)
{
self->errornumber = STMT_EXEC_ERROR;
self->errormsg = "GetData to Procedure return failed.";
void
-SC_log_error(char *func, char *desc, StatementClass *self)
+SC_log_error(char *func, char *desc, StatementClass * self)
{
#ifdef PRN_NULLCHECK
#define nullcheck(a) (a ? a : "(NULL)")
typedef enum
{
- STMT_ALLOCATED, /* The statement handle is allocated, but
+ STMT_ALLOCATED, /* The statement handle is allocated, but
* not used so far */
- STMT_READY, /* the statement is waiting to be executed */
- STMT_PREMATURE, /* ODBC states that it is legal to call
+ STMT_READY, /* the statement is waiting to be executed */
+ STMT_PREMATURE, /* ODBC states that it is legal to call
* e.g. SQLDescribeCol before a call to
* SQLExecute, but after SQLPrepare. To
* get all the necessary information in
* query _before_ the actual call to
* SQLExecute, so that statement is
* considered to be "premature". */
- STMT_FINISHED, /* statement execution has finished */
- STMT_EXECUTING /* statement execution is still going on */
-} STMT_Status;
+ STMT_FINISHED, /* statement execution has finished */
+ STMT_EXECUTING /* statement execution is still going on */
+} STMT_Status;
#define STMT_ROW_VERSION_CHANGED (-4)
#define STMT_POS_BEFORE_RECORDSET (-3)
/* statement types */
enum
{
- STMT_TYPE_UNKNOWN = -2,
- STMT_TYPE_OTHER = -1,
- STMT_TYPE_SELECT = 0,
- STMT_TYPE_INSERT,
- STMT_TYPE_UPDATE,
- STMT_TYPE_DELETE,
- STMT_TYPE_CREATE,
- STMT_TYPE_ALTER,
- STMT_TYPE_DROP,
- STMT_TYPE_GRANT,
- STMT_TYPE_REVOKE,
- STMT_TYPE_PROCCALL
+ STMT_TYPE_UNKNOWN = -2,
+ STMT_TYPE_OTHER = -1,
+ STMT_TYPE_SELECT = 0,
+ STMT_TYPE_INSERT,
+ STMT_TYPE_UPDATE,
+ STMT_TYPE_DELETE,
+ STMT_TYPE_CREATE,
+ STMT_TYPE_ALTER,
+ STMT_TYPE_DROP,
+ STMT_TYPE_GRANT,
+ STMT_TYPE_REVOKE,
+ STMT_TYPE_PROCCALL
};
#define STMT_UPDATE(stmt) (stmt->statement_type > STMT_TYPE_SELECT)
/* Parsing status */
enum
{
- STMT_PARSE_NONE = 0,
- STMT_PARSE_COMPLETE,
- STMT_PARSE_INCOMPLETE,
- STMT_PARSE_FATAL,
+ STMT_PARSE_NONE = 0,
+ STMT_PARSE_COMPLETE,
+ STMT_PARSE_INCOMPLETE,
+ STMT_PARSE_FATAL,
};
/* Result style */
enum
{
- STMT_FETCH_NONE = 0,
- STMT_FETCH_NORMAL,
- STMT_FETCH_EXTENDED,
+ STMT_FETCH_NONE = 0,
+ STMT_FETCH_NORMAL,
+ STMT_FETCH_EXTENDED,
};
typedef struct
COL_INFO *col_info; /* cached SQLColumns info for this table */
char name[MAX_TABLE_LEN + 1];
char alias[MAX_TABLE_LEN + 1];
-} TABLE_INFO;
+} TABLE_INFO;
typedef struct
{
char dot[MAX_TABLE_LEN + 1];
char name[MAX_COLUMN_LEN + 1];
char alias[MAX_COLUMN_LEN + 1];
-} FIELD_INFO;
+} FIELD_INFO;
/******** Statement Handle ***********/
char cursor_name[MAX_CURSOR_LEN + 1];
- char *stmt_with_params; /* statement after
- * parameter
- * substitution */
- int stmt_size_limit;
+ char *stmt_with_params; /* statement after parameter
+ * substitution */
+ int stmt_size_limit;
char pre_executing; /* This statement is prematurely executing */
- char inaccurate_result; /* Current status is PREMATURE but
+ char inaccurate_result; /* Current status is PREMATURE but
* result is inaccurate */
- char errormsg_malloced; /* Current error message is malloed (not in a static variable) ? */
+ char errormsg_malloced; /* Current error message is
+ * malloed (not in a static
+ * variable) ? */
char miscinfo;
};
/* misc info */
#define SC_set_pre_executable(a) (a->miscinfo |= 1L)
-#define SC_no_pre_executable(a) (a->miscinfo &= ~1L)
-#define SC_is_pre_executable(a) ((a->miscinfo & 1L) != 0)
+#define SC_no_pre_executable(a) (a->miscinfo &= ~1L)
+#define SC_is_pre_executable(a) ((a->miscinfo & 1L) != 0)
#define SC_set_fetchcursor(a) (a->miscinfo |= 2L)
#define SC_no_fetchcursor(a) (a->miscinfo &= ~2L)
#define SC_is_fetchcursor(a) ((a->miscinfo & 2L) != 0)
/* Statement prototypes */
StatementClass *SC_Constructor(void);
-void InitializeStatementOptions(StatementOptions *opt);
-char SC_Destructor(StatementClass *self);
+void InitializeStatementOptions(StatementOptions * opt);
+char SC_Destructor(StatementClass * self);
int statement_type(char *statement);
-char parse_statement(StatementClass *stmt);
-void SC_pre_execute(StatementClass *self);
-char SC_unbind_cols(StatementClass *self);
-char SC_recycle_statement(StatementClass *self);
-
-void SC_clear_error(StatementClass *self);
-char SC_get_error(StatementClass *self, int *number, char **message);
-char *SC_create_errormsg(StatementClass *self);
-RETCODE SC_execute(StatementClass *self);
-RETCODE SC_fetch(StatementClass *self);
-void SC_free_params(StatementClass *self, char option);
-void SC_log_error(char *func, char *desc, StatementClass *self);
-unsigned long SC_get_bookmark(StatementClass *self);
-
+char parse_statement(StatementClass * stmt);
+void SC_pre_execute(StatementClass * self);
+char SC_unbind_cols(StatementClass * self);
+char SC_recycle_statement(StatementClass * self);
+
+void SC_clear_error(StatementClass * self);
+char SC_get_error(StatementClass * self, int *number, char **message);
+char *SC_create_errormsg(StatementClass * self);
+RETCODE SC_execute(StatementClass * self);
+RETCODE SC_fetch(StatementClass * self);
+void SC_free_params(StatementClass * self, char option);
+void SC_log_error(char *func, char *desc, StatementClass * self);
+unsigned long SC_get_bookmark(StatementClass * self);
#endif
void
-set_tuplefield_null(TupleField *tuple_field)
+set_tuplefield_null(TupleField * tuple_field)
{
tuple_field->len = 0;
tuple_field->value = NULL; /* strdup(""); */
void
-set_tuplefield_string(TupleField *tuple_field, char *string)
+set_tuplefield_string(TupleField * tuple_field, char *string)
{
tuple_field->len = strlen(string);
tuple_field->value = malloc(strlen(string) + 1);
void
-set_tuplefield_int2(TupleField *tuple_field, Int2 value)
+set_tuplefield_int2(TupleField * tuple_field, Int2 value)
{
char buffer[10];
void
-set_tuplefield_int4(TupleField *tuple_field, Int4 value)
+set_tuplefield_int4(TupleField * tuple_field, Int4 value)
{
char buffer[15];
#define set_nullfield_int2(FLD, VAL) ((VAL) != -1 ? set_tuplefield_int2(FLD, (VAL)) : set_tuplefield_null(FLD))
#define set_nullfield_int4(FLD, VAL) ((VAL) != -1 ? set_tuplefield_int4(FLD, (VAL)) : set_tuplefield_null(FLD))
-void set_tuplefield_null(TupleField *tuple_field);
-void set_tuplefield_string(TupleField *tuple_field, char *string);
-void set_tuplefield_int2(TupleField *tuple_field, Int2 value);
-void set_tuplefield_int4(TupleField *tuple_field, Int4 value);
-
+void set_tuplefield_null(TupleField * tuple_field);
+void set_tuplefield_string(TupleField * tuple_field, char *string);
+void set_tuplefield_int2(TupleField * tuple_field, Int2 value);
+void set_tuplefield_int4(TupleField * tuple_field, Int4 value);
#endif
void
-TL_Destructor(TupleListClass *self)
+TL_Destructor(TupleListClass * self)
{
int lf;
TupleNode *node,
void *
-TL_get_fieldval(TupleListClass *self, Int4 tupleno, Int2 fieldno)
+TL_get_fieldval(TupleListClass * self, Int4 tupleno, Int2 fieldno)
{
Int4 lf;
Int4 delta,
}
else if (start_is_closer)
{
-
/*
* the shortest way is to start the search from the head of the
* list
char
-TL_add_tuple(TupleListClass *self, TupleNode *new_field)
+TL_add_tuple(TupleListClass * self, TupleNode * new_field)
{
-
/*
* we append the tuple at the end of the doubly linked list of the
* tuples we have already read in
}
else
{
-
/*
* there is already an element in the list, so add the new one at
* the end of the list
/* Create a TupleList. Each tuple consits of fieldcnt columns */
TupleListClass *TL_Constructor(UInt4 fieldcnt);
-void TL_Destructor(TupleListClass *self);
-void *TL_get_fieldval(TupleListClass *self, Int4 tupleno, Int2 fieldno);
-char TL_add_tuple(TupleListClass *self, TupleNode *new_field);
-
+void TL_Destructor(TupleListClass * self);
+void *TL_get_fieldval(TupleListClass * self, Int4 tupleno, Int2 fieldno);
+char TL_add_tuple(TupleListClass * self, TupleNode * new_field);
#endif
projects / psqlodbc.git / commitdiff