/*
* Obtain the current value of a field.
*/
static HB_ERRCODE hb_delimGetValue( DELIMAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
LPFIELD pField;
HB_TRACE(HB_TR_DEBUG, ("hb_delimGetValue(%p, %hu, %p)", pArea, uiIndex, pItem));
--uiIndex;
pField = pArea->lpFields + uiIndex;
switch( pField->uiType )
{
case HB_FT_STRING:
#ifndef HB_CDP_SUPPORT_OFF
if( pArea->cdPage != hb_cdppage() )
{
char * pVal = ( char * ) hb_xgrab( pField->uiLen + 1 );
memcpy( pVal, pArea->pRecord + pArea->pFieldOffset[ uiIndex ], pField->uiLen );
pVal[ pField->uiLen ] = '\0';
hb_cdpnTranslate( pVal, pArea->cdPage, hb_cdppage(), pField->uiLen );
hb_itemPutCPtr( pItem, pVal, pField->uiLen );
}
else
#endif
{
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, TRUE );
break;
default:
hb_itemPutL( pItem, FALSE );
break;
}
break;
case HB_FT_DATE:
hb_itemPutDS( pItem, ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ] );
break;
case HB_FT_LONG:
{
HB_LONG lVal;
double dVal;
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, "" );
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( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return HB_FAILURE;
}
}
return HB_SUCCESS;
}
/*
* Read record, decode it to buffer and set next record offset
*/
static HB_ERRCODE hb_delimReadRecord( DELIMAREAP pArea )
{
USHORT uiField, uiLen, uiSize;
HB_TYPE uiType;
LPFIELD pField;
BYTE * pFieldBuf, buffer[ 256 ];
char cStop;
int ch = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_delimReadRecord(%p)", pArea));
if( pArea->ulBufferStart <= pArea->ulRecordOffset &&
pArea->ulBufferStart + ( HB_FOFFSET ) pArea->ulBufferRead > pArea->ulRecordOffset )
{
pArea->ulBufferIndex = ( ULONG ) ( pArea->ulRecordOffset - pArea->ulBufferStart );
}
else
{
pArea->ulBufferStart = pArea->ulRecordOffset;
pArea->ulBufferRead = pArea->ulBufferIndex = 0;
}
/* clear the record buffer */
hb_delimClearRecordBuffer( pArea );
for( uiField = 0; uiField < pArea->uiFieldCount; ++uiField )
{
pField = pArea->lpFields + uiField;
uiType = pField->uiType;
if( uiType == HB_FT_STRING || uiType == HB_FT_LOGICAL ||
uiType == HB_FT_DATE || uiType == HB_FT_LONG )
{
uiSize = 0;
uiLen = pField->uiLen;
pFieldBuf = pArea->pRecord + pArea->pFieldOffset[ uiField ];
/* ignore leading spaces */
do
ch = hb_delimNextChar( pArea );
while( ch == ' ' );
/* set the stop character */
if( pArea->cDelim && ch == pArea->cDelim )
{
cStop = pArea->cDelim;
ch = hb_delimNextChar( pArea );
}
else
cStop = pArea->cSeparator;
/*
* Clipper uses differ rules for character fields, they
* can be terminated only with valid stop character, when
* other fields also by length
*/
if( pField->uiType == HB_FT_STRING )
{
while( ch >= 0 && ch != cStop )
{
if( uiSize < uiLen )
pFieldBuf[ uiSize++ ] = ( BYTE ) ch;
ch = hb_delimNextChar( pArea );
}
}
else
{
while( ch >= 0 && ch != cStop && uiSize < uiLen )
{
buffer[ uiSize++ ] = ( BYTE ) ch;
ch = hb_delimNextChar( pArea );
}
buffer[ uiSize ] = '\0';
if( pField->uiType == HB_FT_LOGICAL )
{
*pFieldBuf = ( *buffer == 'T' || *buffer == 't' ||
*buffer == 'Y' || *buffer == 'y' ) ? 'T' : 'F';
}
else if( pField->uiType == HB_FT_DATE )
{
if( uiSize == 8 && hb_dateEncStr( ( char * ) buffer ) != 0 )
memcpy( pFieldBuf, buffer, 8 );
}
else
{
HB_LONG lVal;
double dVal;
BOOL fDbl;
fDbl = hb_strnToNum( (const char *) buffer, uiSize, &lVal, &dVal );
if( fDbl )
pArea->valResult = hb_itemPutNDLen( pArea->valResult, dVal,
uiLen - pField->uiDec - 1, pField->uiDec );
else
pArea->valResult = hb_itemPutNIntLen( pArea->valResult,
lVal, uiLen );
hb_itemStrBuf( ( char * ) buffer, pArea->valResult, uiLen, pField->uiDec );
/* TODO: RT error on width range */
memcpy( pFieldBuf, buffer, uiLen );
}
}
/* ignore all character to the next field separator */
while( ch >= 0 && ch != pArea->cSeparator )
ch = hb_delimNextChar( pArea );
/* stop reading on EOL */
if( ch < 0 )
break;
}
}
/* ignore all character to the end of line */
while( ch >= 0 )
ch = hb_delimNextChar( pArea );
if( ch == -2 &&
pArea->ulRecordOffset == ( HB_FOFFSET ) ( pArea->ulBufferStart +
pArea->ulBufferIndex ) )
{
pArea->fEof = TRUE;
pArea->fPositioned = FALSE;
}
else
{
pArea->fEof = FALSE;
pArea->fPositioned = TRUE;
}
return HB_SUCCESS;
}
static HB_ERRCODE sqlite3GoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo )
{
sqlite3_stmt * st = ( ( SDDDATA * ) pArea->pSDDData )->pStmt;
while( ulRecNo > pArea->ulRecCount && ! pArea->fFetched )
{
PHB_ITEM pArray;
HB_USHORT ui;
if( sqlite3_step( st ) != SQLITE_ROW )
{
pArea->fFetched = HB_TRUE;
break;
}
pArray = hb_itemArrayNew( pArea->area.uiFieldCount );
for( ui = 0; ui < pArea->area.uiFieldCount; ++ui )
{
PHB_ITEM pItem = NULL;
LPFIELD pField = pArea->area.lpFields + ui;
switch( pField->uiType )
{
case HB_FT_STRING:
pItem = S_HB_ITEMPUTSTR( NULL, ( const char * ) sqlite3_column_text( st, ui ) );
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, sqlite3_column_int( st, ui ), pField->uiLen );
#else
pItem = hb_itemPutNIntLen( NULL, sqlite3_column_int64( st, ui ), pField->uiLen );
#endif
else
pItem = hb_itemPutNDLen( NULL, sqlite3_column_double( st, ui ), pField->uiLen, pField->uiDec );
break;
case HB_FT_BLOB:
pItem = hb_itemPutCL( NULL, ( const char * ) sqlite3_column_blob( st, ui ), sqlite3_column_bytes( st, ui ) );
break;
}
if( pItem )
{
hb_arraySetForward( pArray, ui + 1, 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;
}
/*
* 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;
}