static HB_ERRCODE pgsqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem )
{
SDDDATA * pSDDData = ( SDDDATA * ) pArea->pSDDData;
LPFIELD pField;
char * pValue;
HB_BOOL bError;
PHB_ITEM pError;
HB_SIZE ulLen;
bError = HB_FALSE;
uiIndex--;
pField = pArea->area.lpFields + uiIndex;
if( PQgetisnull( pSDDData->pResult, pArea->ulRecNo - 1, uiIndex ) )
return HB_SUCCESS;
pValue = PQgetvalue( pSDDData->pResult, pArea->ulRecNo - 1, uiIndex );
ulLen = ( HB_SIZE ) PQgetlength( pSDDData->pResult, pArea->ulRecNo - 1, uiIndex );
/* printf( "fieldget recno:%d index:%d value:%s len:%d\n", pArea->ulRecNo, uiIndex, pValue, ulLen ); */
switch( pField->uiType )
{
case HB_FT_STRING:
hb_itemPutCL( pItem, pValue, ulLen );
break;
case HB_FT_MEMO:
hb_itemPutCL( pItem, pValue, ulLen );
hb_itemSetCMemo( pItem );
break;
case HB_FT_INTEGER:
case HB_FT_LONG:
case HB_FT_DOUBLE:
if( pField->uiDec )
hb_itemPutNDLen( pItem, atof( pValue ),
( int ) pField->uiLen - ( ( int ) pField->uiDec + 1 ),
( int ) pField->uiDec );
else
if( pField->uiLen > 9 )
hb_itemPutNDLen( pItem, atof( pValue ),
( int ) pField->uiLen, ( int ) pField->uiDec );
else
hb_itemPutNLLen( pItem, atol( pValue ), ( int ) pField->uiLen );
break;
case HB_FT_LOGICAL:
hb_itemPutL( pItem, pValue[ 0 ] == 'T' || pValue[ 0 ] == 'Y' );
break;
case HB_FT_DATE:
{
char szDate[ 9 ];
szDate[ 0 ] = pValue[ 0 ];
szDate[ 1 ] = pValue[ 1 ];
szDate[ 2 ] = pValue[ 2 ];
szDate[ 3 ] = pValue[ 3 ];
szDate[ 4 ] = pValue[ 5 ];
szDate[ 5 ] = pValue[ 6 ];
szDate[ 6 ] = pValue[ 8 ];
szDate[ 7 ] = pValue[ 9 ];
szDate[ 8 ] = '\0';
hb_itemPutDS( pItem, szDate );
break;
}
default:
bError = HB_TRUE;
break;
}
if( bError )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_DATATYPE );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_DATATYPE ) );
hb_errPutSubCode( pError, EDBF_DATATYPE );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return HB_FAILURE;
}
return HB_SUCCESS;
}
static HB_ERRCODE sqlbaseCreate( SQLBASEAREAP pArea, LPDBOPENINFO pOpenInfo )
{
PHB_ITEM pItemEof, pItem;
HB_USHORT uiCount;
HB_BOOL bError;
pArea->ulConnection = pOpenInfo->ulConnection ? pOpenInfo->ulConnection : s_ulConnectionCurrent;
if( pArea->ulConnection > s_ulConnectionCount ||
( pArea->ulConnection && ! s_pConnection[ pArea->ulConnection - 1 ] ) )
{
hb_errRT_SQLBASE( EG_OPEN, ESQLDD_NOTCONNECTED, "Not connected", NULL );
return HB_FAILURE;
}
if( pArea->ulConnection )
{
pArea->pConnection = s_pConnection[ pArea->ulConnection - 1 ];
pArea->pConnection->uiAreaCount++;
pArea->pSDD = pArea->pConnection->pSDD;
}
else
pArea->pSDD = &sddNull;
pItemEof = hb_itemArrayNew( pArea->area.uiFieldCount );
bError = HB_FALSE;
for( uiCount = 0; uiCount < pArea->area.uiFieldCount; uiCount++ )
{
LPFIELD pField = pArea->area.lpFields + uiCount;
switch( pField->uiType )
{
case HB_FT_STRING:
{
char * pStr;
pStr = ( char * ) hb_xgrab( pField->uiLen + 1 );
memset( pStr, ' ', pField->uiLen );
pStr[ pField->uiLen ] = '\0';
pItem = hb_itemPutCL( NULL, pStr, pField->uiLen );
hb_xfree( pStr );
break;
}
case HB_FT_MEMO:
pItem = hb_itemPutC( NULL, NULL );
break;
case HB_FT_INTEGER:
if( pField->uiDec )
pItem = hb_itemPutND( NULL, 0.0 );
else
pItem = hb_itemPutNI( NULL, 0 );
break;
case HB_FT_LONG:
if( pField->uiDec )
pItem = hb_itemPutND( NULL, 0.0 );
else
pItem = hb_itemPutNL( NULL, 0 );
break;
case HB_FT_FLOAT:
pItem = hb_itemPutND( NULL, 0.0 );
break;
case HB_FT_DOUBLE:
pItem = hb_itemPutND( NULL, 0.0 );
break;
case HB_FT_DATE:
pItem = hb_itemPutDS( NULL, NULL );
break;
case HB_FT_LOGICAL:
pItem = hb_itemPutL( NULL, HB_FALSE );
break;
default:
pItem = hb_itemNew( NULL );
bError = HB_TRUE;
break;
}
hb_arraySetForward( pItemEof, uiCount + 1, pItem );
hb_itemRelease( pItem );
if( bError )
break;
}
if( bError )
{
hb_itemClear( pItemEof );
hb_itemRelease( pItemEof );
hb_errRT_SQLBASE( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", NULL );
SELF_CLOSE( ( AREAP ) pArea );
return HB_FAILURE;
}
pArea->ulRecCount = 0;
pArea->pRow = ( void ** ) hb_xalloc( SQLDD_ROWSET_RESIZE * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xalloc( SQLDD_ROWSET_RESIZE * sizeof( HB_BYTE ) );
pArea->ulRecMax = SQLDD_ROWSET_RESIZE;
*( pArea->pRow ) = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pArea->fFetched = HB_TRUE;
if( SUPER_CREATE( ( AREAP ) pArea, pOpenInfo ) != HB_SUCCESS )
{
SELF_CLOSE( ( AREAP ) pArea );
return HB_FAILURE;
}
return SELF_GOTOP( ( AREAP ) pArea );
}
static HB_BOOL hb_regex( int iRequest )
{
HB_REGMATCH aMatches[ HB_REGMATCH_SIZE( REGEX_MAX_GROUPS ) ];
PHB_ITEM pRetArray, pMatch, pString;
int i, iMatches, iMaxMatch;
HB_BOOL fResult = HB_FALSE;
PHB_REGEX pRegEx;
const char * pszString;
HB_SIZE nLen;
pString = hb_param( 2, HB_IT_STRING );
if( ! pString )
{
hb_errRT_BASE_SubstR( EG_ARG, 3014, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return HB_FALSE;
}
pRegEx = hb_regexGet( hb_param( 1, HB_IT_ANY ),
( ! hb_parldef( 3, 1 ) ? HBREG_ICASE : 0 ) |
( hb_parl( 4 ) ? HBREG_NEWLINE : 0 ) );
if( ! pRegEx )
return HB_FALSE;
pszString = hb_itemGetCPtr( pString );
nLen = hb_itemGetCLen( pString );
iMaxMatch = iRequest == 0 || iRequest == 4 || iRequest == 5 ?
REGEX_MAX_GROUPS : 1;
iMatches = hb_regexec( pRegEx, pszString, nLen, iMaxMatch, aMatches );
if( iMatches > 0 )
{
switch( iRequest )
{
case 0:
pRetArray = hb_itemArrayNew( iMatches );
for( i = 0; i < iMatches; i++ )
{
if( HB_REGMATCH_EO( aMatches, i ) > -1 )
hb_arraySetCL( pRetArray, i + 1,
pszString + HB_REGMATCH_SO( aMatches, i ),
HB_REGMATCH_EO( aMatches, i ) -
HB_REGMATCH_SO( aMatches, i ) );
else
hb_arraySetCL( pRetArray, i + 1, NULL, 0 );
}
hb_itemReturnRelease( pRetArray );
fResult = HB_TRUE;
break;
case 1: /* LIKE */
fResult = HB_REGMATCH_SO( aMatches, 0 ) == 0 &&
( HB_SIZE ) HB_REGMATCH_EO( aMatches, 0 ) == nLen;
break;
case 2: /* MATCH ( HAS ) */
fResult = HB_TRUE;
break;
case 3: /* SPLIT */
iMaxMatch = hb_parni( 5 );
pRetArray = hb_itemArrayNew( 0 );
pMatch = hb_itemNew( NULL );
iMatches = 0;
do
{
hb_itemPutCL( pMatch, pszString, HB_REGMATCH_SO( aMatches, 0 ) );
hb_arrayAddForward( pRetArray, pMatch );
nLen -= HB_REGMATCH_EO( aMatches, 0 );
pszString += HB_REGMATCH_EO( aMatches, 0 );
iMatches++;
}
while( HB_REGMATCH_EO( aMatches, 0 ) > 0 && nLen &&
( iMaxMatch == 0 || iMatches < iMaxMatch ) &&
hb_regexec( pRegEx, pszString, nLen, 1, aMatches ) > 0 );
/* last match must be done also in case that pszString is empty;
this would mean an empty split field at the end of the string */
/* if( nLen ) */
{
hb_itemPutCL( pMatch, pszString, nLen );
hb_arrayAddForward( pRetArray, pMatch );
}
hb_itemRelease( pMatch );
hb_itemReturnRelease( pRetArray );
fResult = HB_TRUE;
break;
case 4: /* results AND positions */
pRetArray = hb_itemArrayNew( iMatches );
for( i = 0; i < iMatches; i++ )
{
int iSO = HB_REGMATCH_SO( aMatches, i ),
iEO = HB_REGMATCH_EO( aMatches, i );
pMatch = hb_arrayGetItemPtr( pRetArray, i + 1 );
hb_arrayNew( pMatch, 3 );
if( iEO != -1 )
{
/* matched string */
hb_arraySetCL( pMatch, 1, pszString + iSO, iEO - iSO );
/* begin of match */
hb_arraySetNS( pMatch, 2, iSO + 1 );
/* End of match */
hb_arraySetNS( pMatch, 3, iEO );
}
else
{
hb_arraySetCL( pMatch, 1, NULL, 0 );
hb_arraySetNS( pMatch, 2, 0 );
hb_arraySetNS( pMatch, 3, 0 );
}
}
hb_itemReturnRelease( pRetArray );
fResult = HB_TRUE;
break;
case 5: /* _ALL_ results AND positions */
{
PHB_ITEM pAtxArray;
int iMax = hb_parni( 5 ); /* max nuber of matches I want, 0 = unlimited */
int iGetMatch = hb_parni( 6 ); /* Gets if want only one single match or a sub-match */
HB_BOOL fOnlyMatch = hb_parldef( 7, 1 ); /* if HB_TRUE returns only matches and sub-matches, not positions */
HB_SIZE nOffset = 0;
int iCount = 0;
int iSO, iEO;
/* Set new array */
pRetArray = hb_itemArrayNew( 0 );
do
{
/* If I want all matches */
if( iGetMatch == 0 || /* Check boundaries */
( iGetMatch < 0 || iGetMatch > iMatches ) )
{
pAtxArray = hb_itemArrayNew( iMatches );
for( i = 0; i < iMatches; i++ )
{
iSO = HB_REGMATCH_SO( aMatches, i );
iEO = HB_REGMATCH_EO( aMatches, i );
pMatch = hb_arrayGetItemPtr( pAtxArray, i + 1 );
if( ! fOnlyMatch )
{
hb_arrayNew( pMatch, 3 );
if( iEO != -1 )
{
/* matched string */
hb_arraySetCL( pMatch, 1, pszString + iSO, iEO - iSO );
/* begin of match */
hb_arraySetNS( pMatch, 2, nOffset + iSO + 1 );
/* End of match */
hb_arraySetNS( pMatch, 3, nOffset + iEO );
}
else
{
hb_arraySetCL( pMatch, 1, NULL, 0 );
hb_arraySetNS( pMatch, 2, 0 );
hb_arraySetNS( pMatch, 3, 0 );
}
}
else
{
if( iEO != -1 )
/* matched string */
hb_itemPutCL( pMatch, pszString + iSO, iEO - iSO );
else
hb_itemPutC( pMatch, NULL );
}
}
hb_arrayAddForward( pRetArray, pAtxArray );
hb_itemRelease( pAtxArray );
}
else /* Here I get only single matches */
{
i = iGetMatch - 1;
iSO = HB_REGMATCH_SO( aMatches, i );
iEO = HB_REGMATCH_EO( aMatches, i );
pMatch = hb_itemNew( NULL );
if( ! fOnlyMatch )
{
hb_arrayNew( pMatch, 3 );
if( iEO != -1 )
{
/* matched string */
hb_arraySetCL( pMatch, 1, pszString + iSO, iEO - iSO );
/* begin of match */
hb_arraySetNS( pMatch, 2, nOffset + iSO + 1 );
/* End of match */
hb_arraySetNS( pMatch, 3, nOffset + iEO );
}
else
{
hb_arraySetCL( pMatch, 1, NULL, 0 );
hb_arraySetNS( pMatch, 2, 0 );
hb_arraySetNS( pMatch, 3, 0 );
}
}
else
{
if( iEO != -1 )
/* matched string */
hb_itemPutCL( pMatch, pszString + iSO, iEO - iSO );
else
hb_itemPutC( pMatch, NULL );
}
hb_arrayAddForward( pRetArray, pMatch );
hb_itemRelease( pMatch );
}
iEO = HB_REGMATCH_EO( aMatches, 0 );
if( iEO == -1 )
break;
nLen -= iEO;
pszString += iEO;
nOffset += iEO;
iCount++;
}
while( iEO && nLen && ( iMax == 0 || iCount < iMax ) &&
( iMatches = hb_regexec( pRegEx, pszString, nLen, iMaxMatch, aMatches ) ) > 0 );
hb_itemReturnRelease( pRetArray );
fResult = HB_TRUE;
break;
}
}
}
else if( iRequest == 3 )
{
pRetArray = hb_itemArrayNew( 1 );
hb_arraySet( pRetArray, 1, pString );
hb_itemReturnRelease( pRetArray );
fResult = HB_TRUE;
}
hb_regexFree( pRegEx );
return fResult;
}
static HB_ERRCODE pgsqlOpen( SQLBASEAREAP pArea )
{
PGconn * pConn = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pConn;
SDDDATA * pSDDData;
PGresult * pResult;
ExecStatusType status;
PHB_ITEM pItemEof, pItem;
HB_USHORT uiFields, uiCount;
HB_BOOL bError;
DBFIELDINFO pFieldInfo;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
pResult = PQexec( pConn, pArea->szQuery );
if( ! pResult )
{
hb_errRT_PostgreSQLDD( EG_OPEN, ESQLDD_LOWMEMORY, "Query failed", NULL, 0 ); /* Low memory, etc */
return HB_FAILURE;
}
status = PQresultStatus( pResult );
if( status != PGRES_TUPLES_OK && status != PGRES_COMMAND_OK )
{
hb_errRT_PostgreSQLDD( EG_OPEN, ESQLDD_INVALIDQUERY, PQresultErrorMessage( pResult ), pArea->szQuery, ( HB_ERRCODE ) status );
PQclear( pResult );
return HB_FAILURE;
}
pSDDData->pResult = pResult;
uiFields = ( HB_USHORT ) PQnfields( pResult );
SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
pItem = hb_itemNew( NULL );
bError = HB_FALSE;
for( uiCount = 0; uiCount < uiFields; uiCount++ )
{
pFieldInfo.atomName = PQfname( pResult, ( int ) uiCount );
pFieldInfo.uiDec = 0;
switch( PQftype( pResult, ( int ) uiCount ) )
{
case BPCHAROID:
case VARCHAROID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = ( HB_USHORT ) PQfmod( pResult, uiCount ) - 4;
break;
case TEXTOID:
pFieldInfo.uiType = HB_FT_MEMO;
pFieldInfo.uiLen = 10;
break;
case NUMERICOID:
pFieldInfo.uiType = HB_FT_DOUBLE;
pFieldInfo.uiLen = ( PQfmod( pResult, uiCount ) - 4 ) >> 16;
pFieldInfo.uiDec = ( PQfmod( pResult, uiCount ) - 4 ) & 0xFFFF;
break;
case INT2OID:
pFieldInfo.uiType = HB_FT_INTEGER;
pFieldInfo.uiLen = 6;
break;
case INT4OID:
pFieldInfo.uiType = HB_FT_INTEGER;
pFieldInfo.uiLen = 11;
break;
case INT8OID:
case OIDOID:
pFieldInfo.uiType = HB_FT_LONG;
pFieldInfo.uiLen = 20;
break;
case FLOAT4OID:
case FLOAT8OID:
case CASHOID: /* TODO: ??? */
pFieldInfo.uiType = HB_FT_DOUBLE;
pFieldInfo.uiLen = 16;
pFieldInfo.uiDec = 2; /* TODO: hb_set.SET_DECIMALS ??? */
break;
case BOOLOID:
pFieldInfo.uiType = HB_FT_LOGICAL;
pFieldInfo.uiLen = 1;
break;
case DATEOID:
pFieldInfo.uiType = HB_FT_DATE;
pFieldInfo.uiLen = 8;
break;
case INETOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 29;
break;
case CIDROID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 32;
break;
case MACADDROID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 17;
break;
case BITOID:
case VARBITOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = ( HB_USHORT ) PQfsize( pResult, uiCount );
break;
case TIMEOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 12;
break;
case TIMESTAMPOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 23;
break;
case TIMETZOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 15;
break;
case TIMESTAMPTZOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 26;
break;
case NAMEOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 63;
break;
case BYTEAOID:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiLen = 0;
break;
default:
pFieldInfo.uiType = 0;
pFieldInfo.uiLen = 0;
bError = HB_TRUE;
break;
}
/* printf( "field:%s \ttype:%d \tsize:%d \tformat:%d \tmod:%d err=%d\n", pFieldInfo.atomName, PQftype( pResult, ( int ) uiCount ), PQfsize( pResult, uiCount ), PQfformat( pResult, uiCount ) , PQfmod( pResult, uiCount ), bError ); */
if( ! bError )
{
switch( pFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr;
pStr = ( char * ) hb_xgrab( pFieldInfo.uiLen + 1 );
memset( pStr, ' ', pFieldInfo.uiLen );
pStr[ pFieldInfo.uiLen ] = '\0';
hb_itemPutCL( pItem, pStr, pFieldInfo.uiLen );
hb_xfree( pStr );
break;
}
case HB_FT_MEMO:
hb_itemPutC( pItem, NULL );
hb_itemSetCMemo( pItem );
break;
case HB_FT_INTEGER:
hb_itemPutNI( pItem, 0 );
break;
case HB_FT_LONG:
hb_itemPutNL( pItem, 0 );
break;
case HB_FT_DOUBLE:
hb_itemPutND( pItem, 0.0 );
break;
case HB_FT_LOGICAL:
hb_itemPutL( pItem, HB_FALSE );
break;
case HB_FT_DATE:
hb_itemPutDS( pItem, NULL );
break;
default:
hb_itemClear( pItem );
bError = HB_TRUE;
break;
}
hb_arraySetForward( pItemEof, uiCount + 1, pItem );
/* if( pFieldInfo.uiType == HB_IT_DOUBLE || pFieldInfo.uiType == HB_IT_INTEGER )
pFieldInfo.uiType = HB_IT_LONG;
*/
if( ! bError )
bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE );
}
if( bError )
break;
}
hb_itemRelease( pItem );
if( bError )
{
hb_itemClear( pItemEof );
hb_itemRelease( pItemEof );
hb_errRT_PostgreSQLDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, 0 );
return HB_FAILURE;
}
pArea->ulRecCount = ( HB_ULONG ) PQntuples( pResult );
pArea->pRow = ( void ** ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) );
memset( pArea->pRowFlags, 0, ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) );
*pArea->pRow = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pArea->fFetched = HB_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;
pArray = hb_itemArrayNew( pArea->area.uiFieldCount );
for( ui = 0; ui < pArea->area.uiFieldCount; ++ui )
{
PHB_ITEM pItem = NULL;
LPFIELD pField = pArea->area.lpFields + ui;
HB_USHORT uiType = pField->uiType;
if( uiType == HB_FT_ANY )
{
switch( sqlite3_column_type( st, ui ) )
{
case SQLITE_TEXT:
uiType = HB_FT_STRING;
break;
case SQLITE_FLOAT:
case SQLITE_INTEGER:
uiType = HB_FT_LONG;
break;
case SQLITE_BLOB:
uiType = HB_FT_BLOB;
break;
}
}
switch( uiType )
{
case HB_FT_STRING:
pItem = S_HB_ITEMPUTSTR( NULL, ( const char * ) sqlite3_column_text( st, ui ) );
break;
case HB_FT_INTEGER:
#if HB_VMLONG_MAX > INT32_MAX && ! defined( HB_LONG_LONG_OFF )
pItem = hb_itemPutNInt( NULL, sqlite3_column_int64( st, ui ) );
break;
#endif
case HB_FT_LONG:
pItem = hb_itemPutNDDec( NULL, sqlite3_column_double( st, ui ), 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;
if( sqlite3_step( st ) != SQLITE_ROW )
{
pArea->fFetched = HB_TRUE;
break;
}
}
if( ulRecNo == 0 || ulRecNo > pArea->ulRecCount )
{
pArea->pRecord = pArea->pRow[ 0 ];
pArea->bRecordFlags = pArea->pRowFlags[ 0 ];
pArea->fPositioned = HB_FALSE;
}
else
{
pArea->pRecord = pArea->pRow[ ulRecNo ];
pArea->bRecordFlags = pArea->pRowFlags[ ulRecNo ];
pArea->fPositioned = HB_TRUE;
}
return HB_SUCCESS;
}
/*
* 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;
}
/*
* 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 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;
}
static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea )
{
SDDCONN * pSDDConn = ( SDDCONN * ) pArea->pConnection->pSDDConn;
SDDDATA * pSDDData;
O_HB_CHAR * pchQuery;
SQLHSTMT hStmt;
SQLSMALLINT iNameLen;
PHB_ITEM pItemEof, pItem;
HB_BOOL bError;
HB_USHORT uiFields, uiIndex;
HB_ERRCODE errCode;
char * szError;
SQLRETURN result;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
#if ODBCVER >= 0x0300
if( ! SQL_SUCCEEDED( SQLAllocHandle( SQL_HANDLE_STMT, pSDDConn->hConn, &hStmt ) ) )
#else
if( ! SQL_SUCCEEDED( SQLAllocStmt( pSDDConn->hConn, &hStmt ) ) )
#endif
{
szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, SQL_NULL_HSTMT, &errCode );
hb_errRT_ODBCDD( EG_OPEN, ESQLDD_STMTALLOC, szError, pArea->szQuery, errCode );
hb_xfree( szError );
return HB_FAILURE;
}
pchQuery = O_HB_CHARDUP( pArea->szQuery );
result = SQLExecDirect( hStmt,
( SQLTCHAR * ) HB_UNCONST( pchQuery ),
( SQLINTEGER ) O_HB_STRLEN( pchQuery ) );
hb_xfree( pchQuery );
if( ! SQL_SUCCEEDED( result ) )
{
szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, hStmt, &errCode );
#if ODBCVER >= 0x0300
SQLFreeHandle( SQL_HANDLE_STMT, hStmt );
#else
SQLFreeStmt( hStmt, SQL_DROP );
#endif
hb_errRT_ODBCDD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
hb_xfree( szError );
return HB_FAILURE;
}
if( ! SQL_SUCCEEDED( SQLNumResultCols( hStmt, &iNameLen ) ) )
{
szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, hStmt, &errCode );
#if ODBCVER >= 0x0300
SQLFreeHandle( SQL_HANDLE_STMT, hStmt );
#else
SQLFreeStmt( hStmt, SQL_DROP );
#endif
hb_errRT_ODBCDD( EG_OPEN, ESQLDD_STMTDESCR + 1000, szError, pArea->szQuery, errCode );
hb_xfree( szError );
return HB_FAILURE;
}
uiFields = ( HB_USHORT ) iNameLen;
SELF_SETFIELDEXTENT( &pArea->area, 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 dbFieldInfo;
char * pszName;
SQLTCHAR cName[ 256 ];
SQLULEN uiSize;
SQLSMALLINT iDataType, iDec, iNull;
if( ! SQL_SUCCEEDED( SQLDescribeCol( hStmt, ( SQLSMALLINT ) uiIndex + 1,
cName, HB_SIZEOFARRAY( cName ),
&iNameLen, &iDataType, &uiSize, &iDec, &iNull ) ) )
{
hb_itemRelease( pItemEof );
hb_itemRelease( pItem );
szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, hStmt, NULL );
#if ODBCVER >= 0x0300
SQLFreeHandle( SQL_HANDLE_STMT, hStmt );
#else
SQLFreeStmt( hStmt, SQL_DROP );
#endif
hb_errRT_ODBCDD( EG_OPEN, ESQLDD_STMTDESCR + 1001, szError, pArea->szQuery, 0 );
hb_xfree( szError );
return HB_FAILURE;
}
memset( &dbFieldInfo, 0, sizeof( dbFieldInfo ) );
dbFieldInfo.atomName = pszName = O_HB_OSSTRDUP( ( O_HB_CHAR * ) cName );
/*
We do mapping of many SQL types to one Harbour field type here, so, we need store
real SQL type in uiTypeExtended. SQL types are signed, so, HB_USHORT type casting
is a little hackish. We need to remember use this casting also in expressions like
this:
if( pField->uiTypeExtended == ( HB_USHORT ) SQL_BIGINT )
or introduce our own unsigned SQL types.
[Mindaugas]
*/
dbFieldInfo.uiTypeExtended = ( HB_USHORT ) iDataType;
dbFieldInfo.uiLen = ( HB_USHORT ) uiSize;
dbFieldInfo.uiDec = iDec;
if( iNull == SQL_NULLABLE )
dbFieldInfo.uiFlags |= HB_FF_NULLABLE;
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "field: name=%s type=%d len=%d dec=%d null=%d", dbFieldInfo.atomName, iDataType, uiSize, iDec, iNull ) );
#endif
switch( iDataType )
{
case SQL_CHAR:
case SQL_VARCHAR:
case SQL_LONGVARCHAR:
dbFieldInfo.uiType = HB_FT_STRING;
break;
case SQL_WCHAR:
case SQL_WVARCHAR:
case SQL_WLONGVARCHAR:
dbFieldInfo.uiType = HB_FT_STRING;
dbFieldInfo.uiFlags |= HB_FF_UNICODE;
break;
case SQL_BINARY:
case SQL_VARBINARY:
case SQL_LONGVARBINARY:
dbFieldInfo.uiType = HB_FT_STRING;
dbFieldInfo.uiFlags |= HB_FF_BINARY;
break;
case SQL_TINYINT:
case SQL_SMALLINT:
case SQL_INTEGER:
case SQL_BIGINT:
dbFieldInfo.uiType = HB_FT_INTEGER;
break;
case SQL_DECIMAL:
case SQL_NUMERIC:
dbFieldInfo.uiType = HB_FT_LONG;
break;
case SQL_REAL:
case SQL_FLOAT:
case SQL_DOUBLE:
dbFieldInfo.uiType = HB_FT_DOUBLE;
break;
case SQL_BIT:
dbFieldInfo.uiType = HB_FT_LOGICAL;
break;
case SQL_DATE:
#if ODBCVER >= 0x0300
case SQL_TYPE_DATE:
#endif
dbFieldInfo.uiType = HB_FT_DATE;
break;
case SQL_TIME:
#if ODBCVER >= 0x0300
case SQL_TYPE_TIME:
#endif
dbFieldInfo.uiType = HB_FT_TIME;
break;
/* SQL_DATETIME = SQL_DATE = 9 */
case SQL_TIMESTAMP:
#if ODBCVER >= 0x0300
case SQL_TYPE_TIMESTAMP:
#endif
dbFieldInfo.uiType = HB_FT_TIMESTAMP;
break;
default:
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "new sql type=%d", iDataType ) );
#endif
bError = HB_TRUE;
errCode = ( HB_ERRCODE ) iDataType;
break;
}
if( ! bError )
{
switch( dbFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr;
pStr = ( char * ) hb_xgrab( ( HB_SIZE ) dbFieldInfo.uiLen + 1 );
memset( pStr, ' ', dbFieldInfo.uiLen );
pStr[ dbFieldInfo.uiLen ] = '\0';
hb_itemPutCL( pItem, pStr, dbFieldInfo.uiLen );
hb_xfree( pStr );
break;
}
case HB_FT_MEMO:
hb_itemPutC( pItem, NULL );
break;
case HB_FT_INTEGER:
hb_itemPutNI( pItem, 0 );
break;
case HB_FT_LONG:
if( dbFieldInfo.uiDec == 0 )
hb_itemPutNLLen( pItem, 0, dbFieldInfo.uiLen );
else
hb_itemPutNDLen( pItem, 0.0, dbFieldInfo.uiLen, dbFieldInfo.uiDec );
break;
case HB_FT_DOUBLE:
hb_itemPutNDLen( pItem, 0.0, dbFieldInfo.uiLen, dbFieldInfo.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:
hb_itemPutTDT( pItem, 0, 0 );
break;
case HB_FT_TIMESTAMP:
hb_itemPutTDT( pItem, 0, 0 );
break;
default:
hb_itemClear( pItem );
bError = HB_TRUE;
break;
}
hb_arraySetForward( pItemEof, uiIndex + 1, pItem );
if( ! bError )
bError = ( SELF_ADDFIELD( &pArea->area, &dbFieldInfo ) == HB_FAILURE );
hb_xfree( pszName );
}
if( bError )
break;
}
hb_itemRelease( pItem );
if( bError )
{
hb_itemRelease( pItemEof );
#if ODBCVER >= 0x0300
SQLFreeHandle( SQL_HANDLE_STMT, hStmt );
#else
SQLFreeStmt( hStmt, SQL_DROP );
#endif
hb_errRT_ODBCDD( 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->hStmt = hStmt;
return HB_SUCCESS;
}
static const char * _hb_jsonDecode( const char * szSource, PHB_ITEM pValue )
{
if( *szSource == '\"' )
{
char * szDest, * szHead;
HB_SIZE nAlloc = 16;
szHead = szDest = ( char * ) hb_xgrab( nAlloc );
szSource++;
while( *szSource != '\"' )
{
if( szHead + 6 >= szDest + nAlloc )
{
HB_SIZE nLen = szHead - szDest;
nAlloc += nAlloc << 1;
szDest = ( char * ) hb_xrealloc( szDest, nAlloc );
szHead = szDest + nLen;
}
if( *szSource == '\\' )
{
szSource++;
switch( *szSource )
{
case '\"':
*szHead++ = '\"';
break;
case '\\':
*szHead++ = '\\';
break;
case '/':
*szHead++ = '/';
break;
case 'b':
*szHead++ = '\b';
break;
case 'f':
*szHead++ = '\f';
break;
case 'n':
*szHead++ = '\n';
break;
case 'r':
*szHead++ = '\r';
break;
case 't':
*szHead++ = '\t';
break;
case 'u':
{
HB_WCHAR wc = 0;
int i;
for( i = 0; i < 4; i++ )
{
char c = *++szSource;
wc <<= 4;
if( c >= '0' && c <= '9' )
wc += c - '0';
else if( c >= 'A' && c <= 'F' )
wc += c - 'A' + 10;
else if( c >= 'a' && c <= 'f' )
wc += c - 'a' + 10;
else
{
hb_xfree( szDest );
return NULL;
}
}
szHead += hb_cdpU16ToStr( hb_vmCDP(), HB_CDP_ENDIAN_NATIVE,
&wc, 1,
szHead, szDest + nAlloc - szHead );
break;
}
default:
hb_xfree( szDest );
return NULL;
}
szSource++;
}
else if( *( const unsigned char * ) szSource >= ' ' )
*szHead++ = *szSource++;
else
{
hb_xfree( szDest );
return NULL;
}
}
hb_itemPutCL( pValue, szDest, szHead - szDest );
hb_xfree( szDest );
return szSource + 1;
}
else if( *szSource == '-' || ( *szSource >= '0' && *szSource <= '9' ) )
{
/* NOTE: this function is much less strict to number format than
JSON syntax definition. This is allowed behaviour [Mindaugas] */
HB_MAXINT nValue = 0;
double dblValue = 0;
HB_BOOL fNeg, fDbl = HB_FALSE;
int iDec = 0;
fNeg = *szSource == '-';
if( fNeg )
szSource++;
while( *szSource >= '0' && *szSource <= '9' )
{
nValue = nValue * 10 + *szSource - '0';
szSource++;
}
if( *szSource == '.' )
{
double mult = 1;
dblValue = ( double ) nValue;
fDbl = HB_TRUE;
szSource++;
while( *szSource >= '0' && *szSource <= '9' )
{
mult /= 10;
dblValue += ( ( double ) ( *szSource - '0' ) ) * mult;
szSource++;
iDec++;
}
}
if( *szSource == 'e' || *szSource == 'E' )
{
HB_BOOL fNegExp;
int iExp = 0;
szSource++;
fNegExp = *szSource == '-';
if( fNegExp )
szSource++;
while( *szSource >= '0' && *szSource <= '9' )
{
iExp = iExp * 10 + *szSource - '0';
szSource++;
}
if( ! fDbl )
{
dblValue = ( double ) nValue;
fDbl = HB_TRUE;
}
if( fNegExp )
iDec += iExp;
dblValue = hb_numExpConv( dblValue, fNegExp ? iExp : -iExp );
}
if( fDbl )
hb_itemPutNDDec( pValue, hb_numRound( fNeg ? -dblValue : dblValue, iDec ), iDec );
else
hb_itemPutNInt( pValue, fNeg ? -nValue : nValue );
return szSource;
}
else if( ! strncmp( szSource, "null", 4 ) )
{
hb_itemClear( pValue );
return szSource + 4;
}
else if( ! strncmp( szSource, "true", 4 ) )
{
hb_itemPutL( pValue, HB_TRUE );
return szSource + 4;
}
else if( ! strncmp( szSource, "false", 5 ) )
{
hb_itemPutL( pValue, HB_FALSE );
return szSource + 5;
}
else if( *szSource == '[' )
{
hb_arrayNew( pValue, 0 );
szSource = _skipws( szSource + 1 );
if( *szSource != ']' )
{
PHB_ITEM pItem = hb_itemNew( NULL );
for( ;; )
{
szSource = _hb_jsonDecode( szSource, pItem );
if( ! szSource )
{
hb_itemRelease( pItem );
return NULL;
}
hb_arrayAddForward( pValue, pItem );
szSource = _skipws( szSource );
if( *szSource == ',' )
{
szSource = _skipws( szSource + 1 );
continue;
}
else if( *szSource == ']' )
break;
else
{
hb_itemRelease( pItem );
return NULL;
}
}
hb_itemRelease( pItem );
}
return szSource + 1;
}
else if( *szSource == '{' )
{
hb_hashNew( pValue );
szSource = _skipws( szSource + 1 );
if( *szSource != '}' )
{
PHB_ITEM pItemKey = hb_itemNew( NULL );
PHB_ITEM pItemValue = hb_itemNew( NULL );
for( ;; )
{
/* Do we need to check if key does not exist yet? */
if( ( szSource = _hb_jsonDecode( szSource, pItemKey ) ) == NULL ||
! HB_IS_STRING( pItemKey ) ||
* ( szSource = _skipws( szSource ) ) != ':' ||
( szSource = _hb_jsonDecode( _skipws( szSource + 1 ), pItemValue ) ) == NULL)
{
hb_itemRelease( pItemKey );
hb_itemRelease( pItemValue );
return NULL;
}
hb_hashAdd( pValue, pItemKey, pItemValue );
szSource = _skipws( szSource );
if( *szSource == ',' )
{
szSource = _skipws( szSource + 1 );
continue;
}
else if( *szSource == '}' )
break;
else
{
hb_itemRelease( pItemKey );
hb_itemRelease( pItemValue );
return NULL;
}
}
hb_itemRelease( pItemKey );
hb_itemRelease( pItemValue );
}
return szSource + 1;
}
return NULL;
}
static HB_ERRCODE mysqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem )
{
SDDDATA * pSDDData = ( SDDDATA * ) pArea->pSDDData;
LPFIELD pField;
char * pValue;
char szBuffer[ 64 ];
HB_BOOL bError;
PHB_ITEM pError;
HB_SIZE ulLen;
bError = HB_FALSE;
uiIndex--;
pField = pArea->area.lpFields + uiIndex;
pValue = pSDDData->pNatRecord[ uiIndex ];
ulLen = pSDDData->pNatLength[ uiIndex ];
/* NULL => NIL (?) */
if( ! pValue )
{
hb_itemClear( pItem );
return HB_SUCCESS;
}
switch( pField->uiType )
{
case HB_FT_STRING:
{
#if 0
char * pStr;
/* Expand strings to field length */
pStr = ( char * ) hb_xgrab( pField->uiLen + 1 );
if( pValue )
memcpy( pStr, pValue, ulLen );
if( ( HB_SIZE ) pField->uiLen > ulLen )
memset( pStr + ulLen, ' ', pField->uiLen - ulLen );
pStr[ pField->uiLen ] = '\0';
hb_itemPutCRaw( pItem, pStr, pField->uiLen );
#else
/* Do not expand strings */
if( pValue )
hb_itemPutCL( pItem, pValue, ulLen );
else
hb_itemPutC( pItem, NULL );
#endif
break;
}
case HB_FT_MEMO:
if( pValue )
hb_itemPutCL( pItem, pValue, ulLen );
else
hb_itemPutC( pItem, NULL );
hb_itemSetCMemo( pItem );
break;
case HB_FT_INTEGER:
case HB_FT_LONG:
case HB_FT_DOUBLE:
if( pValue )
{
hb_strncpy( szBuffer, pValue, sizeof( szBuffer ) - 1 );
if( pField->uiDec )
{
hb_itemPutNDLen( pItem, atof( szBuffer ),
( int ) pField->uiLen - ( ( int ) pField->uiDec + 1 ),
( int ) pField->uiDec );
}
else
hb_itemPutNLLen( pItem, atol( szBuffer ), ( int ) pField->uiLen );
}
else
{
if( pField->uiDec )
hb_itemPutNDLen( pItem, 0.0,
( int ) pField->uiLen - ( ( int ) pField->uiDec + 1 ),
( int ) pField->uiDec );
else
hb_itemPutNLLen( pItem, 0, ( int ) pField->uiLen );
}
break;
case HB_FT_DATE:
{
char szDate[ 9 ];
szDate[ 0 ] = pValue[ 0 ];
szDate[ 1 ] = pValue[ 1 ];
szDate[ 2 ] = pValue[ 2 ];
szDate[ 3 ] = pValue[ 3 ];
szDate[ 4 ] = pValue[ 5 ];
szDate[ 5 ] = pValue[ 6 ];
szDate[ 6 ] = pValue[ 8 ];
szDate[ 7 ] = pValue[ 9 ];
szDate[ 8 ] = '\0';
hb_itemPutDS( pItem, szDate );
break;
}
case HB_FT_TIMESTAMP:
{
char szTimeStamp[ 15 ];
szTimeStamp[ 0 ] = pValue[ 0 ];
szTimeStamp[ 1 ] = pValue[ 1 ];
szTimeStamp[ 2 ] = pValue[ 2 ];
szTimeStamp[ 3 ] = pValue[ 3 ];
szTimeStamp[ 4 ] = pValue[ 5 ];
szTimeStamp[ 5 ] = pValue[ 6 ];
szTimeStamp[ 6 ] = pValue[ 8 ];
szTimeStamp[ 7 ] = pValue[ 9 ];
szTimeStamp[ 8 ] = pValue[ 11 ];
szTimeStamp[ 9 ] = pValue[ 12 ];
szTimeStamp[ 10 ] = pValue[ 14 ];
szTimeStamp[ 11 ] = pValue[ 15 ];
szTimeStamp[ 12 ] = pValue[ 17 ];
szTimeStamp[ 13 ] = pValue[ 18 ];
szTimeStamp[ 14 ] = '\0';
hb_itemPutTS( pItem, szTimeStamp );
break;
}
case HB_FT_TIME:
{
char szTimeStamp[ 15 ];
szTimeStamp[ 0 ] = '0';
szTimeStamp[ 1 ] = '0';
szTimeStamp[ 2 ] = '0';
szTimeStamp[ 3 ] = '0';
szTimeStamp[ 4 ] = '0';
szTimeStamp[ 5 ] = '0';
szTimeStamp[ 6 ] = '0';
szTimeStamp[ 7 ] = '0';
szTimeStamp[ 8 ] = pValue[ 0 ];
szTimeStamp[ 9 ] = pValue[ 1 ];
szTimeStamp[ 10 ] = pValue[ 3 ];
szTimeStamp[ 11 ] = pValue[ 4 ];
szTimeStamp[ 12 ] = pValue[ 6 ];
szTimeStamp[ 13 ] = pValue[ 7 ];
szTimeStamp[ 14 ] = '\0';
hb_itemPutTS( pItem, szTimeStamp );
break;
}
default:
bError = HB_TRUE;
break;
}
if( bError )
{
pError = hb_errNew();
hb_errPutGenCode( pError, EG_DATATYPE );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_DATATYPE ) );
hb_errPutSubCode( pError, EDBF_DATATYPE );
SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return HB_FAILURE;
}
return HB_SUCCESS;
}
static HB_ERRCODE mysqlOpen( SQLBASEAREAP pArea )
{
MYSQL * pMySql = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pMySql;
SDDDATA * pSDDData;
PHB_ITEM pItemEof, pItem;
HB_ULONG ulIndex;
HB_USHORT uiFields, uiCount;
HB_ERRCODE errCode = 0;
HB_BOOL bError;
DBFIELDINFO pFieldInfo;
MYSQL_FIELD * pMyField;
void ** pRow;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
if( mysql_real_query( pMySql, pArea->szQuery, ( unsigned long ) strlen( pArea->szQuery ) ) )
{
hb_errRT_MySQLDD( EG_OPEN, ESQLDD_INVALIDQUERY, ( const char * ) mysql_error( pMySql ), pArea->szQuery,
mysql_errno( pMySql ) );
return HB_FAILURE;
}
if( ( pSDDData->pResult = mysql_store_result( pMySql ) ) == NULL )
{
hb_errRT_MySQLDD( EG_MEM, ESQLDD_INVALIDQUERY, ( const char * ) mysql_error( pMySql ), pArea->szQuery,
mysql_errno( pMySql ) );
return HB_FAILURE;
}
uiFields = ( HB_USHORT ) mysql_num_fields( pSDDData->pResult );
SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
bError = HB_FALSE;
for( uiCount = 0; uiCount < uiFields; uiCount++ )
{
pMyField = mysql_fetch_field_direct( pSDDData->pResult, uiCount );
pFieldInfo.atomName = pMyField->name;
pFieldInfo.uiLen = ( HB_USHORT ) pMyField->length;
pFieldInfo.uiDec = 0;
switch( pMyField->type )
{
case MYSQL_TYPE_TINY:
case MYSQL_TYPE_SHORT:
pFieldInfo.uiType = HB_FT_INTEGER;
break;
case MYSQL_TYPE_LONG:
case MYSQL_TYPE_LONGLONG:
case MYSQL_TYPE_INT24:
pFieldInfo.uiType = HB_FT_LONG;
break;
case MYSQL_TYPE_DECIMAL:
case MYSQL_TYPE_NEWDECIMAL:
case MYSQL_TYPE_FLOAT:
case MYSQL_TYPE_DOUBLE:
pFieldInfo.uiType = HB_FT_DOUBLE;
pFieldInfo.uiDec = ( HB_USHORT ) pMyField->decimals;
break;
case MYSQL_TYPE_STRING:
case MYSQL_TYPE_VAR_STRING:
case MYSQL_TYPE_ENUM:
pFieldInfo.uiType = HB_FT_STRING;
break;
case MYSQL_TYPE_DATE:
pFieldInfo.uiType = HB_FT_DATE;
break;
case MYSQL_TYPE_TINY_BLOB:
case MYSQL_TYPE_MEDIUM_BLOB:
case MYSQL_TYPE_LONG_BLOB:
case MYSQL_TYPE_BLOB:
pFieldInfo.uiType = HB_FT_MEMO;
break;
case MYSQL_TYPE_TIMESTAMP:
case MYSQL_TYPE_DATETIME:
pFieldInfo.uiType = HB_FT_TIMESTAMP;
pFieldInfo.uiLen = 8;
break;
case MYSQL_TYPE_TIME:
pFieldInfo.uiType = HB_FT_TIME;
pFieldInfo.uiLen = 4;
break;
case MYSQL_TYPE_NULL:
case MYSQL_TYPE_YEAR:
case MYSQL_TYPE_NEWDATE:
case MYSQL_TYPE_SET:
case MYSQL_TYPE_VARCHAR:
case MYSQL_TYPE_BIT:
case MYSQL_TYPE_GEOMETRY:
bError = HB_TRUE;
errCode = ( HB_ERRCODE ) pMyField->type;
pFieldInfo.uiType = 0;
break;
}
if( ! bError )
{
switch( pFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr;
pStr = ( char * ) hb_xgrab( pFieldInfo.uiLen + 1 );
memset( pStr, ' ', pFieldInfo.uiLen );
pStr[ pFieldInfo.uiLen ] = '\0';
pItem = hb_itemPutCL( NULL, pStr, pFieldInfo.uiLen );
hb_xfree( pStr );
break;
}
case HB_FT_MEMO:
pItem = hb_itemPutC( NULL, NULL );
break;
case HB_FT_INTEGER:
pItem = hb_itemPutNI( NULL, 0 );
break;
case HB_FT_LONG:
pItem = hb_itemPutNL( NULL, 0 );
break;
case HB_FT_DOUBLE:
pItem = hb_itemPutND( NULL, 0.0 );
break;
case HB_FT_DATE:
pItem = hb_itemPutDS( NULL, NULL );
break;
case HB_FT_TIMESTAMP:
case HB_FT_TIME:
pItem = hb_itemPutTDT( NULL, 0, 0 );
break;
default:
pItem = hb_itemNew( NULL );
bError = HB_TRUE;
break;
}
hb_arraySetForward( pItemEof, uiCount + 1, pItem );
hb_itemRelease( pItem );
#if 0
if( pFieldInfo.uiType == HB_IT_DOUBLE || pFieldInfo.uiType == HB_IT_INTEGER )
pFieldInfo.uiType = HB_IT_LONG;
#endif
if( ! bError )
bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE );
}
if( bError )
break;
}
if( bError )
{
hb_itemRelease( pItemEof );
hb_errRT_MySQLDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode );
return HB_FAILURE;
}
pArea->ulRecCount = ( HB_ULONG ) mysql_num_rows( pSDDData->pResult );
pArea->pRow = ( void ** ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrabz( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) );
pArea->ulRecMax = pArea->ulRecCount + 1;
pRow = pArea->pRow;
*pRow = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pRow++;
for( ulIndex = 1; ulIndex <= pArea->ulRecCount; ulIndex++ )
{
*pRow++ = ( void * ) mysql_row_tell( pSDDData->pResult );
mysql_fetch_row( pSDDData->pResult );
}
pArea->fFetched = HB_TRUE;
return HB_SUCCESS;
}
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 amqp_response_type_enum s_process_response( int iParam, amqp_rpc_reply_t x )
{
if( HB_ISBYREF( iParam ) )
{
PHB_ITEM hResponse = hb_hashNew( NULL );
PHB_ITEM pKey = hb_itemNew( NULL );
PHB_ITEM pVal = hb_itemNew( NULL );
char szName[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 5 ];
hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "cAPI" ), hb_itemPutC( pVal, hb_procname( 0, szName, HB_FALSE ) ) );
hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReplyType" ), hb_itemPutNI( pVal, ( int ) x.reply_type ) );
hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nLibraryError" ), hb_itemPutNI( pVal, x.library_error ) );
hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "cLibraryError" ), hb_itemPutC( pVal, amqp_error_string2( x.library_error ) ) );
switch( x.reply_type )
{
case AMQP_RESPONSE_NORMAL:
/* fallthrough */
case AMQP_RESPONSE_LIBRARY_EXCEPTION:
/* fallthrough */
case AMQP_RESPONSE_NONE:
break;
case AMQP_RESPONSE_SERVER_EXCEPTION:
hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReplyID" ), hb_itemPutNI( pVal, ( int ) x.reply.id ) );
switch( x.reply.id )
{
case AMQP_CONNECTION_CLOSE_METHOD:
{
amqp_connection_close_t * m = ( amqp_connection_close_t * ) x.reply.decoded;
hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_Code" ), hb_itemPutNL( pVal, ( long ) m->reply_code ) );
hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_Text" ), hb_itemPutCL( pVal, m->reply_text.bytes, m->reply_text.len ) );
hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_ClassID" ), hb_itemPutNL( pVal, ( long ) m->class_id ) );
hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_MethodID" ), hb_itemPutNL( pVal, ( long ) m->method_id ) );
break;
}
case AMQP_CHANNEL_CLOSE_METHOD:
{
amqp_channel_close_t * m = ( amqp_channel_close_t * ) x.reply.decoded;
hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_Code" ), hb_itemPutNL( pVal, ( long ) m->reply_code ) );
hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_Text" ), hb_itemPutCL( pVal, m->reply_text.bytes, m->reply_text.len ) );
hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_ClassID" ), hb_itemPutNL( pVal, ( long ) m->class_id ) );
hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_MethodID" ), hb_itemPutNL( pVal, ( long ) m->method_id ) );
break;
}
}
break;
}
if( ! hb_itemParamStoreRelease( iParam, hResponse ) )
hb_itemRelease( hResponse );
hb_itemRelease( pVal );
hb_itemRelease( pKey );
}
return x.reply_type;
}
static HB_ERRCODE adsxOrderInfo( ADSXAREAP pArea, HB_USHORT uiIndex, LPDBORDERINFO pOrderInfo )
{
PMIXTAG pTag = pArea->pTagCurrent;
/* resolve any pending relations */
if( pArea->adsarea.lpdbPendingRel )
SELF_FORCEREL( ( AREAP ) pArea );
/* all others need an index handle */
if( uiIndex != DBOI_ORDERCOUNT )
{
if( pOrderInfo->itmOrder )
{
if( HB_IS_STRING( pOrderInfo->itmOrder ) )
{
pTag = pArea->pTagList;
while( pTag )
{
if( ! hb_stricmp( hb_itemGetCPtr( pOrderInfo->itmOrder ), pTag->szName ) )
break;
pTag = pTag->pNext;
}
}
else if( HB_IS_NUMERIC( pOrderInfo->itmOrder ) )
{
UNSIGNED16 usOrder = 0, usSearch = ( UNSIGNED16 ) hb_itemGetNI( pOrderInfo->itmOrder );
AdsGetNumIndexes( pArea->adsarea.hTable, &usOrder );
pTag = usSearch <= usOrder ? NULL : pArea->pTagList;
while( pTag )
{
if( ++usOrder == usSearch )
break;
pTag = pTag->pNext;
}
}
}
if( ! pTag )
return SUPER_ORDINFO( ( AREAP ) pArea, uiIndex, pOrderInfo );
}
switch( uiIndex )
{
case DBOI_CONDITION:
hb_itemPutC( pOrderInfo->itmResult, pTag->szForExpr );
break;
case DBOI_EXPRESSION:
hb_itemPutC( pOrderInfo->itmResult, pTag->szKeyExpr );
break;
case DBOI_ISCOND:
hb_itemPutL( pOrderInfo->itmResult, pTag->pForItem != NULL );
break;
case DBOI_ISDESC:
hb_itemPutL( pOrderInfo->itmResult, HB_FALSE );
break;
case DBOI_UNIQUE:
hb_itemPutL( pOrderInfo->itmResult, HB_FALSE );
break;
case DBOI_KEYTYPE:
hb_itemPutCL( pOrderInfo->itmResult, ( char * ) &pTag->bType, 1 );
break;
case DBOI_KEYSIZE:
hb_itemPutNI( pOrderInfo->itmResult, pTag->uiLen );
break;
case DBOI_KEYVAL:
{
PHB_ITEM pItem;
PHB_CODEPAGE pCodepage = hb_cdpSelect( pArea->adsarea.area.cdPage );
pItem = hb_vmEvalBlockOrMacro( pTag->pKeyItem );
hb_cdpSelect( pCodepage );
hb_itemMove( pOrderInfo->itmResult, pItem );
break;
}
case DBOI_KEYCOUNT:
case DBOI_KEYCOUNTRAW: /* ignore filter but RESPECT SCOPE */
hb_itemPutNL( pOrderInfo->itmResult, pTag->ulRecCount );
break;
case DBOI_POSITION:
case DBOI_RECNO:
case DBOI_KEYNORAW:
if( uiIndex == DBOI_POSITION && pOrderInfo->itmNewVal && HB_IS_NUMERIC( pOrderInfo->itmNewVal ) )
{
HB_ULONG ulPos;
ulPos = hb_itemGetNL( pOrderInfo->itmNewVal );
if( ulPos > 0 && ulPos <= pTag->ulRecCount )
SELF_GOTO( ( AREAP ) pArea, pTag->pKeys[ ulPos - 1 ]->rec );
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, ! pArea->adsarea.area.fEof );
}
else
{
PMIXKEY pKey;
HB_ULONG ulKeyPos;
if( ! pArea->adsarea.fPositioned )
SELF_GOTO( ( AREAP ) pArea, pArea->adsarea.ulRecNo );
else
pArea->adsarea.area.fEof = HB_FALSE;
pKey = mixKeyEval( pTag, pArea );
hb_itemPutNL( pOrderInfo->itmResult,
mixFindKey( pTag, pKey, &ulKeyPos ) ? ( ulKeyPos + 1 ) : 0 );
mixKeyFree( pKey );
}
break;
case DBOI_RELKEYPOS:
if( pOrderInfo->itmNewVal && HB_IS_NUMERIC( pOrderInfo->itmNewVal ) )
{
HB_ULONG ulPos;
ulPos = ( HB_ULONG ) ( hb_itemGetND( pOrderInfo->itmNewVal ) * ( double ) pTag->ulRecCount );
if( ulPos > 0 && ulPos <= pTag->ulRecCount )
SELF_GOTO( ( AREAP ) pArea, pTag->pKeys[ ulPos - 1 ]->rec );
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, ! pArea->adsarea.area.fEof );
}
else
{
PMIXKEY pKey;
HB_ULONG ulKeyPos;
if( ! pArea->adsarea.fPositioned )
SELF_GOTO( ( AREAP ) pArea, pArea->adsarea.ulRecNo );
else
pArea->adsarea.area.fEof = HB_FALSE;
pKey = mixKeyEval( pTag, pArea );
if( ! mixFindKey( pTag, pKey, &ulKeyPos + 1 ) )
ulKeyPos = 0;
mixKeyFree( pKey );
pOrderInfo->itmResult = hb_itemPutND( pOrderInfo->itmResult,
( double ) ulKeyPos / ( double ) pTag->ulRecCount );
}
break;
case DBOI_NAME:
hb_itemPutC( pOrderInfo->itmResult, pTag->szName );
break;
case DBOI_BAGNAME:
hb_itemPutC( pOrderInfo->itmResult, NULL );
break;
case DBOI_FULLPATH:
hb_itemPutC( pOrderInfo->itmResult, NULL );
break;
case DBOI_BAGEXT:
hb_itemPutC( pOrderInfo->itmResult, "mix" );
break;
case DBOI_ORDERCOUNT:
{
UNSIGNED16 usOrder = 0;
AdsGetNumIndexes( pArea->adsarea.hTable, &usOrder );
pTag = pArea->pTagList;
while( pTag )
{
pTag = pTag->pNext;
usOrder++;
}
hb_itemPutNI( pOrderInfo->itmResult, ( int ) usOrder );
break;
}
case DBOI_NUMBER:
{
PMIXTAG pTag2;
UNSIGNED16 usOrder = 0;
AdsGetNumIndexes( pArea->adsarea.hTable, &usOrder );
pTag2 = pArea->pTagList;
usOrder++;
while( pTag2 && pTag != pTag2 )
{
pTag2 = pTag2->pNext;
usOrder++;
}
hb_itemPutNI( pOrderInfo->itmResult, ( int ) usOrder );
break;
}
case DBOI_CUSTOM:
hb_itemPutL( pOrderInfo->itmResult, HB_FALSE );
break;
case DBOI_OPTLEVEL:
hb_itemPutNI( pOrderInfo->itmResult, DBOI_OPTIMIZED_NONE );
break;
case DBOI_KEYADD:
hb_itemPutL( pOrderInfo->itmResult, HB_FALSE );
break;
case DBOI_KEYDELETE:
hb_itemPutL( pOrderInfo->itmResult, HB_FALSE );
break;
case DBOI_AUTOOPEN:
hb_itemPutL( pOrderInfo->itmResult, HB_FALSE );
break;
default:
return SUPER_ORDINFO( ( AREAP ) pArea, uiIndex, pOrderInfo );
}
return HB_SUCCESS;
}
