static PHB_ITEM hb_i18n_serialize( PHB_I18N_TRANS pI18N )
{
if( pI18N )
{
HB_SIZE nSize;
HB_U32 ulCRC;
char * pBuffer = hb_itemSerialize( pI18N->table, 0, &nSize );
char * pI18Nbuffer;
PHB_ITEM pKey, pValue;
ulCRC = hb_crc32( 0, pBuffer, nSize );
pI18Nbuffer = ( char * ) memset( hb_xgrab( nSize + HB_I18N_HEADER_SIZE + 1 ),
0, HB_I18N_HEADER_SIZE );
memcpy( pI18Nbuffer + HB_I18N_HEADER_SIZE, pBuffer, nSize );
hb_xfree( pBuffer );
memcpy( pI18Nbuffer, s_signature, HB_I18N_SIG_SIZE );
HB_PUT_LE_UINT32( &pI18Nbuffer[ HB_I18N_SIZE_OFFSET ], nSize );
HB_PUT_LE_UINT32( &pI18Nbuffer[ HB_I18N_CRC_OFFSET ], ulCRC );
pKey = hb_itemPutCConst( NULL, "DESCRIPTION" );
pValue = hb_hashGetItemPtr( pI18N->table, pKey, 0 );
if( pValue )
hb_strncpy( &pI18Nbuffer[ HB_I18N_TXT_OFFSET ],
hb_itemGetCPtr( pValue ), HB_I18N_TXT_SIZE );
return hb_itemPutCLPtr( pKey, pI18Nbuffer, nSize + HB_I18N_HEADER_SIZE );
}
return NULL;
}
static void hb_i18n_transitm( PHB_ITEM pText, PHB_CODEPAGE cdpIn, PHB_CODEPAGE cdpOut )
{
HB_SIZE nLen = hb_itemGetCLen( pText );
if( nLen > 0 )
{
char * szValue = hb_cdpnDup( hb_itemGetCPtr( pText ), &nLen,
cdpIn, cdpOut );
hb_itemPutCLPtr( pText, szValue, nLen );
}
}
/*
* Add <pItem> to array <pReturn> at pos <uiPos>
* AddToArray( <pItem>, <pReturn>, <uiPos> )
*/
static void AddToArray( PHB_ITEM pItem, PHB_ITEM pReturn, HB_SIZE nPos )
{
HB_TRACE( HB_TR_DEBUG, ( "AddToArray(%p, %p, %" HB_PFS "u)", pItem, pReturn, nPos ) );
if( HB_IS_SYMBOL( pItem ) ) /* Symbol is pushed as text */
{
PHB_ITEM pArrayItem = hb_arrayGetItemPtr( pReturn, nPos );
if( pArrayItem )
{
HB_SIZE nLen = strlen( pItem->item.asSymbol.value->szName ) + 2;
char * szBuff = ( char * ) hb_xgrab( nLen + 1 );
hb_snprintf( szBuff, nLen + 1, "[%s]", pItem->item.asSymbol.value->szName );
hb_itemPutCLPtr( pArrayItem, szBuff, nLen );
}
}
else /* Normal types */
hb_itemArrayPut( pReturn, nPos, pItem );
}
static void STAItm( PHB_ITEM pItmPar )
{
HB_UINT i, ulItmPar = ( HB_UINT ) hb_itemGetCLen( pItmPar );
const char * cItmPar = hb_itemGetCPtr( pItmPar ), * c;
char * cRes;
for( i = 3, c = cItmPar; *c; c++ )
{
if( *c == '\'' )
i++; /* Count ' Tokens */
}
cRes = ( char * ) hb_xgrab( ulItmPar + i * sizeof( char ) );
i = 0; c = cItmPar; cRes[ i++ ] = '\'';
while( *c )
{
if( *c == '\'' )
cRes[ i++ ] = '\'';
cRes[ i++ ] = *c++;
}
cRes[ i++ ] = '\''; /* cRes[i] = '\0'; */
hb_itemPutCLPtr( pItmPar, cRes, i );
}
static PHB_ITEM hb_i18n_pluralexp_compile( PHB_ITEM pExp )
{
HB_SIZE nLen = hb_itemGetCLen( pExp );
PHB_ITEM pBlock = NULL;
if( nLen > 0 )
{
char * szMacro = ( char * ) hb_xgrab( nLen + 6 );
const char * szType;
PHB_ITEM pMacro;
szMacro[ 0 ] = '{';
szMacro[ 1 ] = '|';
szMacro[ 2 ] = 'n';
szMacro[ 3 ] = '|';
memcpy( &szMacro[ 4 ], hb_itemGetCPtr( pExp ), nLen );
szMacro[ 4 + nLen ] = '}';
szMacro[ 5 + nLen ] = '\0';
pMacro = hb_itemPutCLPtr( NULL, szMacro, nLen );
szType = hb_macroGetType( pMacro );
if( *szType == 'B' )
{
hb_vmPush( pMacro );
hb_macroGetValue( hb_stackItemFromTop( -1 ), 0, 0 );
if( hb_vmRequestQuery() == 0 )
{
pExp = hb_stackItemFromTop( -1 );
if( HB_IS_BLOCK( pExp ) )
pBlock = hb_itemNew( pExp );
hb_stackPop();
}
}
hb_itemRelease( pMacro );
}
return pBlock;
}
static HB_ERRCODE sqlite3Open( SQLBASEAREAP pArea )
{
sqlite3 * pDb = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pDb;
sqlite3_stmt * st = NULL;
SDDDATA * pSDDData;
const char * pszQuery;
HB_SIZE nQueryLen;
void * hQuery;
HB_USHORT uiFields, uiIndex;
PHB_ITEM pItemEof, pItem, pName = NULL;
HB_ERRCODE errCode;
char * szError;
HB_BOOL bError;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
pItem = hb_itemPutC( NULL, pArea->szQuery );
pszQuery = S_HB_ITEMGETSTR( pItem, &hQuery, &nQueryLen );
if( sqlite3_prepare_v2( pDb, pszQuery, ( int ) nQueryLen, &st, NULL ) != SQLITE_OK )
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
else
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
}
if( sqlite3_step( st ) != SQLITE_ROW )
{
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
uiFields = ( HB_USHORT ) sqlite3_column_count( st );
SELF_SETFIELDEXTENT( &pArea->area, uiFields );
errCode = 0;
bError = HB_FALSE;
pItemEof = hb_itemArrayNew( uiFields );
for( uiIndex = 0; uiIndex < uiFields; ++uiIndex )
{
DBFIELDINFO dbFieldInfo;
memset( &dbFieldInfo, 0, sizeof( dbFieldInfo ) );
pName = S_HB_ITEMPUTSTR( pName, sqlite3_column_name( st, uiIndex ) );
dbFieldInfo.atomName = hb_itemGetCPtr( pName );
dbFieldInfo.uiType = sqlite3DeclType( st, uiIndex );
pItem = hb_arrayGetItemPtr( pItemEof, uiIndex + 1 );
switch( dbFieldInfo.uiType )
{
case HB_FT_STRING:
{
int iSize = sqlite3_column_bytes( st, uiIndex );
char * pStr;
dbFieldInfo.uiLen = ( HB_USHORT ) HB_MAX( iSize, 10 );
pStr = ( char * ) hb_xgrab( ( HB_SIZE ) dbFieldInfo.uiLen + 1 );
memset( pStr, ' ', dbFieldInfo.uiLen );
hb_itemPutCLPtr( pItem, pStr, dbFieldInfo.uiLen );
break;
}
case HB_FT_BLOB:
dbFieldInfo.uiLen = 4;
hb_itemPutC( pItem, NULL );
break;
case HB_FT_INTEGER:
dbFieldInfo.uiLen = 8;
hb_itemPutNInt( pItem, 0 );
break;
case HB_FT_LONG:
dbFieldInfo.uiLen = 20;
dbFieldInfo.uiDec = ( HB_USHORT ) hb_setGetDecimals();
hb_itemPutNDDec( pItem, 0.0, dbFieldInfo.uiDec );
break;
case HB_FT_ANY:
dbFieldInfo.uiLen = 6;
break;
default:
bError = HB_TRUE;
}
if( ! bError )
bError = ( SELF_ADDFIELD( &pArea->area, &dbFieldInfo ) == HB_FAILURE );
if( bError )
break;
}
hb_itemRelease( pName );
if( bError )
{
hb_itemRelease( pItemEof );
sqlite3_finalize( st );
hb_errRT_SQLT3DD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode );
return HB_FAILURE;
}
pArea->ulRecCount = 0;
pArea->ulRecMax = SQLDD_ROWSET_INIT;
pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
pArea->pRow[ 0 ] = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pSDDData->pStmt = st;
return HB_SUCCESS;
}
static HB_ERRCODE sqlite3Open( SQLBASEAREAP pArea )
{
sqlite3 * pDb = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pDb;
sqlite3_stmt * st = NULL;
SDDDATA * pSDDData;
const char * pszQuery;
HB_SIZE nQueryLen;
void * hQuery;
HB_USHORT uiFields, uiIndex;
PHB_ITEM pItemEof, pItem;
HB_ERRCODE errCode;
char * szError;
HB_BOOL bError;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
pItem = hb_itemPutC( NULL, pArea->szQuery );
pszQuery = S_HB_ITEMGETSTR( pItem, &hQuery, &nQueryLen );
if( sqlite3_prepare_v2( pDb, pszQuery, ( int ) nQueryLen, &st, NULL ) != SQLITE_OK )
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
else
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
}
if( sqlite3_step( st ) != SQLITE_ROW )
{
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
uiFields = ( HB_USHORT ) sqlite3_column_count( st );
SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
/* HB_TRACE( HB_TR_ALWAYS, ("fieldcount=%d", iNameLen) ); */
errCode = 0;
bError = HB_FALSE;
for( uiIndex = 0; uiIndex < uiFields; ++uiIndex )
{
DBFIELDINFO pFieldInfo;
PHB_ITEM pName;
int iDataType;
int iSize;
int iDec;
pName = S_HB_ITEMPUTSTR( NULL, sqlite3_column_name( st, uiIndex ) );
pFieldInfo.atomName = hb_itemGetCPtr( pName );
iDataType = sqlite3_column_type( st, uiIndex );
iSize = sqlite3_column_bytes( st, uiIndex );
iDec = 0;
pFieldInfo.uiLen = ( HB_USHORT ) iSize;
pFieldInfo.uiDec = ( HB_USHORT ) iDec;
/* HB_TRACE( HB_TR_ALWAYS, ("field: name=%s type=%d len=%d dec=%d nullable=%d", pFieldInfo.atomName, iDataType, iSize, iDec ) ); */
switch( iDataType )
{
case SQLITE_TEXT:
pFieldInfo.uiType = HB_FT_STRING;
break;
case SQLITE_FLOAT:
case SQLITE_INTEGER:
pFieldInfo.uiType = HB_FT_LONG;
break;
case SQLITE_BLOB:
pFieldInfo.uiType = HB_FT_BLOB;
break;
default:
/* HB_TRACE( HB_TR_ALWAYS, ("new sql type=%d", iDataType) ); */
bError = HB_TRUE;
errCode = ( HB_ERRCODE ) iDataType;
pFieldInfo.uiType = 0;
pFieldInfo.uiType = HB_FT_STRING;
break;
}
if( ! bError )
{
switch( pFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pFieldInfo.uiLen + 1 );
memset( pStr, ' ', pFieldInfo.uiLen );
pStr[ pFieldInfo.uiLen ] = '\0';
pItem = hb_itemPutCLPtr( NULL, pStr, pFieldInfo.uiLen );
break;
}
case HB_FT_BLOB:
pItem = hb_itemPutC( NULL, NULL );
break;
case HB_FT_LONG:
if( pFieldInfo.uiDec == 0 )
pItem = hb_itemPutNLLen( NULL, 0, pFieldInfo.uiLen );
else
pItem = hb_itemPutNDLen( NULL, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec );
break;
default:
pItem = hb_itemNew( NULL );
bError = HB_TRUE;
}
hb_arraySetForward( pItemEof, uiIndex + 1, pItem );
hb_itemRelease( pItem );
if( ! bError )
bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE );
}
hb_itemRelease( pName );
if( bError )
break;
}
if( bError )
{
hb_itemRelease( pItemEof );
sqlite3_finalize( st );
hb_errRT_SQLT3DD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode );
return HB_FAILURE;
}
pArea->ulRecCount = 0;
pArea->ulRecMax = SQLDD_ROWSET_INIT;
pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) );
memset( pArea->pRow, 0, SQLDD_ROWSET_INIT * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
memset( pArea->pRowFlags, 0, SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
pArea->pRow[ 0 ] = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pSDDData->pStmt = st;
return HB_SUCCESS;
}
static HB_ERRCODE sqlite3Open( SQLBASEAREAP pArea )
{
sqlite3 * pDb = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pDb;
sqlite3_stmt * st = NULL;
SDDDATA * pSDDData;
const char * pszQuery;
HB_SIZE nQueryLen;
void * hQuery;
HB_USHORT uiFields, uiIndex;
PHB_ITEM pItemEof, pItem;
HB_ERRCODE errCode;
char * szError;
HB_BOOL bError;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
pItem = hb_itemPutC( NULL, pArea->szQuery );
pszQuery = S_HB_ITEMGETSTR( pItem, &hQuery, &nQueryLen );
if( sqlite3_prepare_v2( pDb, pszQuery, ( int ) nQueryLen, &st, NULL ) != SQLITE_OK )
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
else
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
}
if( sqlite3_step( st ) != SQLITE_ROW )
{
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
uiFields = ( HB_USHORT ) sqlite3_column_count( st );
SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "fieldcount=%d", uiFields ) );
#endif
errCode = 0;
bError = HB_FALSE;
for( uiIndex = 0; uiIndex < uiFields; ++uiIndex )
{
DBFIELDINFO pFieldInfo;
int iDataType = sqlite3_column_type( st, uiIndex );
PHB_ITEM pName = S_HB_ITEMPUTSTR( NULL, sqlite3_column_name( st, uiIndex ) );
HB_USHORT uiNameLen = ( HB_USHORT ) hb_itemGetCLen( pName );
if( ( ( AREAP ) pArea )->uiMaxFieldNameLength < uiNameLen )
( ( AREAP ) pArea )->uiMaxFieldNameLength = uiNameLen;
pFieldInfo.atomName = hb_itemGetCPtr( pName );
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "field: name=%s type=%d len=%d", pFieldInfo.atomName, iDataType, sqlite3_column_bytes( st, uiIndex ) ) );
#endif
/* There are no field length limits stored in the SQLite3 database,
so we're resorting to setting some arbitrary default values to
make apps relying on these (f.e. Browse()/GET) to behave somewhat
better. For better results, update apps to untie UI metrics from
any database field/value widths. [vszakats] */
pFieldInfo.uiLen = 10;
pFieldInfo.uiDec = 0;
switch( iDataType )
{
case SQLITE3_TEXT:
pFieldInfo.uiType = HB_FT_STRING;
break;
case SQLITE_FLOAT:
pFieldInfo.uiType = HB_FT_LONG;
pFieldInfo.uiDec = ( HB_USHORT ) hb_setGetDecimals();
pFieldInfo.uiLen += pFieldInfo.uiDec + 1;
break;
case SQLITE_INTEGER:
pFieldInfo.uiType = HB_FT_LONG;
break;
case SQLITE_BLOB:
case SQLITE_NULL:
pFieldInfo.uiType = HB_FT_BLOB;
break;
default:
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "new sql type=%d", iDataType ) );
#endif
bError = HB_TRUE;
errCode = ( HB_ERRCODE ) iDataType;
pFieldInfo.uiType = 0;
break;
}
if( ! bError )
{
switch( pFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pFieldInfo.uiLen + 1 );
memset( pStr, ' ', pFieldInfo.uiLen );
pStr[ pFieldInfo.uiLen ] = '\0';
pItem = hb_itemPutCLPtr( NULL, pStr, pFieldInfo.uiLen );
break;
}
case HB_FT_BLOB:
pItem = hb_itemPutC( NULL, NULL );
break;
case HB_FT_LONG:
if( pFieldInfo.uiDec == 0 )
pItem = hb_itemPutNLLen( NULL, 0, pFieldInfo.uiLen );
else
pItem = hb_itemPutNDLen( NULL, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec );
break;
default:
pItem = hb_itemNew( NULL );
bError = HB_TRUE;
}
hb_arraySetForward( pItemEof, uiIndex + 1, pItem );
hb_itemRelease( pItem );
if( ! bError )
bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE );
}
hb_itemRelease( pName );
if( bError )
break;
}
if( bError )
{
hb_itemRelease( pItemEof );
sqlite3_finalize( st );
hb_errRT_SQLT3DD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode );
return HB_FAILURE;
}
pArea->ulRecCount = 0;
pArea->ulRecMax = SQLDD_ROWSET_INIT;
pArea->pRow = ( void ** ) hb_xgrabz( SQLDD_ROWSET_INIT * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrabz( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
pArea->pRow[ 0 ] = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pSDDData->pStmt = st;
return HB_SUCCESS;
}
/*
* Obtain the current value of a field.
*/
static HB_ERRCODE hb_sdfGetValue( SDFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem )
{
LPFIELD pField;
HB_TRACE( HB_TR_DEBUG, ( "hb_sdfGetValue(%p, %hu, %p)", pArea, uiIndex, pItem ) );
if( --uiIndex >= pArea->area.uiFieldCount )
return HB_FAILURE;
pField = pArea->area.lpFields + uiIndex;
switch( pField->uiType )
{
case HB_FT_STRING:
if( ( pField->uiFlags & HB_FF_BINARY ) == 0 )
{
HB_SIZE nLen = pField->uiLen;
char * pszVal = hb_cdpnDup( ( const char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
&nLen, pArea->area.cdPage, hb_vmCDP() );
hb_itemPutCLPtr( pItem, pszVal, nLen );
}
else
{
hb_itemPutCL( pItem, ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
pField->uiLen );
}
break;
case HB_FT_LOGICAL:
switch( pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] )
{
case 'T':
case 't':
case 'Y':
case 'y':
hb_itemPutL( pItem, HB_TRUE );
break;
default:
hb_itemPutL( pItem, HB_FALSE );
break;
}
break;
case HB_FT_DATE:
hb_itemPutDS( pItem, ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ] );
break;
case HB_FT_TIMESTAMP:
{
long lJulian, lMilliSec;
HB_BYTE * pFieldPtr = pArea->pRecord + pArea->pFieldOffset[ uiIndex ], bChar;
bChar = pFieldPtr[ pField->uiLen ];
pFieldPtr[ pField->uiLen ] = 0;
hb_timeStampStrGetDT( ( const char * ) pFieldPtr, &lJulian, &lMilliSec );
pFieldPtr[ pField->uiLen ] = bChar;
hb_itemPutTDT( pItem, lJulian, lMilliSec );
break;
}
case HB_FT_LONG:
{
HB_MAXINT lVal;
double dVal;
HB_BOOL fDbl;
fDbl = hb_strnToNum( ( const char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
pField->uiLen, &lVal, &dVal );
if( pField->uiDec )
{
hb_itemPutNDLen( pItem, fDbl ? dVal : ( double ) lVal,
( int ) ( pField->uiLen - pField->uiDec - 1 ),
( int ) pField->uiDec );
}
else if( fDbl )
{
hb_itemPutNDLen( pItem, dVal, ( int ) pField->uiLen, 0 );
}
else
{
hb_itemPutNIntLen( pItem, lVal, ( int ) pField->uiLen );
}
}
break;
case HB_FT_MEMO:
hb_itemPutC( pItem, NULL );
break;
case HB_FT_NONE:
hb_itemClear( pItem );
break;
default:
{
PHB_ITEM pError;
pError = hb_errNew();
hb_errPutGenCode( pError, EG_DATATYPE );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_DATATYPE ) );
hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) );
hb_errPutSubCode( pError, EDBF_DATATYPE );
SELF_ERROR( &pArea->area, pError );
hb_itemRelease( pError );
return HB_FAILURE;
}
}
return HB_SUCCESS;
}
static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo )
{
SQLHSTMT hStmt;
SQLRETURN res;
SQLLEN iLen;
PHB_ITEM pArray, pItem;
LPFIELD pField;
HB_USHORT ui;
/* No pArea->pSDDData for DBCreate() area...
* though pArea->fFetched == HB_TRUE for them
*/
hStmt = pArea->pSDDData ? ( ( SDDDATA * ) pArea->pSDDData )->hStmt : NULL;
while( ulRecNo > pArea->ulRecCount && ! pArea->fFetched )
{
if( ! SQL_SUCCEEDED( SQLFetch( hStmt ) ) )
{
pArea->fFetched = HB_TRUE;
break;
}
pArray = hb_itemArrayNew( pArea->area.uiFieldCount );
pItem = NULL;
for( ui = 1; ui <= pArea->area.uiFieldCount; ui++ )
{
iLen = SQL_NULL_DATA;
res = 0;
pField = pArea->area.lpFields + ui - 1;
switch( pField->uiType )
{
case HB_FT_STRING:
if( pField->uiType & HB_FF_BINARY )
{
char buffer[ 1 ];
iLen = 0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_BINARY, buffer, 0, &iLen ) ) )
{
if( iLen >= 0 )
{
char * val = ( char * ) hb_xgrab( iLen + 1 );
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_BINARY, val, iLen + 1, &iLen ) ) )
pItem = hb_itemPutCLPtr( pItem, val, ( HB_SIZE ) iLen );
else
hb_xfree( val );
}
}
}
else
{
O_HB_CHAR buffer[ 1 ];
#if defined( UNICODE )
SQLSMALLINT iTargetType = SQL_C_WCHAR;
#else
SQLSMALLINT iTargetType = SQL_C_CHAR;
#endif
iLen = 0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, iTargetType, buffer, 0, &iLen ) ) )
{
if( iLen >= 0 )
{
O_HB_CHAR * val = ( O_HB_CHAR * ) hb_xgrab( iLen + sizeof( O_HB_CHAR ) );
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, iTargetType, val, iLen + sizeof( O_HB_CHAR ), &iLen ) ) )
{
#if defined( UNICODE )
iLen >>= 1;
#endif
pItem = O_HB_ITEMPUTSTRLEN( pItem, val, ( HB_SIZE ) iLen );
}
hb_xfree( val );
}
}
}
break;
case HB_FT_INTEGER:
#if ODBCVER >= 0x0300
if( pField->uiTypeExtended == ( HB_USHORT ) SQL_BIGINT )
{
HB_I64 val = 0;
/* NOTE: SQL_C_SBIGINT not available before ODBC 3.0 */
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_SBIGINT, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutNIntLen( pItem, val, pField->uiLen );
}
else
#endif
{
SQLINTEGER val = 0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_LONG, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutNLLen( pItem, val, pField->uiLen );
}
break;
case HB_FT_LONG:
if( pField->uiDec == 0 && pField->uiLen < 10 )
{
SQLINTEGER val = 0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_LONG, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutNLLen( pItem, val, pField->uiLen );
}
else
{
double val = 0.0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_DOUBLE, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutNDLen( pItem, val, pField->uiLen, pField->uiDec );
}
break;
case HB_FT_DOUBLE:
{
double val = 0.0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_DOUBLE, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutNDLen( pItem, val, pField->uiLen, pField->uiDec );
break;
}
case HB_FT_LOGICAL:
{
unsigned char val = 0;
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_BIT, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutL( pItem, val != 0 );
break;
}
case HB_FT_DATE:
{
DATE_STRUCT val = { 0, 0, 0 };
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_DATE, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutD( pItem, val.year, val.month, val.day );
break;
}
case HB_FT_TIME:
{
TIME_STRUCT val = { 0, 0, 0 };
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_TIME, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutTDT( pItem, 0, hb_timeEncode( val.hour, val.minute, val.second, 0 ) );
break;
}
case HB_FT_TIMESTAMP:
{
TIMESTAMP_STRUCT val = { 0, 0, 0, 0, 0, 0, 0 };
if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_TIMESTAMP, &val, sizeof( val ), &iLen ) ) )
pItem = hb_itemPutTDT( pItem, hb_dateEncode( val.year, val.month, val.day ),
hb_timeEncode( val.hour, val.minute, val.second, val.fraction / 1000000 ) );
break;
}
}
/* TODO: check SQL_SUCCEEDED( res ) */
/* TODO: check for SQL_NO_TOTAL. What does this mean? */
HB_SYMBOL_UNUSED( res );
if( pItem )
{
/* NULL -> NIL */
if( iLen == SQL_NULL_DATA )
hb_itemClear( pItem );
else
hb_arraySetForward( pArray, ui, pItem );
}
}
if( pItem )
hb_itemRelease( pItem );
if( pArea->ulRecCount + 1 >= pArea->ulRecMax )
{
pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) );
pArea->ulRecMax += SQLDD_ROWSET_RESIZE;
}
pArea->ulRecCount++;
pArea->pRow[ pArea->ulRecCount ] = pArray;
pArea->pRowFlags[ pArea->ulRecCount ] = SQLDD_FLAG_CACHED;
}
static HB_ERRCODE ocilibGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo )
{
OCI_Statement * st = ( ( SDDDATA * ) pArea->pSDDData )->pStmt;
OCI_Resultset * rs = OCI_GetResultset( st );
while( ulRecNo > pArea->ulRecCount && ! pArea->fFetched )
{
PHB_ITEM pArray;
HB_USHORT ui;
if( ! OCI_FetchNext( rs ) )
{
pArea->fFetched = HB_TRUE;
break;
}
pArray = hb_itemArrayNew( pArea->area.uiFieldCount );
for( ui = 1; ui <= pArea->area.uiFieldCount; ++ui )
{
PHB_ITEM pItem = NULL;
LPFIELD pField = pArea->area.lpFields + ui - 1;
switch( pField->uiType )
{
case HB_FT_STRING:
if( OCI_IsNull( rs, ui ) )
{
char * pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pField->uiLen + 1 );
memset( pStr, ' ', pField->uiLen );
pStr[ pField->uiLen ] = '\0';
pItem = hb_itemPutCLPtr( NULL, pStr, pField->uiLen );
}
else
{
const dtext * val;
if( ( val = OCI_GetString( rs, ui ) ) != NULL )
pItem = D_HB_ITEMPUTSTRLEN( NULL, val, ( HB_SIZE ) dtslen( val ) ); /* TODO: Pad it to pField->uiLen size with spaces? */
}
break;
case HB_FT_LONG:
case HB_FT_INTEGER:
if( pField->uiDec == 0 )
#if HB_VMLONG_MAX == INT32_MAX || defined( HB_LONG_LONG_OFF )
pItem = hb_itemPutNIntLen( NULL, OCI_GetInt( rs, ui ), pField->uiLen );
#else
pItem = hb_itemPutNIntLen( NULL, OCI_GetBigInt( rs, ui ), pField->uiLen );
#endif
else
pItem = hb_itemPutNDLen( NULL, OCI_GetDouble( rs, ui ), pField->uiLen, pField->uiDec );
break;
case HB_FT_VARLENGTH:
case HB_FT_MEMO:
{
OCI_Long * val = OCI_GetLong( rs, ui );
if( val )
{
unsigned int uiSize = OCI_LongGetSize( val );
if( OCI_LongGetType( val ) == OCI_CLONG )
pItem = D_HB_ITEMPUTSTRLEN( NULL, ( D_HB_CHAR * ) OCI_LongGetBuffer( val ), uiSize );
else
pItem = hb_itemPutCL( NULL, ( char * ) OCI_LongGetBuffer( val ), uiSize );
}
break;
}
case HB_FT_IMAGE:
case HB_FT_BLOB:
case HB_FT_OLE:
{
OCI_Long * val = OCI_GetLong( rs, ui );
if( val )
pItem = hb_itemPutCL( NULL, ( char * ) OCI_LongGetBuffer( val ), OCI_LongGetSize( val ) );
break;
}
case HB_FT_CURRENCY:
case HB_FT_CURDOUBLE:
case HB_FT_FLOAT:
case HB_FT_DOUBLE:
pItem = hb_itemPutNDLen( NULL, OCI_GetDouble( rs, ui ), pField->uiLen, pField->uiDec );
break;
case HB_FT_DATE:
{
OCI_Date * date = OCI_GetDate( rs, ui );
int iYear, iMonth, iDay;
if( date && OCI_DateGetDate( date, &iYear, &iMonth, &iDay ) )
pItem = hb_itemPutD( NULL, iYear, iMonth, iDay );
break;
}
case HB_FT_TIME:
{
OCI_Date * date = OCI_GetDate( rs, ui );
int iYear, iMonth, iDay, iHour, iMin, iSec;
if( date && OCI_DateGetDateTime( date, &iYear, &iMonth, &iDay, &iHour, &iMin, &iSec ) )
pItem = hb_itemPutTDT( NULL, hb_dateEncode( iYear, iMonth, iDay ),
hb_timeEncode( iHour, iMin, iSec, 0 ) );
break;
}
case HB_FT_TIMESTAMP:
{
OCI_Timestamp * ts = OCI_GetTimestamp( rs, ui );
int iYear, iMonth, iDay, iHour, iMin, iSec, iFSec;
if( ts && OCI_TimestampGetDateTime( ts, &iYear, &iMonth, &iDay, &iHour, &iMin, &iSec, &iFSec ) )
pItem = hb_itemPutTDT( NULL, hb_dateEncode( iYear, iMonth, iDay ),
hb_timeEncode( iHour, iMin, iSec, iFSec / 1000000 ) );
break;
}
}
if( pItem )
{
hb_arraySetForward( pArray, ui, pItem );
hb_itemRelease( pItem );
}
}
if( pArea->ulRecCount + 1 <= pArea->ulRecMax )
{
pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) );
pArea->ulRecMax += SQLDD_ROWSET_RESIZE;
}
pArea->ulRecCount++;
pArea->pRow[ pArea->ulRecCount ] = pArray;
pArea->pRowFlags[ pArea->ulRecCount ] = SQLDD_FLAG_CACHED;
}
static HB_ERRCODE ocilibOpen( SQLBASEAREAP pArea )
{
OCI_Statement * st = OCI_StatementCreate( ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pConn );
OCI_Resultset * rs;
SDDDATA * pSDDData;
void * hQuery;
HB_USHORT uiFields, uiIndex;
PHB_ITEM pItemEof, pItem;
HB_ERRCODE errCode;
char * szError;
HB_BOOL bError;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
if( ! st )
{
szError = ocilibGetError( &errCode );
hb_errRT_OCIDD( EG_OPEN, ESQLDD_STMTALLOC, szError, pArea->szQuery, errCode );
hb_xfree( szError );
return HB_FAILURE;
}
pItem = hb_itemPutC( NULL, pArea->szQuery );
if( ! OCI_ExecuteStmt( st, M_HB_ITEMGETSTR( pItem, &hQuery, NULL ) ) )
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
szError = ocilibGetError( &errCode );
OCI_StatementFree( st );
hb_errRT_OCIDD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
hb_xfree( szError );
return HB_FAILURE;
}
else
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
}
rs = OCI_GetResultset( st );
uiFields = ( HB_USHORT ) OCI_GetColumnCount( rs );
SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
pItem = hb_itemNew( NULL );
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "fieldcount=%d", iNameLen ) );
#endif
errCode = 0;
bError = HB_FALSE;
for( uiIndex = 0; uiIndex < uiFields; ++uiIndex )
{
DBFIELDINFO pFieldInfo;
PHB_ITEM pName;
OCI_Column * col = OCI_GetColumn( rs, uiIndex + 1 );
unsigned int uiDataType;
unsigned int uiSize;
int iDec;
HB_BOOL bNullable;
if( ! col )
{
hb_itemRelease( pItemEof );
hb_itemRelease( pItem );
szError = ocilibGetError( NULL );
OCI_StatementFree( st );
hb_errRT_OCIDD( EG_OPEN, ESQLDD_STMTDESCR + 1001, szError, pArea->szQuery, 0 );
hb_xfree( szError );
return HB_FAILURE;
}
pName = D_HB_ITEMPUTSTR( NULL, OCI_ColumnGetName( col ) );
pFieldInfo.atomName = hb_itemGetCPtr( pName );
uiDataType = OCI_ColumnGetType( col );
uiSize = OCI_ColumnGetSize( col );
iDec = OCI_ColumnGetPrecision( col );
bNullable = ( HB_BOOL ) OCI_ColumnGetNullable( col );
if( bNullable )
pFieldInfo.uiFlags |= HB_FF_NULLABLE;
pFieldInfo.uiLen = ( HB_USHORT ) uiSize;
pFieldInfo.uiDec = ( HB_USHORT ) iDec;
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "field: name=%s type=%d len=%d dec=%d nullable=%d %d %d %d %d", pFieldInfo.atomName, uiDataType, uiSize, iDec, bNullable, OCI_ColumnGetScale( col ), OCI_ColumnGetPrecision( col ), OCI_ColumnGetFractionalPrecision( col ), OCI_ColumnGetLeadingPrecision( col ) ) );
#endif
switch( uiDataType )
{
case OCI_CDT_TEXT:
pFieldInfo.uiType = HB_FT_STRING;
break;
case OCI_CDT_NUMERIC:
pFieldInfo.uiType = HB_FT_LONG;
/* For plain 'NUMERIC', precision is zero and scale is -127 */
if( OCI_ColumnGetPrecision( col ) > 0 )
pFieldInfo.uiLen = ( HB_USHORT ) OCI_ColumnGetPrecision( col );
if( OCI_ColumnGetScale( col ) >= 0 )
pFieldInfo.uiDec = ( HB_USHORT ) OCI_ColumnGetScale( col );
else
pFieldInfo.uiDec = ( HB_USHORT ) hb_setGetDecimals();
break;
case OCI_CDT_LONG:
pFieldInfo.uiType = HB_FT_VARLENGTH;
break;
case OCI_CDT_RAW:
pFieldInfo.uiType = HB_FT_BLOB;
break;
case OCI_CDT_DATETIME:
case OCI_CDT_TIMESTAMP:
case OCI_CDT_INTERVAL:
pFieldInfo.uiType = HB_FT_TIME;
break;
default:
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "new sql type=%d", uiDataType ) );
#endif
bError = HB_TRUE;
errCode = ( HB_ERRCODE ) uiDataType;
pFieldInfo.uiType = 0;
pFieldInfo.uiType = HB_FT_STRING;
break;
}
if( ! bError )
{
switch( pFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pFieldInfo.uiLen + 1 );
memset( pStr, ' ', pFieldInfo.uiLen );
pStr[ pFieldInfo.uiLen ] = '\0';
hb_itemPutCLPtr( pItem, pStr, pFieldInfo.uiLen );
break;
}
case HB_FT_MEMO:
case HB_FT_VARLENGTH:
case HB_FT_BLOB:
hb_itemPutC( pItem, NULL );
break;
case HB_FT_INTEGER:
hb_itemPutNI( pItem, 0 );
break;
case HB_FT_LONG:
if( pFieldInfo.uiDec == 0 )
hb_itemPutNLLen( pItem, 0, pFieldInfo.uiLen );
else
hb_itemPutNDLen( pItem, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec );
break;
case HB_FT_DOUBLE:
hb_itemPutNDLen( pItem, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec );
break;
case HB_FT_LOGICAL:
hb_itemPutL( pItem, HB_FALSE );
break;
case HB_FT_DATE:
hb_itemPutDL( pItem, 0 );
break;
case HB_FT_TIME:
case HB_FT_TIMESTAMP:
hb_itemPutTDT( pItem, 0, 0 );
break;
default:
hb_itemClear( pItem );
bError = HB_TRUE;
}
hb_arraySetForward( pItemEof, uiIndex + 1, pItem );
if( ! bError )
bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE );
}
hb_itemRelease( pName );
if( bError )
break;
}
hb_itemRelease( pItem );
if( bError )
{
hb_itemRelease( pItemEof );
OCI_StatementFree( st );
hb_errRT_OCIDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode );
return HB_FAILURE;
}
pArea->ulRecCount = 0;
pArea->ulRecMax = SQLDD_ROWSET_INIT;
pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) );
memset( pArea->pRow, 0, SQLDD_ROWSET_INIT * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
memset( pArea->pRowFlags, 0, SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
pArea->pRow[ 0 ] = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pSDDData->pStmt = st;
return HB_SUCCESS;
}
