static HB_BOOL hb_regex( int iRequest )
{
#if defined( HB_HAS_PCRE2 )
HB_REGMATCH * aMatches;
#else
HB_REGMATCH aMatches[ HB_REGMATCH_SIZE( REGEX_MAX_GROUPS ) ];
#endif
PHB_ITEM pRetArray, pString;
int 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, HB_TRUE ) ? HBREG_ICASE : 0 ) |
( hb_parl( 4 ) ? HBREG_NEWLINE : 0 ) );
if( ! pRegEx )
return HB_FALSE;
#if defined( HB_HAS_PCRE2 )
aMatches = pRegEx->re_match_data = pcre2_match_data_create( REGEX_MAX_GROUPS, NULL );
#endif
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 )
{
PHB_ITEM pMatch;
int i;
switch( iRequest )
{
case 0:
pRetArray = hb_itemArrayNew( iMatches );
for( i = 0; i < iMatches; i++ )
{
if( HB_REGMATCH_EO( aMatches, i ) != HB_REGMATCH_UNSET )
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: /* 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 != ( int ) HB_REGMATCH_UNSET )
{
/* 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, HB_TRUE ); /* 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 != ( int ) HB_REGMATCH_UNSET )
{
/* 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 != ( int ) HB_REGMATCH_UNSET )
/* 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 != ( int ) HB_REGMATCH_UNSET )
{
/* 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 != ( int ) HB_REGMATCH_UNSET )
/* 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 == ( int ) HB_REGMATCH_UNSET )
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 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;
}
dblValue *= pow( 10.0, ( double ) ( fNegExp ? -iExp : iExp ) );
if( fNegExp )
iDec += iExp;
}
if( fDbl )
hb_itemPutNDDec( pValue, fNeg ? -dblValue : dblValue, 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 );
hb_hashSetFlags( pValue, HB_HASH_KEEPORDER );
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 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 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 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;
}
PHB_ITEM hb_itemDo( PHB_ITEM pItem, HB_SIZE ulPCount, ... )
{
HB_THREAD_STUB
PHB_ITEM pResult = NULL;
HB_TRACE( HB_TR_DEBUG, ( "hb_itemDo(%p, %hu, ...)", pItem, ulPCount ) );
if( pItem )
{
PHB_SYMB pSymbol = NULL;
if( HB_IS_STRING( pItem ) )
{
PHB_DYNS pDynSym = hb_dynsymFindName( pItem->item.asString.value );
if( pDynSym )
pSymbol = pDynSym->pSymbol;
}
else if( HB_IS_POINTER( pItem ) )
pSymbol = ( PHB_SYMB ) pItem->item.asPointer.value;
else if( HB_IS_SYMBOL( pItem ) )
pSymbol = pItem->item.asSymbol.value;
if( pSymbol )
{
hb_vmPushState();
hb_vmPushSymbol( pSymbol );
hb_vmPushNil();
if( ulPCount )
{
register ULONG ulParam;
va_list va;
va_start( va, ulPCount );
for( ulParam = 1; ulParam <= ulPCount; ulParam++ )
hb_vmPush( va_arg( va, PHB_ITEM ) );
va_end( va );
}
hb_vmDo( ( USHORT ) ulPCount );
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
hb_vmPopState();
}
else if( HB_IS_BLOCK( pItem ) )
{
hb_vmPushState();
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pItem );
if( ulPCount )
{
register ULONG ulParam;
va_list va;
va_start( va, ulPCount );
for( ulParam = 1; ulParam <= ulPCount; ulParam++ )
hb_vmPush( va_arg( va, PHB_ITEM ) );
va_end( va );
}
hb_vmSend( ( USHORT ) ulPCount );
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
hb_vmPopState();
}
else if( HB_IS_ARRAY( pItem ) )
{
hb_vmPushState();
if( hb_execFromArray( pItem ) )
{
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
}
hb_vmPopState();
}
}
return pResult;
}
static void insertdata( struct hb_BTree * pBTree )
{
PHB_ITEM data = hb_itemNew( NULL );
hb_BTreeInsert( pBTree, "fuweqgsz", hb_itemPutNL( data, 1 ) );
hb_BTreeInsert( pBTree, "sjruexrd", hb_itemPutNL( data, 2 ) );
hb_BTreeInsert( pBTree, "fvveitnz", hb_itemPutNL( data, 3 ) );
hb_BTreeInsert( pBTree, "aqgksjxe", hb_itemPutNL( data, 4 ) );
hb_BTreeInsert( pBTree, "oonrehvj", hb_itemPutNL( data, 5 ) );
hb_BTreeInsert( pBTree, "gvowjwtr", hb_itemPutNL( data, 6 ) );
hb_BTreeInsert( pBTree, "xxidwtvn", hb_itemPutNL( data, 7 ) );
hb_BTreeInsert( pBTree, "rwjbxesd", hb_itemPutNL( data, 8 ) );
hb_BTreeInsert( pBTree, "yaznsaek", hb_itemPutNL( data, 9 ) );
hb_BTreeInsert( pBTree, "wbdhfkfy", hb_itemPutNL( data, 10 ) );
hb_BTreeInsert( pBTree, "lryaezia", hb_itemPutNL( data, 11 ) );
hb_BTreeInsert( pBTree, "tspmnrvk", hb_itemPutNL( data, 12 ) );
hb_BTreeInsert( pBTree, "hpxryhdj", hb_itemPutNL( data, 13 ) );
hb_BTreeInsert( pBTree, "sztcqaby", hb_itemPutNL( data, 14 ) );
hb_BTreeInsert( pBTree, "fcyzsqja", hb_itemPutNL( data, 15 ) );
hb_BTreeInsert( pBTree, "uccxumvg", hb_itemPutNL( data, 16 ) );
hb_BTreeInsert( pBTree, "amwuoout", hb_itemPutNL( data, 17 ) );
hb_BTreeInsert( pBTree, "yaytseln", hb_itemPutNL( data, 18 ) );
hb_BTreeInsert( pBTree, "sfiiozej", hb_itemPutNL( data, 19 ) );
hb_BTreeInsert( pBTree, "xuvsoljy", hb_itemPutNL( data, 20 ) );
hb_BTreeInsert( pBTree, "qmqjbedm", hb_itemPutNL( data, 21 ) );
hb_BTreeInsert( pBTree, "cctzzrkz", hb_itemPutNL( data, 22 ) );
hb_BTreeInsert( pBTree, "ikytgdon", hb_itemPutNL( data, 23 ) );
hb_BTreeInsert( pBTree, "pksobcwu", hb_itemPutNL( data, 24 ) );
hb_BTreeInsert( pBTree, "vmurindj", hb_itemPutNL( data, 25 ) );
hb_BTreeInsert( pBTree, "elvybqwg", hb_itemPutNL( data, 26 ) );
hb_BTreeInsert( pBTree, "ixchaztx", hb_itemPutNL( data, 27 ) );
hb_BTreeInsert( pBTree, "nzpztlhd", hb_itemPutNL( data, 28 ) );
hb_BTreeInsert( pBTree, "aucrchiw", hb_itemPutNL( data, 29 ) );
hb_BTreeInsert( pBTree, "munrytse", hb_itemPutNL( data, 30 ) );
hb_BTreeInsert( pBTree, "kqkhcmls", hb_itemPutNL( data, 31 ) );
hb_BTreeInsert( pBTree, "abqhurbi", hb_itemPutNL( data, 32 ) );
hb_BTreeInsert( pBTree, "ymrldckr", hb_itemPutNL( data, 33 ) );
hb_BTreeInsert( pBTree, "rhsmfflc", hb_itemPutNL( data, 34 ) );
hb_BTreeInsert( pBTree, "apyfkvee", hb_itemPutNL( data, 35 ) );
hb_BTreeInsert( pBTree, "cdntyzrf", hb_itemPutNL( data, 36 ) );
hb_BTreeInsert( pBTree, "iacblqrh", hb_itemPutNL( data, 37 ) );
hb_BTreeInsert( pBTree, "xvewqana", hb_itemPutNL( data, 38 ) );
hb_BTreeInsert( pBTree, "xmybqytj", hb_itemPutNL( data, 39 ) );
hb_BTreeInsert( pBTree, "dnowympf", hb_itemPutNL( data, 40 ) );
hb_BTreeInsert( pBTree, "smloihft", hb_itemPutNL( data, 41 ) );
hb_BTreeInsert( pBTree, "zumppmis", hb_itemPutNL( data, 42 ) );
hb_BTreeInsert( pBTree, "jirucnxu", hb_itemPutNL( data, 43 ) );
hb_BTreeInsert( pBTree, "ecdzikcv", hb_itemPutNL( data, 44 ) );
hb_BTreeInsert( pBTree, "slbwvnpg", hb_itemPutNL( data, 45 ) );
hb_BTreeInsert( pBTree, "yaftlkmz", hb_itemPutNL( data, 46 ) );
hb_BTreeInsert( pBTree, "blcepksd", hb_itemPutNL( data, 47 ) );
hb_BTreeInsert( pBTree, "xufowlpl", hb_itemPutNL( data, 48 ) );
hb_BTreeInsert( pBTree, "xegtjtqc", hb_itemPutNL( data, 49 ) );
hb_BTreeInsert( pBTree, "yplcqumq", hb_itemPutNL( data, 50 ) );
hb_BTreeInsert( pBTree, "vdoycauz", hb_itemPutNL( data, 51 ) );
hb_BTreeInsert( pBTree, "uhqkjuph", hb_itemPutNL( data, 52 ) );
hb_BTreeInsert( pBTree, "prllaeyi", hb_itemPutNL( data, 53 ) );
hb_BTreeInsert( pBTree, "ybzgmwzm", hb_itemPutNL( data, 54 ) );
hb_BTreeInsert( pBTree, "kkvyllnp", hb_itemPutNL( data, 55 ) );
hb_BTreeInsert( pBTree, "nberwsrb", hb_itemPutNL( data, 56 ) );
hb_BTreeInsert( pBTree, "wgetahua", hb_itemPutNL( data, 57 ) );
hb_BTreeInsert( pBTree, "yxcyehcv", hb_itemPutNL( data, 58 ) );
hb_BTreeInsert( pBTree, "oacormks", hb_itemPutNL( data, 59 ) );
hb_BTreeInsert( pBTree, "mcadkdxo", hb_itemPutNL( data, 60 ) );
hb_BTreeInsert( pBTree, "ycsalwqw", hb_itemPutNL( data, 61 ) );
hb_BTreeInsert( pBTree, "qmpysvjl", hb_itemPutNL( data, 62 ) );
hb_BTreeInsert( pBTree, "iqikamew", hb_itemPutNL( data, 63 ) );
hb_BTreeInsert( pBTree, "iaparrva", hb_itemPutNL( data, 64 ) );
hb_BTreeInsert( pBTree, "casbvtay", hb_itemPutNL( data, 65 ) );
hb_BTreeInsert( pBTree, "blaksexr", hb_itemPutNL( data, 66 ) );
hb_BTreeInsert( pBTree, "tbosrbql", hb_itemPutNL( data, 67 ) );
hb_BTreeInsert( pBTree, "ifkywsyt", hb_itemPutNL( data, 68 ) );
hb_BTreeInsert( pBTree, "gvklwevy", hb_itemPutNL( data, 69 ) );
hb_BTreeInsert( pBTree, "krpmpbud", hb_itemPutNL( data, 70 ) );
hb_BTreeInsert( pBTree, "rdvlwbwm", hb_itemPutNL( data, 71 ) );
hb_BTreeInsert( pBTree, "apnvdkww", hb_itemPutNL( data, 72 ) );
hb_BTreeInsert( pBTree, "euqdocvm", hb_itemPutNL( data, 73 ) );
hb_BTreeInsert( pBTree, "ksmkjcwp", hb_itemPutNL( data, 74 ) );
hb_BTreeInsert( pBTree, "bztgclzc", hb_itemPutNL( data, 75 ) );
hb_BTreeInsert( pBTree, "awkdnuxa", hb_itemPutNL( data, 76 ) );
hb_BTreeInsert( pBTree, "abavnpod", hb_itemPutNL( data, 77 ) );
hb_BTreeInsert( pBTree, "dvwvhjmh", hb_itemPutNL( data, 78 ) );
hb_BTreeInsert( pBTree, "dmfmivqb", hb_itemPutNL( data, 79 ) );
hb_BTreeInsert( pBTree, "ewsxanon", hb_itemPutNL( data, 80 ) );
hb_itemRelease( data );
}
HB_ERRCODE hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest,
LPDBTRANSINFO lpdbTransInfo,
PHB_ITEM * pStruct, PHB_ITEM pFields )
{
HB_USHORT uiFields, uiSize, uiCount, uiPosSrc, uiPosDst, uiSizeSrc, uiSizeDst;
HB_ERRCODE errCode;
const char * szField;
HB_BOOL fAll;
errCode = SELF_FIELDCOUNT( lpaSource, &uiSizeSrc );
if( errCode != HB_SUCCESS )
return errCode;
if( lpaDest )
{
errCode = SELF_FIELDCOUNT( lpaDest, &uiSizeDst );
if( errCode != HB_SUCCESS )
return errCode;
uiSize = HB_MIN( uiSizeDst, uiSizeSrc );
}
else
{
uiSize = uiSizeDst = uiSizeSrc;
}
if( ! uiSize )
return HB_FAILURE;
if( hb_itemType( pFields ) & HB_IT_ARRAY )
{
uiFields = ( HB_USHORT ) hb_arrayLen( pFields );
if( uiFields )
uiSize = uiFields;
}
else
uiFields = 0;
fAll = ( uiSizeDst == uiSizeSrc );
lpdbTransInfo->lpaSource = lpaSource;
lpdbTransInfo->lpaDest = lpaDest;
lpdbTransInfo->lpTransItems = ( LPDBTRANSITEM )
hb_xgrab( uiSize * sizeof( DBTRANSITEM ) );
if( ! lpaDest )
{
*pStruct = hb_itemNew( NULL );
hb_arrayNew( *pStruct, 0 );
}
if( uiFields == 0 )
{
if( lpaDest )
{
PHB_ITEM pItem = hb_itemNew( NULL );
uiSize = 0;
for( uiCount = 1; uiCount <= uiSizeSrc; ++uiCount )
{
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_NAME, pItem ) != HB_SUCCESS )
{
uiSize = 0;
break;
}
szField = hb_itemGetCPtr( pItem );
uiPosDst = hb_rddFieldExpIndex( lpaDest, szField );
if( uiPosDst != uiCount )
fAll = HB_FALSE;
if( uiPosDst )
{
HB_USHORT ui;
/* check for replicated field names in source area */
for( ui = 0; ui < uiSize; ++ui )
{
if( lpdbTransInfo->lpTransItems[ ui ].uiDest == uiPosDst )
break;
}
if( ui == uiSize )
{
lpdbTransInfo->lpTransItems[ uiSize ].uiSource = uiCount;
lpdbTransInfo->lpTransItems[ uiSize++ ].uiDest = uiPosDst;
}
}
}
hb_itemRelease( pItem );
}
else
{
hb_tblStructure( lpaSource, *pStruct, 0 );
uiSize = ( HB_USHORT ) hb_arrayLen( *pStruct );
for( uiCount = 0; uiCount < uiSize; ++uiCount )
{
lpdbTransInfo->lpTransItems[ uiCount ].uiSource =
lpdbTransInfo->lpTransItems[ uiCount ].uiDest = uiCount + 1;
}
}
}
else
{
uiSize = 0;
for( uiCount = 1; uiCount <= uiFields; ++uiCount )
{
szField = hb_dbTransFieldPos( pFields, uiCount );
if( szField )
{
uiPosSrc = hb_rddFieldExpIndex( lpaSource, szField );
if( ! uiPosSrc )
continue;
if( lpaDest )
uiPosDst = hb_rddFieldExpIndex( lpaDest, szField );
else
uiPosDst = uiSize + 1;
if( uiPosDst )
{
if( uiPosSrc != uiPosDst )
fAll = HB_FALSE;
lpdbTransInfo->lpTransItems[ uiSize ].uiSource = uiPosSrc;
lpdbTransInfo->lpTransItems[ uiSize++ ].uiDest = uiPosDst;
if( ! lpaDest )
{
hb_arraySize( *pStruct, uiSize );
hb_fldStructure( lpaSource, uiPosSrc, 0,
hb_arrayGetItemPtr( *pStruct, uiSize ) );
}
}
}
}
}
if( uiSize != uiSizeSrc )
fAll = HB_FALSE;
if( fAll && lpaDest )
{
PHB_ITEM pSrcItm = hb_itemNew( NULL ),
pDstItm = hb_itemNew( NULL );
/*
* if fAll is HB_TRUE here then it means that all fields are included
* and they are on the same positions in both tables, so now check
* if their types and sizes are also equal
*/
for( uiCount = 1; uiCount <= uiSize; ++uiCount )
{
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_TYPE, pSrcItm ) != HB_SUCCESS ||
SELF_FIELDINFO( lpaDest, uiCount, DBS_TYPE, pDstItm ) != HB_SUCCESS )
{
uiSize = 0;
break;
}
if( hb_stricmp( hb_itemGetCPtr( pSrcItm ),
hb_itemGetCPtr( pDstItm ) ) != 0 )
{
fAll = HB_FALSE;
break;
}
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_LEN, pSrcItm ) != HB_SUCCESS ||
SELF_FIELDINFO( lpaDest, uiCount, DBS_LEN, pDstItm ) != HB_SUCCESS )
{
uiSize = 0;
break;
}
if( hb_itemGetNL( pSrcItm ) != hb_itemGetNL( pDstItm ) )
{
fAll = HB_FALSE;
break;
}
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_DEC, pSrcItm ) != HB_SUCCESS ||
SELF_FIELDINFO( lpaDest, uiCount, DBS_DEC, pDstItm ) != HB_SUCCESS )
{
uiSize = 0;
break;
}
if( hb_itemGetNL( pSrcItm ) != hb_itemGetNL( pDstItm ) )
{
fAll = HB_FALSE;
break;
}
#ifdef DBS_FLAG
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_FLAG, pSrcItm ) != HB_SUCCESS ||
SELF_FIELDINFO( lpaDest, uiCount, DBS_FLAG, pDstItm ) != HB_SUCCESS )
{
uiSize = 0;
break;
}
#endif
if( hb_itemGetNL( pSrcItm ) != hb_itemGetNL( pDstItm ) )
{
fAll = HB_FALSE;
break;
}
}
hb_itemRelease( pSrcItm );
hb_itemRelease( pDstItm );
}
lpdbTransInfo->uiFlags = fAll ? DBTF_MATCH : 0;
lpdbTransInfo->uiItemCount = uiSize;
return uiSize ? HB_SUCCESS : HB_FAILURE;
}
PHB_ITEM hb_fsDirectory( const char * pszDirSpec, const char * pszAttributes )
{
PHB_ITEM pDir = hb_itemArrayNew( 0 );
char * pszFree = NULL;
PHB_FFIND ffind;
HB_FATTR ulMask;
/* Get the passed attributes and convert them to Harbour Flags */
ulMask = HB_FA_ARCHIVE |
HB_FA_READONLY |
HB_FA_DEVICE |
HB_FA_TEMPORARY |
HB_FA_SPARSE |
HB_FA_REPARSE |
HB_FA_COMPRESSED |
HB_FA_OFFLINE |
HB_FA_NOTINDEXED |
HB_FA_ENCRYPTED |
HB_FA_VOLCOMP;
if( pszAttributes && *pszAttributes )
ulMask |= hb_fsAttrEncode( pszAttributes );
if( pszDirSpec && *pszDirSpec )
{
if( ulMask != HB_FA_LABEL )
{
/* CA-Cl*pper compatible behavior - add all file mask when
* last character is directory or drive separator
*/
HB_SIZE nLen = strlen( pszDirSpec ) - 1;
#ifdef HB_OS_HAS_DRIVE_LETTER
if( pszDirSpec[ nLen ] == HB_OS_PATH_DELIM_CHR ||
pszDirSpec[ nLen ] == HB_OS_DRIVE_DELIM_CHR )
#else
if( pszDirSpec[ nLen ] == HB_OS_PATH_DELIM_CHR )
#endif
pszDirSpec = pszFree =
hb_xstrcpy( NULL, pszDirSpec, HB_OS_ALLFILE_MASK, NULL );
}
}
else
pszDirSpec = HB_OS_ALLFILE_MASK;
/* Get the file list */
if( ( ffind = hb_fsFindFirst( pszDirSpec, ulMask ) ) != NULL )
{
PHB_ITEM pSubarray = hb_itemNew( NULL );
do
{
char buffer[ 32 ];
hb_arrayNew ( pSubarray, F_LEN );
hb_arraySetC ( pSubarray, F_NAME, ffind->szName );
hb_arraySetNInt( pSubarray, F_SIZE, ffind->size );
hb_arraySetDL ( pSubarray, F_DATE, ffind->lDate );
hb_arraySetC ( pSubarray, F_TIME, ffind->szTime );
hb_arraySetC ( pSubarray, F_ATTR, hb_fsAttrDecode( ffind->attr, buffer ) );
/* Don't exit when array limit is reached */
hb_arrayAddForward( pDir, pSubarray );
}
while( hb_fsFindNext( ffind ) );
hb_itemRelease( pSubarray );
hb_fsFindClose( ffind );
}
if( pszFree )
hb_xfree( pszFree );
return pDir;
}
static void hb_ParseLine( PHB_ITEM pReturn, const char * szText, int iDelimiter, int * iWord )
{
if( szText )
{
HB_ISIZ nLen = strlen( szText );
if( nLen > 0 )
{
PHB_ITEM pTemp = hb_itemNew( NULL );
HB_ISIZ i = 0;
int word_count = 0;
/* booked enough memory */
char * szResult = ( char * ) hb_xgrab( nLen + 1 );
#if 0
while( nLen )
{
if( szText[ nLen - 1 ] && ! HB_ISSPACE( szText[ nLen - 1 ] ) )
break;
nLen--;
}
szText[ nLen ] = 0;
nLen = strlen( szText );
#endif
while( i < nLen )
{
HB_ISIZ ui = 0;
hb_xmemset( szResult, ' ', nLen + 1 );
/* an '"' found, loop until the next one is found */
if( szText[ i ] == '"' )
{
/* an '"' after '"' ? */
if( szText[ i + 1 ] != '"' )
{
szResult[ ui ] = szText[ i + 1 ];
}
else
{
szResult[ ui ] = '\0';
}
++i;
while( ++i < nLen )
{
if( szText[ i - 1 ] == '"' )
{
szResult[ ui + 1 ] = '\0';
break;
}
else
{
if( szText[ i ] == '"' )
szResult[ ui + 1 ] = '\0';
else
szResult[ ++ui ] = szText[ i ];
}
}
word_count++;
hb_arrayAddForward( pReturn, hb_itemPutC( pTemp, szResult ) );
}
/* delimiter found */
else if( szText[ i ] == iDelimiter )
{
/* first delimiter found but no word yet */
if( word_count == 0 )
{
/* add an empty string */
szResult[ ui ] = '\0';
}
else
{
/* we have already have the first word */
/* check next character */
if( szText[ i - 1 ] == iDelimiter )
{
/* delimiter after delimiter */
/* just add an empty string */
szResult[ ui ] = '\0';
}
else
{
/* ",,0" */
/* it is not a delimiter */
/* move to next character */
++i;
szResult[ ui ] = szText[ i ];
while( ++i < nLen )
{
if( szText[ i ] == iDelimiter )
{
break;
}
else
{
szResult[ ++ui ] = szText[ i ];
}
}
}
}
word_count++;
szResult[ ui + 1 ] = '\0';
hb_arrayAddForward( pReturn, hb_itemPutC( pTemp, szResult ) );
}
else
{
szResult[ ui ] = szText[ i ];
while( ++i < nLen )
{
if( szText[ i ] == iDelimiter )
{
szResult[ ui + 1 ] = '\0';
break;
}
else if( szText[ i ] == '"' )
{
szResult[ ui ] = szText[ i + 1 ];
++i;
while( ++i < nLen )
{
if( szText[ i - 1 ] == '"' )
{
szResult[ ui + 1 ] = '\0';
break;
}
else
{
if( szText[ i ] == '"' )
{
szResult[ ui + 1 ] = '\0';
break;
}
else
{
szResult[ ++ui ] = szText[ i ];
}
}
}
}
else
{
szResult[ ++ui ] = szText[ i ];
}
}
word_count++;
szResult[ ui + 1 ] = '\0';
hb_arrayAddForward( pReturn, hb_itemPutC( pTemp, szResult ) );
}
i++;
}
/* last character in passed string is a delimiter */
/* just add an empty string */
if( szText[ nLen - 1 ] == iDelimiter )
{
word_count++;
hb_arrayAddForward( pReturn, hb_itemPutC( pTemp, NULL ) );
}
/* store number of words */
*iWord = word_count;
/* clean up */
hb_xfree( szResult );
hb_itemRelease( pTemp );
}
}
}
static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea )
{
SDDCONN * pSDDConn = ( SDDCONN * ) pArea->pConnection->pSDDConn;
SDDDATA * pSDDData;
void * hQuery;
SQLHSTMT hStmt;
SQLSMALLINT iNameLen;
PHB_ITEM pItemEof, pItem;
HB_BOOL bError;
HB_USHORT uiFields, uiIndex;
HB_ERRCODE errCode;
char * szError;
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;
}
pItem = hb_itemPutC( NULL, pArea->szQuery );
if( ! SQL_SUCCEEDED( SQLExecDirect( hStmt,
( SQLTCHAR * ) O_HB_ITEMGETSTR( pItem, &hQuery, NULL ),
( SQLINTEGER ) hb_itemGetCLen( pItem ) ) ) )
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
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;
}
else
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
}
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( ( AREAP ) pArea, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
#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;
SQLTCHAR cName[ 256 ];
SQLULEN uiSize;
SQLSMALLINT iDataType, iDec, iNull;
if( ! SQL_SUCCEEDED( SQLDescribeCol( hStmt, ( SQLSMALLINT ) uiIndex + 1, ( SQLTCHAR * ) cName, HB_SIZEOFARRAY( cName ), &iNameLen, &iDataType, &uiSize, &iDec, &iNull ) ) )
{
hb_itemRelease( pItemEof );
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;
}
pName = O_HB_ITEMPUTSTRLEN( NULL, ( O_HB_CHAR * ) cName, iNameLen );
pFieldInfo.atomName = hb_itemGetCPtr( pName );
/*
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 hacky. 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]
*/
pFieldInfo.uiTypeExtended = ( HB_USHORT ) iDataType;
pFieldInfo.uiLen = ( HB_USHORT ) uiSize;
pFieldInfo.uiDec = iDec;
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "field: name=%s type=%d len=%d dec=%d null=%d", pFieldInfo.atomName, iDataType, uiSize, iDec, iNull ) );
#endif
switch( iDataType )
{
case SQL_CHAR:
case SQL_VARCHAR:
case SQL_LONGVARCHAR:
case SQL_WCHAR:
case SQL_WVARCHAR:
case SQL_WLONGVARCHAR:
pFieldInfo.uiType = HB_FT_STRING;
break;
case SQL_VARBINARY:
case SQL_LONGVARBINARY:
pFieldInfo.uiType = HB_FT_STRING;
pFieldInfo.uiFlags = HB_FF_BINARY;
break;
case SQL_TINYINT:
case SQL_SMALLINT:
case SQL_INTEGER:
case SQL_BIGINT:
pFieldInfo.uiType = HB_FT_INTEGER;
break;
case SQL_DECIMAL:
case SQL_NUMERIC:
pFieldInfo.uiType = HB_FT_LONG;
break;
case SQL_REAL:
case SQL_FLOAT:
case SQL_DOUBLE:
pFieldInfo.uiType = HB_FT_DOUBLE;
break;
case SQL_BIT:
pFieldInfo.uiType = HB_FT_LOGICAL;
break;
case SQL_DATE:
#if ODBCVER >= 0x0300
case SQL_TYPE_DATE:
#endif
pFieldInfo.uiType = HB_FT_DATE;
break;
case SQL_TIME:
#if ODBCVER >= 0x0300
case SQL_TYPE_TIME:
#endif
pFieldInfo.uiType = HB_FT_DATE;
break;
/* SQL_DATETIME = SQL_DATE = 9 */
case SQL_TIMESTAMP:
#if ODBCVER >= 0x0300
case SQL_TYPE_TIMESTAMP:
#endif
pFieldInfo.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;
pFieldInfo.uiType = 0;
pFieldInfo.uiType = HB_FT_STRING;
break;
}
if( ! bError )
{
switch( pFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr;
pStr = ( char * ) hb_xgrab( ( HB_SIZE ) 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:
if( pFieldInfo.uiDec == 0 )
pItem = hb_itemPutNLLen( NULL, 0, pFieldInfo.uiLen );
else
pItem = hb_itemPutNDLen( NULL, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec );
break;
case HB_FT_DOUBLE:
pItem = hb_itemPutNDLen( NULL, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec );
break;
case HB_FT_LOGICAL:
pItem = hb_itemPutL( NULL, HB_FALSE );
break;
case HB_FT_DATE:
pItem = hb_itemPutDL( NULL, 0 );
break;
case HB_FT_TIME:
pItem = hb_itemPutTDT( NULL, 0, 0 );
break;
case HB_FT_TIMESTAMP:
pItem = hb_itemPutTDT( NULL, 0, 0 );
break;
default:
pItem = hb_itemNew( NULL );
bError = HB_TRUE;
break;
}
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 );
#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 * ) );
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->hStmt = hStmt;
return HB_SUCCESS;
}
static HB_ERRCODE adsxOrderCreate( ADSXAREAP pArea, LPDBORDERCREATEINFO pOrderInfo )
{
PMIXTAG pTagNew, pTag;
PHB_ITEM pKeyItem, pForItem = NULL, pWhileItem = NULL, pResult;
HB_ULONG ulRecNo;
HB_USHORT uiLen;
HB_BYTE bType;
UNSIGNED16 bValidExpr;
HB_BOOL bUseADS;
/* Test key expression */
bValidExpr = 0;
AdsIsExprValid( pArea->adsarea.hTable, ( UNSIGNED8 * ) hb_itemGetCPtr( pOrderInfo->abExpr ), &bValidExpr );
bUseADS = bValidExpr;
if( bUseADS && pArea->adsarea.area.lpdbOrdCondInfo )
{
/* Test FOR expression */
if( pArea->adsarea.area.lpdbOrdCondInfo->abFor )
{
bValidExpr = 0;
AdsIsExprValid( pArea->adsarea.hTable, ( UNSIGNED8 * ) pArea->adsarea.area.lpdbOrdCondInfo->abFor, &bValidExpr );
bUseADS = bValidExpr;
}
else if( pArea->adsarea.area.lpdbOrdCondInfo->itmCobFor )
{
bUseADS = HB_FALSE;
}
/* Test WHILE expression */
if( bUseADS )
{
if( pArea->adsarea.area.lpdbOrdCondInfo->abWhile )
{
bValidExpr = 0;
AdsIsExprValid( pArea->adsarea.hTable, ( UNSIGNED8 * ) pArea->adsarea.area.lpdbOrdCondInfo->abWhile, &bValidExpr );
bUseADS = ( bValidExpr != 0 );
}
else if( pArea->adsarea.area.lpdbOrdCondInfo->itmCobWhile )
bUseADS = HB_FALSE;
}
}
if( bUseADS )
{
return SUPER_ORDCREATE( ( AREAP ) pArea, pOrderInfo );
}
/* Obtain key codeblock */
if( pOrderInfo->itmCobExpr )
{
pKeyItem = hb_itemNew( pOrderInfo->itmCobExpr );
}
else
{
if( SELF_COMPILE( ( AREAP ) pArea, hb_itemGetCPtr( pOrderInfo->abExpr ) ) == HB_FAILURE )
return HB_FAILURE;
pKeyItem = pArea->adsarea.area.valResult;
pArea->adsarea.area.valResult = NULL;
}
/* Test key codeblock on EOF */
ulRecNo = pArea->adsarea.ulRecNo;
SELF_GOTO( ( AREAP ) pArea, 0 );
if( SELF_EVALBLOCK( ( AREAP ) pArea, pKeyItem ) == HB_FAILURE )
{
hb_vmDestroyBlockOrMacro( pKeyItem );
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
return HB_FAILURE;
}
pResult = pArea->adsarea.area.valResult;
pArea->adsarea.area.valResult = NULL;
switch( hb_itemType( pResult ) )
{
case HB_IT_STRING:
case HB_IT_STRING | HB_IT_MEMO:
bType = 'C';
uiLen = ( HB_USHORT ) hb_itemGetCLen( pResult );
if( uiLen > MIX_MAXKEYLEN )
uiLen = MIX_MAXKEYLEN;
break;
case HB_IT_INTEGER:
case HB_IT_LONG:
case HB_IT_DOUBLE:
bType = 'N';
uiLen = 8;
break;
case HB_IT_DATE:
bType = 'D';
uiLen = 8;
break;
case HB_IT_LOGICAL:
bType = 'L';
uiLen = 1;
break;
default:
bType = 'U';
uiLen = 0;
}
hb_itemRelease( pResult );
if( bType == 'U' || uiLen == 0 )
{
hb_vmDestroyBlockOrMacro( pKeyItem );
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
hb_mixErrorRT( pArea, bType == 'U' ? EG_DATATYPE : EG_DATAWIDTH, 1026, NULL, 0, 0 );
return HB_FAILURE;
}
if( pArea->adsarea.area.lpdbOrdCondInfo )
{
/* Obtain FOR codeblock */
if( pArea->adsarea.area.lpdbOrdCondInfo->itmCobFor )
{
pForItem = hb_itemNew( pArea->adsarea.area.lpdbOrdCondInfo->itmCobFor );
}
else if( pArea->adsarea.area.lpdbOrdCondInfo->abFor )
{
if( SELF_COMPILE( ( AREAP ) pArea, pArea->adsarea.area.lpdbOrdCondInfo->abFor ) == HB_FAILURE )
{
hb_vmDestroyBlockOrMacro( pKeyItem );
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
return HB_FAILURE;
}
pForItem = pArea->adsarea.area.valResult;
pArea->adsarea.area.valResult = NULL;
}
/* Obtain WHILE codeblock */
if( pArea->adsarea.area.lpdbOrdCondInfo->itmCobWhile )
{
pWhileItem = hb_itemNew( pArea->adsarea.area.lpdbOrdCondInfo->itmCobWhile );
}
else if( pArea->adsarea.area.lpdbOrdCondInfo->abWhile )
{
if( SELF_COMPILE( ( AREAP ) pArea, pArea->adsarea.area.lpdbOrdCondInfo->abWhile ) == HB_FAILURE )
{
hb_vmDestroyBlockOrMacro( pKeyItem );
if( pForItem )
hb_vmDestroyBlockOrMacro( pForItem );
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
return HB_FAILURE;
}
pWhileItem = pArea->adsarea.area.valResult;
pArea->adsarea.area.valResult = NULL;
}
}
/* Test FOR codeblock on EOF */
if( pForItem )
{
if( SELF_EVALBLOCK( ( AREAP ) pArea, pForItem ) == HB_FAILURE )
{
hb_vmDestroyBlockOrMacro( pKeyItem );
hb_vmDestroyBlockOrMacro( pForItem );
if( pWhileItem )
hb_vmDestroyBlockOrMacro( pWhileItem );
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
return HB_FAILURE;
}
if( hb_itemType( pArea->adsarea.area.valResult ) != HB_IT_LOGICAL )
{
hb_itemRelease( pArea->adsarea.area.valResult );
pArea->adsarea.area.valResult = 0;
hb_vmDestroyBlockOrMacro( pKeyItem );
hb_vmDestroyBlockOrMacro( pForItem );
if( pWhileItem )
hb_vmDestroyBlockOrMacro( pWhileItem );
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
hb_mixErrorRT( pArea, EG_DATATYPE, EDBF_INVALIDFOR, NULL, 0, 0 );
return HB_FAILURE;
}
hb_itemRelease( pArea->adsarea.area.valResult );
pArea->adsarea.area.valResult = NULL;
}
/* TODO: WHILE condition is not tested, like in DBFCDX. Why? Compatibility with Clipper? */
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
pTagNew = mixTagCreate( pOrderInfo->atomBagName, pOrderInfo->abExpr, pKeyItem,
pForItem, pWhileItem, bType, uiLen, pArea );
if( pWhileItem )
hb_vmDestroyBlockOrMacro( pWhileItem );
/* Append the tag to the end of list */
if( pArea->pTagList )
{
pTag = pArea->pTagList;
while( pTag->pNext )
pTag = pTag->pNext;
pTag->pNext = pTagNew;
}
else
{
pArea->pTagList = pTagNew;
}
pArea->pTagCurrent = pTagNew;
pArea->adsarea.hOrdCurrent = 0;
return HB_SUCCESS;
}
static void sk_add( BOOL bReturn, SHORT iKeyCode, PHB_ITEM pAction, PHB_ITEM pIsActive )
{
if( iKeyCode )
{
PHB_SETKEY sk_list_tmp, sk_list_end;
// Verify to allow only codeblock in pIsActive
pIsActive = ( pIsActive && HB_IS_BLOCK( pIsActive ) ) ? pIsActive : NULL;
sk_list_tmp = sk_findkey( iKeyCode, &sk_list_end );
if( sk_list_tmp == NULL )
{
if( pAction )
{
sk_list_tmp = ( PHB_SETKEY ) hb_xgrab( sizeof( HB_SETKEY ) );
sk_list_tmp->next = NULL;
sk_list_tmp->iKeyCode = iKeyCode;
sk_list_tmp->pAction = hb_itemNew( pAction );
sk_list_tmp->pIsActive = pIsActive ? hb_itemNew( pIsActive ) : NULL;
if( sk_list_end == NULL )
{
s_sk_list = sk_list_tmp;
}
else
{
sk_list_end->next = sk_list_tmp;
}
}
}
else
{
/* Return the previous value */
if( bReturn )
hb_itemReturn( sk_list_tmp->pAction );
/* Free the previous values */
hb_itemRelease( sk_list_tmp->pAction );
if( sk_list_tmp->pIsActive )
{
hb_itemRelease( sk_list_tmp->pIsActive );
}
/* Set the new values or free the entry */
if( pAction )
{
sk_list_tmp->pAction = hb_itemNew( pAction );
sk_list_tmp->pIsActive = pIsActive ? hb_itemNew( pIsActive ) : NULL;
}
else
{
/* if this is true, then the key found is the first key in the list */
if( sk_list_end == NULL )
{
sk_list_tmp = s_sk_list->next;
hb_xfree( s_sk_list );
s_sk_list = sk_list_tmp;
}
else
{
sk_list_end->next = sk_list_tmp->next;
hb_xfree( sk_list_tmp );
}
}
}
}
}
/* NOTE: Same as hb_itemDoC(), but has additional second parameter
which set the reference mask for 1-st 32/64 parametes [druzus]
*/
PHB_ITEM hb_itemDoCRef( char * szFunc, HB_SIZE ulRefMask, HB_SIZE ulPCount, ... )
{
HB_THREAD_STUB
PHB_ITEM pResult = NULL;
HB_TRACE( HB_TR_DEBUG, ( "hb_itemDoCRef(%s, %hu, %hu, ...)", szFunc, ulRefMask, ulPCount ) );
if( szFunc )
{
PHB_DYNS pDynSym;
pDynSym = hb_dynsymFindName( szFunc );
if( pDynSym )
{
hb_vmPushState();
hb_vmPushSymbol( pDynSym->pSymbol );
hb_vmPushNil();
if( ulPCount )
{
PHB_ITEM pItemRefBuf[ sizeof( HB_SIZE ) * 8 ];
HB_ITEM itmRef;
register HB_SIZE ulParam;
HB_SIZE ulRef = 0;
va_list va;
PHB_ITEM * pRefBase;
PHB_ITEM pParam;
pRefBase = pItemRefBuf;
/* initialize the reference item */
itmRef.type = HB_IT_BYREF;
itmRef.item.asRefer.offset = -1;
itmRef.item.asRefer.BasePtr.itemsbasePtr = &pRefBase;
va_start( va, ulPCount );
for( ulParam = 0; ulParam < ulPCount; ulParam++ )
{
pParam = va_arg( va, PHB_ITEM );
if( ulRefMask & ( 1L << ulParam ) )
{
/* when item is passed by reference then we have to put
* the reference on the stack instead of the item itself
*/
pItemRefBuf[ ulRef++ ] = pParam;
itmRef.item.asRefer.value = ( LONG ) ulRef;
/* hb_vmPush( &itmRef ); */
pParam = &itmRef;
}
hb_vmPush( pParam );
}
va_end( va );
}
hb_vmDo( ( USHORT ) ulPCount );
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
hb_vmPopState();
}
}
return pResult;
}
PHB_ITEM hb_itemDo( PHB_ITEM pItem, HB_ULONG ulPCount, ... )
{
PHB_ITEM pResult = NULL;
HB_TRACE( HB_TR_DEBUG, ( "hb_itemDo(%p, %lu, ...)", pItem, ulPCount ) );
if( pItem )
{
PHB_SYMB pSymbol = NULL;
if( HB_IS_STRING( pItem ) )
{
PHB_DYNS pDynSym = hb_dynsymFindName( pItem->item.asString.value );
if( pDynSym )
{
pSymbol = pDynSym->pSymbol;
pItem = NULL;
}
}
else if( HB_IS_SYMBOL( pItem ) )
{
pSymbol = pItem->item.asSymbol.value;
pItem = NULL;
}
else if( HB_IS_BLOCK( pItem ) )
{
pSymbol = &hb_symEval;
}
if( pSymbol )
{
if( hb_vmRequestReenter() )
{
hb_vmPushSymbol( pSymbol );
if( pItem )
hb_vmPush( pItem );
else
hb_vmPushNil();
if( ulPCount )
{
HB_ULONG ulParam;
va_list va;
va_start( va, ulPCount );
for( ulParam = 1; ulParam <= ulPCount; ulParam++ )
hb_vmPush( va_arg( va, PHB_ITEM ) );
va_end( va );
}
if( pItem )
hb_vmSend( ( HB_USHORT ) ulPCount );
else
hb_vmProc( ( HB_USHORT ) ulPCount );
pResult = hb_itemNew( hb_stackReturnItem() );
hb_vmRequestRestore();
}
}
}
return pResult;
}
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", iNameLen ) );
#endif
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;
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "field: name=%s type=%d len=%d dec=%d nullable=%d", pFieldInfo.atomName, iDataType, iSize, iDec ) );
#endif
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:
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "new sql type=%d", iDataType ) );
#endif
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 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_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_YEAR:
case MYSQL_TYPE_NEWDATE:
case MYSQL_TYPE_ENUM:
case MYSQL_TYPE_SET:
*/
default:
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( 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;
}
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_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) );
memset( pArea->pRowFlags, 0, ( 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;
}
