629 lines
21 KiB
C
629 lines
21 KiB
C
/*
|
|
* $Id$
|
|
*/
|
|
|
|
/*
|
|
* Harbour Project source code
|
|
* This file contains source for first ODBC routines.
|
|
*
|
|
* Copyright 2009 Viktor Szakats (harbour syenar.net)
|
|
* Copyright 1999 Antonio Linares <alinares@fivetech.com>
|
|
* www - http://harbour-project.org
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this software; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
|
|
* Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
|
|
*
|
|
* As a special exception, the Harbour Project gives permission for
|
|
* additional uses of the text contained in its release of Harbour.
|
|
*
|
|
* The exception is that, if you link the Harbour libraries with other
|
|
* files to produce an executable, this does not by itself cause the
|
|
* resulting executable to be covered by the GNU General Public License.
|
|
* Your use of that executable is in no way restricted on account of
|
|
* linking the Harbour library code into it.
|
|
*
|
|
* This exception does not however invalidate any other reasons why
|
|
* the executable file might be covered by the GNU General Public License.
|
|
*
|
|
* This exception applies only to the code released by the Harbour
|
|
* Project under the name Harbour. If you copy code from other
|
|
* Harbour Project or Free Software Foundation releases into a copy of
|
|
* Harbour, as the General Public License permits, the exception does
|
|
* not apply to the code that you add in this way. To avoid misleading
|
|
* anyone as to the status of such modified files, you must delete
|
|
* this exception notice from them.
|
|
*
|
|
* If you write modifications of your own for Harbour, it is your choice
|
|
* whether to permit this exception to apply to your modifications.
|
|
* If you do not wish that, delete this exception notice.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* The following parts are Copyright of the individual authors.
|
|
* www - http://harbour-project.org
|
|
*
|
|
* Copyright 1999 Felipe G. Coury <fcoury@creation.com.br>
|
|
* SQLNUMRESULTCOLS()
|
|
* SQLDESCRIBECOL()
|
|
*
|
|
* Copyright 1996 Marcelo Lombardo <lombardo@uol.com.br>
|
|
* SQLGETINFO()
|
|
* SQLSETCONNECTOPTION()
|
|
* SQLSETSTMTOPTION()
|
|
* SQLGETCONNECTOPTION()
|
|
* SQLGETSTMTOPTION()
|
|
* SQLCOMMIT()
|
|
* SQLROLLBACK()
|
|
* SQLCOLATTRIBUTE()
|
|
* SQLBINDOUTPARAM()
|
|
* SQLMORERESULTS()
|
|
*
|
|
* See COPYING for licensing terms.
|
|
*/
|
|
|
|
#include "hbapi.h"
|
|
#include "hbapistr.h"
|
|
#include "hbset.h"
|
|
|
|
/* Required by headers on Windows */
|
|
#if defined( HB_OS_WIN )
|
|
|
|
/* NOTE: Workaround for OpenWatcom's (tested with 1.9) odbc32.lib implib
|
|
missing the entry for wide version of one function,
|
|
so we turn off UNICODE, until its fixed in OpenWatcom:
|
|
Error! E2028: _SQLSetStmtAttrW@16 is an undefined reference
|
|
[vszakats] */
|
|
# if defined( __WATCOMC__ ) && defined( UNICODE )
|
|
# undef UNICODE
|
|
# endif
|
|
|
|
# include <windows.h>
|
|
/* Required for WIN32_LEAN_AND_MEAN mode */
|
|
# if ! defined( WIN32 )
|
|
# define WIN32
|
|
# endif
|
|
#endif
|
|
|
|
#include <sql.h>
|
|
#include <sqlext.h>
|
|
|
|
#if !defined( HB_OS_WIN )
|
|
# if !defined( SQLLEN ) && !defined( SQLTCHAR )
|
|
typedef unsigned char SQLTCHAR;
|
|
# endif
|
|
#endif
|
|
|
|
#ifndef SQL_NO_DATA
|
|
# define SQL_NO_DATA SQL_NO_DATA_FOUND
|
|
#endif
|
|
|
|
#if defined( UNICODE )
|
|
#define O_HB_PARSTR( n, h, len ) hb_parstr_u16( n, HB_CDP_ENDIAN_NATIVE, h, len )
|
|
#define O_HB_PARSTRDEF( n, h, len ) hb_wstrnull( hb_parstr_u16( n, HB_CDP_ENDIAN_NATIVE, h, len ) )
|
|
#define O_HB_STORSTR( str, n ) hb_storstr_u16( HB_CDP_ENDIAN_NATIVE, str, n )
|
|
#define O_HB_STORSTRLEN( str, len, n ) hb_storstrlen_u16( HB_CDP_ENDIAN_NATIVE, str, len, n )
|
|
#define O_HB_ARRAYGETSTR( arr, n, phstr, plen ) hb_arrayGetStrU16( arr, n, HB_CDP_ENDIAN_NATIVE, phstr, plen )
|
|
#define O_HB_ITEMCOPYSTR( itm, str, len ) hb_itemCopyStrU16( itm, HB_CDP_ENDIAN_NATIVE, str, len )
|
|
#define O_HB_ITEMGETSTR( itm, phstr, plen ) hb_itemGetStrU16( itm, HB_CDP_ENDIAN_NATIVE, phstr, plen )
|
|
#define O_HB_ITEMPUTSTR( itm, str ) hb_itemPutStrU16( itm, HB_CDP_ENDIAN_NATIVE, str )
|
|
#define O_HB_ITEMPUTSTRLEN( itm, str, len ) hb_itemPutStrLenU16( itm, HB_CDP_ENDIAN_NATIVE, str, len )
|
|
#define O_HB_CHAR HB_WCHAR
|
|
#else
|
|
#define O_HB_PARSTR( n, h, len ) hb_parstr( n, hb_setGetOSCP(), h, len )
|
|
#define O_HB_PARSTRDEF( n, h, len ) hb_strnull( hb_parstr( n, hb_setGetOSCP(), h, len ) )
|
|
#define O_HB_STORSTR( str, n ) hb_storstr( hb_setGetOSCP(), str, n )
|
|
#define O_HB_STORSTRLEN( str, len, n ) hb_storstrlen( hb_setGetOSCP(), str, len, n )
|
|
#define O_HB_ARRAYGETSTR( arr, n, phstr, plen ) hb_arrayGetStr( arr, n, hb_setGetOSCP(), phstr, plen )
|
|
#define O_HB_ITEMCOPYSTR( itm, str, len ) hb_itemCopyStr( itm, hb_setGetOSCP(), str, len )
|
|
#define O_HB_ITEMGETSTR( itm, phstr, plen ) hb_itemGetStr( itm, hb_setGetOSCP(), phstr, plen )
|
|
#define O_HB_ITEMPUTSTR( itm, str ) hb_itemPutStr( itm, hb_setGetOSCP(), str )
|
|
#define O_HB_ITEMPUTSTRLEN( itm, str, len ) hb_itemPutStrLen( itm, hb_setGetOSCP(), str, len )
|
|
#define O_HB_CHAR char
|
|
#endif
|
|
|
|
HB_FUNC( SQLALLOCENV ) /* @hEnv --> nRetCode */
|
|
{
|
|
SQLHENV hEnv;
|
|
hb_retni( SQLAllocEnv( &hEnv ) );
|
|
hb_storptr( ( void * ) hEnv, 1 );
|
|
}
|
|
|
|
HB_FUNC( SQLALLOCCONNECT ) /* hEnv, @hDbc --> nRetCode */
|
|
{
|
|
SQLHDBC hDbc;
|
|
hb_retni( SQLAllocConnect( ( SQLHENV ) hb_parptr( 1 ), &hDbc ) );
|
|
hb_storptr( ( void * ) hDbc, 2 );
|
|
}
|
|
|
|
HB_FUNC( SQLDRIVERCONNECT ) /* hDbc, @cConnectString --> nRetCode */
|
|
{
|
|
SQLSMALLINT iLen;
|
|
SQLRETURN ret;
|
|
void * hConnStr;
|
|
SQLTCHAR buffer[ 1024 ];
|
|
|
|
buffer[ 0 ] = '\0';
|
|
|
|
ret = SQLDriverConnect( ( SQLHDBC ) hb_parptr( 1 ),
|
|
( SQLHWND ) NULL,
|
|
( SQLTCHAR * ) O_HB_PARSTRDEF( 2, &hConnStr, NULL ),
|
|
( SQLSMALLINT ) hb_parclen( 2 ),
|
|
( SQLTCHAR * ) buffer,
|
|
( SQLSMALLINT ) HB_SIZEOFARRAY( buffer ),
|
|
( SQLSMALLINT * ) &iLen,
|
|
( SQLUSMALLINT ) SQL_DRIVER_COMPLETE );
|
|
|
|
hb_strfree( hConnStr );
|
|
|
|
O_HB_STORSTR( ( O_HB_CHAR * ) buffer, 3 );
|
|
|
|
hb_retni( ret );
|
|
}
|
|
|
|
HB_FUNC( SQLCONNECT ) /* hDbc, cDSN, cUseName, cPassword --> nRetCode */
|
|
{
|
|
SQLRETURN ret;
|
|
|
|
void * hDSN;
|
|
void * hUser;
|
|
void * hPass;
|
|
|
|
ret = SQLConnect( ( SQLHDBC ) hb_parptr( 1 ),
|
|
( SQLTCHAR * ) O_HB_PARSTRDEF( 2, &hDSN, NULL ),
|
|
( SQLSMALLINT ) hb_parclen( 2 ),
|
|
( SQLTCHAR * ) O_HB_PARSTRDEF( 3, &hUser, NULL ),
|
|
( SQLSMALLINT ) hb_parclen( 3 ),
|
|
( SQLTCHAR * ) O_HB_PARSTRDEF( 4, &hPass, NULL ),
|
|
( SQLSMALLINT ) hb_parclen( 4 ) );
|
|
|
|
hb_strfree( hDSN );
|
|
hb_strfree( hUser );
|
|
hb_strfree( hPass );
|
|
|
|
hb_retni( ret );
|
|
}
|
|
|
|
HB_FUNC( SQLDISCONNECT ) /* hDbc --> nRetCode */
|
|
{
|
|
hb_retni( SQLDisconnect( ( SQLHDBC ) hb_parptr( 1 ) ) );
|
|
}
|
|
|
|
HB_FUNC( SQLFREECONNECT ) /* hDbc --> nRetCode */
|
|
{
|
|
hb_retni( SQLFreeConnect( ( SQLHDBC ) hb_parptr( 1 ) ) );
|
|
}
|
|
|
|
HB_FUNC( SQLFREEENV ) /* hEnv --> nRetCode */
|
|
{
|
|
hb_retni( SQLFreeEnv( ( SQLHENV ) hb_parptr( 1 ) ) );
|
|
}
|
|
|
|
HB_FUNC( SQLALLOCSTMT ) /* hDbc, @hStmt --> nRetCode */
|
|
{
|
|
SQLHSTMT hStmt;
|
|
hb_retni( SQLAllocStmt( ( SQLHDBC ) hb_parptr( 1 ), &hStmt ) );
|
|
hb_storptr( ( void * ) hStmt, 2 );
|
|
}
|
|
|
|
HB_FUNC( SQLFREESTMT ) /* hStmt, nType --> nRetCode */
|
|
{
|
|
hb_retni( SQLFreeStmt( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLUSMALLINT ) hb_parni( 2 ) ) );
|
|
}
|
|
|
|
HB_FUNC( SQLEXECDIRECT ) /* hStmt, cStatement --> nRetCode */
|
|
{
|
|
void * hStatement;
|
|
hb_retni( SQLExecDirect( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLTCHAR * ) O_HB_PARSTRDEF( 2, &hStatement, NULL ),
|
|
( SQLINTEGER ) hb_parclen( 2 ) ) );
|
|
hb_strfree( hStatement );
|
|
}
|
|
|
|
HB_FUNC( SQLFETCH ) /* hStmt --> nRetCode */
|
|
{
|
|
hb_retni( SQLFetch( ( SQLHSTMT ) hb_parptr( 1 ) ) );
|
|
}
|
|
|
|
HB_FUNC( SQLGETDATA ) /* hStmt, nField, nType, nLen, @cBuffer --> nRetCode */
|
|
{
|
|
SQLLEN nLen;
|
|
SQLLEN nInitBuff;
|
|
SQLLEN nBuffLen = 0;
|
|
char * buffer;
|
|
char * outbuf = NULL;
|
|
SQLSMALLINT iType = ( SQLSMALLINT ) hb_parnidef( 3, SQL_BINARY );
|
|
int iReallocs = 0;
|
|
SQLRETURN result;
|
|
|
|
nLen = ( SQLLEN ) hb_parnint( 4 );
|
|
if( nLen <= 0 )
|
|
nLen = 64;
|
|
nInitBuff = nLen;
|
|
buffer = ( char * ) hb_xgrab( ( HB_SIZE ) nLen + 1 );
|
|
|
|
result = ! SQL_NO_DATA;
|
|
while( result != SQL_NO_DATA )
|
|
{
|
|
result = SQLGetData( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLUSMALLINT ) hb_parni( 2 ),
|
|
( SQLSMALLINT ) iType,
|
|
( SQLPOINTER ) buffer,
|
|
( SQLLEN ) nLen,
|
|
( SQLLEN * ) &nLen );
|
|
|
|
if( result == SQL_SUCCESS && iReallocs == 0 )
|
|
{
|
|
hb_storclen( buffer, ( HB_SIZE ) ( nLen < 0 ? 0 : ( nLen < ( SQLLEN ) hb_parnint( 4 ) ? nLen : ( SQLLEN ) hb_parnint( 4 ) ) ), 5 );
|
|
break;
|
|
}
|
|
else if( result == SQL_SUCCESS_WITH_INFO && iReallocs == 0 )
|
|
{
|
|
/* Perhaps a data truncation */
|
|
if( nLen >= nInitBuff )
|
|
{
|
|
/* data right truncated! */
|
|
nBuffLen = nLen;
|
|
outbuf = ( char * ) hb_xgrab( ( HB_SIZE ) nBuffLen + 1 );
|
|
hb_strncpy( outbuf, buffer, nLen );
|
|
nLen = nLen - nInitBuff + 2;
|
|
buffer = ( char * ) hb_xrealloc( buffer, ( HB_SIZE ) nLen );
|
|
iReallocs++;
|
|
}
|
|
else
|
|
{
|
|
hb_storclen( buffer, ( HB_SIZE ) ( nLen < 0 ? 0 : ( nLen < ( SQLLEN ) hb_parnint( 4 ) ? nLen : ( SQLLEN ) hb_parnint( 4 ) ) ), 5 );
|
|
break;
|
|
}
|
|
}
|
|
else if( ( result == SQL_SUCCESS || result == SQL_SUCCESS_WITH_INFO ) && iReallocs > 0 )
|
|
{
|
|
hb_strncat( outbuf, buffer, nBuffLen );
|
|
hb_storclen( outbuf, ( HB_SIZE ) ( nLen + nInitBuff - 1 ), 5 );
|
|
result = SQL_SUCCESS;
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
hb_xfree( buffer );
|
|
if( outbuf )
|
|
hb_xfree( outbuf );
|
|
hb_retni( result );
|
|
}
|
|
|
|
HB_FUNC( SQLNUMRESULTCOLS ) /* hStmt, @nColCount --> nRetCode */
|
|
{
|
|
SQLSMALLINT iCols = 0;
|
|
|
|
hb_retni( SQLNumResultCols( ( SQLHSTMT ) hb_parptr( 1 ), &iCols ) );
|
|
|
|
hb_stornl( ( long ) iCols, 2 );
|
|
}
|
|
|
|
HB_FUNC( SQLDESCRIBECOL ) /* hStmt, nCol, @cName, nLen, @nBufferLen, @nDataType, @nColSize, @nDec, @nNull --> nRetCode */
|
|
{
|
|
SQLSMALLINT iLen = ( SQLSMALLINT ) hb_parni( 4 );
|
|
SQLSMALLINT iBufLen = ( SQLUSMALLINT ) hb_parni( 5 );
|
|
SQLSMALLINT iDataType = ( SQLUSMALLINT ) hb_parni( 6 );
|
|
SQLULEN nColSize = ( SQLULEN ) hb_parnint( 7 );
|
|
SQLSMALLINT iDecimals = ( SQLUSMALLINT ) hb_parni( 8 );
|
|
SQLSMALLINT iNullable = ( SQLUSMALLINT ) hb_parni( 9 );
|
|
SQLTCHAR * buffer;
|
|
|
|
if( iLen <= 0 )
|
|
iLen = 64;
|
|
|
|
buffer = ( SQLTCHAR * ) hb_xgrab( iLen * sizeof( SQLTCHAR ) );
|
|
buffer[ 0 ] = '\0';
|
|
|
|
hb_retni( SQLDescribeCol( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLUSMALLINT ) hb_parni( 2 ),
|
|
( SQLTCHAR * ) buffer,
|
|
( SQLSMALLINT ) iLen,
|
|
( SQLSMALLINT * ) &iBufLen,
|
|
( SQLSMALLINT * ) &iDataType,
|
|
( SQLULEN * ) &nColSize,
|
|
( SQLSMALLINT * ) &iDecimals,
|
|
( SQLSMALLINT * ) &iNullable ) );
|
|
|
|
O_HB_STORSTRLEN( ( O_HB_CHAR * ) buffer, ( HB_SIZE ) iBufLen, 3 );
|
|
hb_storni( ( int ) iBufLen, 5 );
|
|
hb_storni( ( int ) iDataType, 6 );
|
|
hb_stornint( nColSize, 7 );
|
|
hb_storni( ( int ) iDecimals, 8 );
|
|
hb_storni( ( int ) iNullable, 9 );
|
|
|
|
hb_xfree( buffer );
|
|
}
|
|
|
|
HB_FUNC( SQLCOLATTRIBUTE ) /* hStmt, nCol, nField, @cName, nLen, @nBufferLen, @nAttribute --> nRetCode */
|
|
{
|
|
SQLSMALLINT iLen = ( SQLSMALLINT ) hb_parni( 5 );
|
|
SQLSMALLINT iBufLen = ( SQLUSMALLINT ) hb_parni( 6 );
|
|
#if ODBCVER >= 0x0300
|
|
SQLLEN nNumPtr = ( SQLLEN ) hb_parnint( 7 );
|
|
#else
|
|
SQLINTEGER nNumPtr = ( SQLINTEGER ) hb_parnl( 7 );
|
|
#endif
|
|
char * buffer;
|
|
|
|
if( iLen <= 0 )
|
|
iLen = 64;
|
|
|
|
buffer = ( char * ) hb_xgrab( iLen );
|
|
buffer[ 0 ] = '\0';
|
|
|
|
#if ODBCVER >= 0x0300
|
|
hb_retni( SQLColAttribute( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLUSMALLINT ) hb_parni( 2 ),
|
|
( SQLUSMALLINT ) hb_parni( 3 ),
|
|
( SQLPOINTER ) buffer,
|
|
iLen,
|
|
( SQLSMALLINT * ) &iBufLen,
|
|
( SQLLEN * ) &nNumPtr ) );
|
|
#else
|
|
hb_retni( SQLColAttributes( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLUSMALLINT ) hb_parni( 2 ),
|
|
( SQLUSMALLINT ) hb_parni( 3 ),
|
|
( SQLPOINTER ) buffer,
|
|
iLen,
|
|
( SQLSMALLINT * ) &iBufLen,
|
|
( SQLINTEGER * ) &nNumPtr ) );
|
|
#endif
|
|
|
|
hb_storclen( buffer, ( HB_SIZE ) iBufLen, 4 );
|
|
hb_storni( ( int ) iBufLen, 6 );
|
|
hb_stornint( nNumPtr, 7 );
|
|
|
|
hb_xfree( buffer );
|
|
}
|
|
|
|
HB_FUNC( SQLFETCHSCROLL )
|
|
{
|
|
#if ODBCVER >= 0x0300
|
|
hb_retni( SQLFetchScroll( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLSMALLINT ) hb_parni( 2 ),
|
|
( SQLLEN ) hb_parnint( 3 ) ) );
|
|
#else
|
|
hb_retni( SQL_ERROR );
|
|
#endif
|
|
}
|
|
|
|
HB_FUNC( SQLERROR ) /* hEnv, hDbc, hStmt, @cErrorClass, @nType, @cErrorMsg */
|
|
{
|
|
SQLINTEGER lError;
|
|
SQLSMALLINT iLen;
|
|
SQLTCHAR buffer[ 256 ];
|
|
SQLTCHAR szErrorMsg[ SQL_MAX_MESSAGE_LENGTH + 1 ];
|
|
|
|
buffer[ 0 ] = '\0';
|
|
szErrorMsg[ 0 ] = '\0';
|
|
iLen = 0;
|
|
|
|
hb_retni( SQLError( ( SQLHENV ) hb_parptr( 1 ),
|
|
( SQLHDBC ) hb_parptr( 2 ),
|
|
( SQLHSTMT ) hb_parptr( 3 ),
|
|
( SQLTCHAR * ) buffer,
|
|
( SQLINTEGER * ) &lError,
|
|
( SQLTCHAR * ) szErrorMsg,
|
|
( SQLSMALLINT ) sizeof( szErrorMsg ),
|
|
( SQLSMALLINT * ) &iLen ) );
|
|
|
|
O_HB_STORSTR( ( O_HB_CHAR * ) buffer, 4 );
|
|
hb_stornl( ( long ) lError, 5 );
|
|
O_HB_STORSTRLEN( ( O_HB_CHAR * ) szErrorMsg, iLen, 6 );
|
|
}
|
|
|
|
HB_FUNC( SQLGETDIAGREC ) /* nHandleType, hHandle, nRecNumber, @cSQLState, @nError, @cErrorMsg */
|
|
{
|
|
SQLTCHAR szSQLState[ 5 + 1 ];
|
|
SQLINTEGER lError;
|
|
SQLTCHAR szErrorMsg[ SQL_MAX_MESSAGE_LENGTH + 1 ];
|
|
SQLSMALLINT iLen;
|
|
|
|
szSQLState[ 0 ] = '\0';
|
|
szErrorMsg[ 0 ] = '\0';
|
|
iLen = 0;
|
|
|
|
hb_retni( SQLGetDiagRec( ( SQLSMALLINT ) hb_parni( 1 ),
|
|
( SQLHANDLE ) ( HB_PTRUINT ) hb_parptr( 2 ),
|
|
( SQLSMALLINT) hb_parni( 3 ),
|
|
( SQLTCHAR * ) szSQLState,
|
|
( SQLINTEGER * ) &lError,
|
|
( SQLTCHAR * ) szErrorMsg,
|
|
( SQLSMALLINT ) sizeof( szErrorMsg ),
|
|
( SQLSMALLINT * ) &iLen ) );
|
|
|
|
O_HB_STORSTR( ( O_HB_CHAR * ) szSQLState, 4 );
|
|
hb_stornl( ( long ) lError, 5 );
|
|
O_HB_STORSTRLEN( ( O_HB_CHAR * ) szErrorMsg, iLen, 6 );
|
|
}
|
|
|
|
HB_FUNC( SQLROWCOUNT )
|
|
{
|
|
SQLLEN iRowCountPtr = ( SQLLEN ) hb_parnint( 2 );
|
|
|
|
hb_retni( SQLRowCount( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLLEN * ) &iRowCountPtr ) );
|
|
|
|
hb_stornint( iRowCountPtr, 2 );
|
|
}
|
|
|
|
HB_FUNC( SQLGETINFO ) /* hDbc, nType, @cResult */
|
|
{
|
|
char buffer[ 512 ];
|
|
SQLSMALLINT iLen = 0;
|
|
buffer[ 0 ] = '\0';
|
|
|
|
hb_retni( SQLGetInfo( ( SQLHDBC ) hb_parptr( 1 ),
|
|
( SQLUSMALLINT ) hb_parni( 2 ),
|
|
( SQLPOINTER ) buffer,
|
|
( SQLSMALLINT ) sizeof( buffer ),
|
|
( SQLSMALLINT * ) &iLen ) );
|
|
|
|
hb_storclen( buffer, iLen, 3 );
|
|
}
|
|
|
|
HB_FUNC( SQLSETCONNECTATTR ) /* hDbc, nOption, uOption */
|
|
{
|
|
#if ODBCVER >= 0x0300
|
|
hb_retni( SQLSetConnectAttr( ( SQLHDBC ) hb_parptr( 1 ),
|
|
( SQLINTEGER ) hb_parnl( 2 ),
|
|
HB_ISCHAR( 3 ) ? ( SQLPOINTER ) hb_parc( 3 ) : ( SQLPOINTER ) ( HB_PTRUINT ) hb_parnint( 3 ),
|
|
HB_ISCHAR( 3 ) ? ( SQLINTEGER ) hb_parclen( 3 ) : ( SQLINTEGER ) SQL_IS_INTEGER ) );
|
|
#else
|
|
hb_retni( SQLSetConnectOption( ( SQLHDBC ) hb_parptr( 1 ),
|
|
( SQLUSMALLINT ) hb_parni( 2 ),
|
|
( SQLULEN ) HB_ISCHAR( 3 ) ? ( SQLULEN ) hb_parc( 3 ) : hb_parnl( 3 ) ) );
|
|
#endif
|
|
}
|
|
|
|
HB_FUNC( SQLSETSTMTATTR ) /* hStmt, nOption, uOption --> nRetCode */
|
|
{
|
|
#if ODBCVER >= 0x0300
|
|
hb_retni( SQLSetStmtAttr( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLINTEGER ) hb_parnl( 2 ),
|
|
HB_ISCHAR( 3 ) ? ( SQLPOINTER ) hb_parc( 3 ) : ( SQLPOINTER ) ( HB_PTRUINT ) hb_parnint( 3 ),
|
|
HB_ISCHAR( 3 ) ? ( SQLINTEGER ) hb_parclen( 3 ) : ( SQLINTEGER ) SQL_IS_INTEGER ) );
|
|
#else
|
|
hb_retni( SQLSetStmtOption( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLUSMALLINT ) hb_parni( 2 ),
|
|
( SQLULEN ) HB_ISCHAR( 3 ) ? ( SQLULEN ) hb_parc( 3 ) : hb_parnl( 3 ) ) );
|
|
#endif
|
|
}
|
|
|
|
HB_FUNC( SQLGETCONNECTATTR ) /* hDbc, nOption, @cOption */
|
|
{
|
|
#if ODBCVER >= 0x0300
|
|
SQLPOINTER buffer[ 512 ];
|
|
SQLINTEGER lLen = 0;
|
|
buffer[ 0 ] = '\0';
|
|
hb_retni( SQLGetConnectAttr( ( SQLHDBC ) hb_parptr( 1 ),
|
|
( SQLINTEGER ) hb_parnl( 2 ),
|
|
( SQLPOINTER ) buffer,
|
|
( SQLINTEGER ) sizeof( buffer ),
|
|
( SQLINTEGER * ) &lLen ) );
|
|
hb_storclen( ( char * ) buffer, lLen, 3 );
|
|
#else
|
|
char buffer[ 512 ];
|
|
buffer[ 0 ] = '\0';
|
|
hb_retni( SQLGetConnectOption( ( SQLHDBC ) hb_parptr( 1 ),
|
|
( SQLSMALLINT ) hb_parni( 2 ),
|
|
( SQLPOINTER ) buffer ) );
|
|
hb_storc( buffer, 3 );
|
|
#endif
|
|
}
|
|
|
|
HB_FUNC( SQLGETSTMTATTR ) /* hStmt, nOption, @cOption */
|
|
{
|
|
#if ODBCVER >= 0x0300
|
|
SQLPOINTER buffer[ 512 ];
|
|
SQLINTEGER lLen = 0;
|
|
buffer[ 0 ] = '\0';
|
|
hb_retni( SQLGetStmtAttr( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLINTEGER ) hb_parnl( 2 ),
|
|
( SQLPOINTER ) buffer,
|
|
( SQLINTEGER ) sizeof( buffer ),
|
|
( SQLINTEGER * ) &lLen ) );
|
|
hb_storclen( ( char * ) buffer, lLen, 3 );
|
|
#else
|
|
char buffer[ 512 ];
|
|
buffer[ 0 ] = '\0';
|
|
hb_retni( SQLGetStmtOption( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLSMALLINT ) hb_parni( 2 ),
|
|
( SQLPOINTER ) buffer ) );
|
|
hb_storc( buffer, 3 );
|
|
#endif
|
|
}
|
|
|
|
HB_FUNC( SQLCOMMIT ) /* hEnv, hDbc */
|
|
{
|
|
hb_retni( SQLTransact( ( SQLHENV ) hb_parptr( 1 ), ( SQLHDBC ) hb_parptr( 2 ), SQL_COMMIT ) );
|
|
}
|
|
|
|
HB_FUNC( SQLROLLBACK ) /* hEnv, hDbc */
|
|
{
|
|
hb_retni( SQLTransact( ( SQLHENV ) hb_parptr( 1 ), ( SQLHDBC ) hb_parptr( 2 ), SQL_ROLLBACK ) );
|
|
}
|
|
|
|
HB_FUNC( SQLPREPARE ) /* hStmt, cStatement --> nRetCode */
|
|
{
|
|
void * hStatement;
|
|
hb_retni( SQLPrepare( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLTCHAR * ) O_HB_PARSTRDEF( 2, &hStatement, NULL ),
|
|
( SQLINTEGER ) SQL_NTS ) );
|
|
hb_strfree( hStatement );
|
|
}
|
|
|
|
HB_FUNC( SQLEXECUTE ) /* hStmt --> nRetCode */
|
|
{
|
|
hb_retni( SQLExecute( ( SQLHSTMT ) hb_parptr( 1 ) ) );
|
|
}
|
|
|
|
HB_FUNC( SQLMORERESULTS ) /* hEnv, hDbc */
|
|
{
|
|
hb_retni( SQLMoreResults( ( SQLHSTMT ) hb_parptr( 1 ) ) );
|
|
}
|
|
|
|
HB_FUNC( SQLBINDPARAMETER ) /* nStatementHandle, nParameterNumber, nParameterType, ColumnSize, DecimalDigits, @ParamValue, @ParamLength --> nRetCode */
|
|
{
|
|
SQLLEN nLen = ( SQLLEN ) hb_parnint( 7 );
|
|
hb_retni( SQLBindParameter( ( SQLHSTMT ) hb_parptr( 1 ),
|
|
( SQLUSMALLINT ) hb_parni( 2 ),
|
|
( SQLSMALLINT ) SQL_PARAM_OUTPUT,
|
|
( SQLSMALLINT ) SQL_CHAR,
|
|
( SQLSMALLINT ) hb_parni( 3 ),
|
|
( SQLULEN ) hb_parnint( 4 ),
|
|
( SQLSMALLINT ) hb_parni( 5 ),
|
|
( SQLPOINTER ) hb_parcx( 6 ),
|
|
( SQLLEN ) hb_parclen( 6 ),
|
|
( SQLLEN * ) &nLen ) );
|
|
hb_stornint( nLen, 7 );
|
|
}
|
|
|
|
HB_FUNC( HB_ODBCSTOD )
|
|
{
|
|
if( hb_parclen( 1 ) >= 10 )
|
|
{
|
|
const char * szSqlDate = hb_parc( 1 ); /* YYYY-MM-DD */
|
|
char szHrbDate[ 9 ]; /* YYYYMMDD */
|
|
|
|
szHrbDate[ 0 ] = szSqlDate[ 0 ];
|
|
szHrbDate[ 1 ] = szSqlDate[ 1 ];
|
|
szHrbDate[ 2 ] = szSqlDate[ 2 ];
|
|
szHrbDate[ 3 ] = szSqlDate[ 3 ];
|
|
szHrbDate[ 4 ] = szSqlDate[ 5 ];
|
|
szHrbDate[ 5 ] = szSqlDate[ 6 ];
|
|
szHrbDate[ 6 ] = szSqlDate[ 8 ];
|
|
szHrbDate[ 7 ] = szSqlDate[ 9 ];
|
|
szHrbDate[ 8 ] = '\0';
|
|
hb_retds( szHrbDate );
|
|
}
|
|
else
|
|
hb_retds( NULL );
|
|
}
|
|
|
|
HB_FUNC( HB_ODBCNUMSETLEN ) /* nValue, nSize, nDecimals --> nValue (nSize, nDec) */
|
|
{
|
|
hb_retnlen( hb_parnd( 1 ), hb_parni( 2 ), hb_parni( 3 ) );
|
|
}
|
|
|
|
HB_FUNC( HB_ODBCVER )
|
|
{
|
|
hb_retni( ODBCVER );
|
|
}
|