bool Callback( int iProgress )
{
PHB_ITEM Disk = hb_itemPutNL( NULL, m_uTotalSoFar ), Total = hb_itemPutNL( NULL, m_uTotalToDo );
( void ) iProgress;
hb_vmEvalBlockV( pProgressInfo, 2, Disk, Total );
hb_itemRelease( Disk );
hb_itemRelease( Total );
return TRUE;
}
bool hb_SetProgressofTdSpan( DWORD a, int iSoFar, void * pData )
{
PHB_ITEM Disk = hb_itemPutNL( NULL, iSoFar ), Total = hb_itemPutNL( NULL, a );
HB_SYMBOL_UNUSED( pData );
hb_vmEvalBlockV( pProgressInfo, 2, Disk, Total );
hb_itemRelease( Disk );
hb_itemRelease( Total );
return TRUE;
}
/*
* Retrieve information about the current table/driver.
*/
static HB_ERRCODE hb_delimInfo( DELIMAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimInfo(%p,%hu,%p)", pArea, uiIndex, pItem));
switch( uiIndex )
{
case DBI_CANPUTREC:
hb_itemPutL( pItem, pArea->fTransRec );
break;
case DBI_GETRECSIZE:
hb_itemPutNL( pItem, pArea->uiRecordLen );
break;
case DBI_GETDELIMITER:
{
char szDelim[ 2 ];
szDelim[ 0 ] = pArea->cDelim;
szDelim[ 1 ] = '\0';
hb_itemPutC( pItem, szDelim );
break;
}
case DBI_SETDELIMITER:
if( hb_itemType( pItem ) & HB_IT_STRING )
{
char * szDelim = hb_itemGetCPtr( pItem );
if( hb_stricmp( szDelim, "BLANK" ) == 0 )
{
pArea->cDelim = '\0';
pArea->cSeparator = ' ';
}
#ifndef HB_C52_STRICT
else if( hb_stricmp( szDelim, "PIPE" ) == 0 )
{
pArea->cDelim = '\0';
pArea->cSeparator = '|';
}
else if( hb_stricmp( szDelim, "TAB" ) == 0 )
{
pArea->cDelim = '\0';
pArea->cSeparator = '\t';
}
else
#else
else if( *szDelim )
#endif
{
pArea->cDelim = *szDelim;
}
}
/*
* a small trick which allow to set character field delimiter and
* field separator in COPY TO ... and APPEND FROM ... commands as
* array. F.e.:
* COPY TO test DELIMITED WITH ({"","|"})
*/
#ifndef HB_C52_STRICT
else if( hb_itemType( pItem ) & HB_IT_ARRAY )
/*
* Retrieve information about the current table/driver.
*/
static HB_ERRCODE hb_sdfInfo( SDFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_sdfInfo(%p,%hu,%p)", pArea, uiIndex, pItem ) );
switch( uiIndex )
{
case DBI_CANPUTREC:
hb_itemPutL( pItem, pArea->fTransRec );
break;
case DBI_GETRECSIZE:
hb_itemPutNL( pItem, pArea->uiRecordLen );
break;
case DBI_FULLPATH:
hb_itemPutC( pItem, pArea->szFileName );
break;
case DBI_FILEHANDLE:
hb_itemPutNInt( pItem, ( HB_NHANDLE ) hb_fileHandle( pArea->pFile ) );
break;
case DBI_SHARED:
hb_itemPutL( pItem, pArea->fShared );
break;
case DBI_ISREADONLY:
hb_itemPutL( pItem, pArea->fReadonly );
break;
case DBI_POSITIONED:
hb_itemPutL( pItem, pArea->fPositioned );
break;
case DBI_DB_VERSION:
case DBI_RDD_VERSION:
{
char szBuf[ 64 ];
int iSub = hb_itemGetNI( pItem );
if( iSub == 1 )
hb_snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s)", 0, 1, "SDF" );
else if( iSub == 2 )
hb_snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s:%d)", 0, 1, "SDF", pArea->area.rddID );
else
hb_snprintf( szBuf, sizeof( szBuf ), "%d.%d", 0, 1 );
hb_itemPutC( pItem, szBuf );
break;
}
default:
return SUPER_INFO( &pArea->area, uiIndex, pItem );
}
return HB_SUCCESS;
}
static void s_hb_hashSetCItemNL( PHB_ITEM pHash, const char * pszKey, long v )
{
PHB_ITEM pKey = hb_itemPutC( NULL, pszKey );
PHB_ITEM pValue = hb_itemPutNL( NULL, v );
hb_hashAdd( pHash, pKey, pValue );
hb_itemRelease( pValue );
hb_itemRelease( pKey );
}
bool Callback( int iProgress )
{
PHB_ITEM Disk = hb_itemPutNL( NULL, m_uDiskNeeded );
( void ) iProgress;
hb_vmEvalBlockV( ChangeDiskBlock, 1, Disk );
hb_itemRelease( Disk );
return TRUE;
}
static HRESULT STDMETHODCALLTYPE Invoke( IDispatch * lpThis, DISPID dispid, REFIID riid,
LCID lcid, WORD wFlags, DISPPARAMS * pParams,
VARIANT * pVarResult, EXCEPINFO * pExcepInfo,
UINT * puArgErr )
{
PHB_ITEM pAction;
HRESULT hr;
HB_SYMBOL_UNUSED( lcid );
HB_SYMBOL_UNUSED( wFlags );
HB_SYMBOL_UNUSED( pExcepInfo );
HB_SYMBOL_UNUSED( puArgErr );
if( ! IsEqualIID( riid, HB_ID_REF( IID_NULL ) ) )
return DISP_E_UNKNOWNINTERFACE;
hr = DISP_E_MEMBERNOTFOUND;
pAction = ( ( ISink * ) lpThis )->pItemHandler;
if( pAction )
{
PHB_ITEM pKey = hb_itemPutNL( hb_stackAllocItem(), ( long ) dispid );
if( pAction && HB_IS_HASH( pAction ) )
{
pAction = hb_hashGetItemPtr( pAction, pKey, 0 );
pKey = NULL;
}
if( pAction && hb_oleDispInvoke( NULL, pAction, pKey,
pParams, pVarResult, NULL,
( ( ISink * ) lpThis )->uiClass ) )
hr = S_OK;
hb_stackPop();
}
return hr;
}
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 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;
}
//------------------------------------------------------------------------------
// IEventHandler's Invoke()
// self is where the action happens
// self function receives events (by their ID number) and distributes the processing
// or them or ignores them
static ULONG STDMETHODCALLTYPE Invoke( IEventHandler *self, DISPID dispid, REFIID riid,
LCID lcid, WORD wFlags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *pexcepinfo,
UINT *puArgErr )
{
PHB_ITEM pItem;
int iArg, i;
PHB_ITEM pItemArray[32]; // max 32 parameters?
PHB_ITEM *pItems;
ULONG ulRefMask = 0;
ULONG ulPos;
PHB_ITEM Key;
Key = hb_itemNew( NULL );
// We implement only a "default" interface
if ( !IsEqualIID( riid, &IID_NULL ) )
return( DISP_E_UNKNOWNINTERFACE );
HB_SYMBOL_UNUSED(lcid);
HB_SYMBOL_UNUSED(wFlags);
HB_SYMBOL_UNUSED(result);
HB_SYMBOL_UNUSED(pexcepinfo);
HB_SYMBOL_UNUSED(puArgErr);
// delegate work to somewhere else in PRG
//***************************************
#ifdef __USEHASHEVENTS
if ( hb_hashScan( ((MyRealIEventHandler* ) self)->pEvents, hb_itemPutNL( Key, dispid ),
&ulPos ) )
{
PHB_ITEM pArray = hb_hashGetValueAt( ((MyRealIEventHandler* ) self)->pEvents, ulPos );
#else
ulPos = hb_arrayScan( ((MyRealIEventHandler* ) self)->pEvents, hb_itemPutNL( Key, dispid ),
NULL, NULL, 0
#ifdef __XHARBOUR__
, 0
#endif
);
if ( ulPos )
{
PHB_ITEM pArray = hb_arrayGetItemPtr( ((MyRealIEventHandler* ) self)->pEventsExec, ulPos );
#endif
PHB_ITEM pExec = hb_arrayGetItemPtr( pArray, 01 );
if ( pExec )
{
hb_vmRequestReenter();
switch ( hb_itemType( pExec ) )
{
case HB_IT_BLOCK:
{
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pExec );
break;
}
case HB_IT_STRING:
{
PHB_ITEM pObject = hb_arrayGetItemPtr( pArray, 2 );
hb_vmPushSymbol( hb_dynsymSymbol( hb_dynsymFindName( hb_itemGetCPtr( pExec ) ) ) );
if ( HB_IS_OBJECT( pObject ) )
hb_vmPush( pObject );
else
hb_vmPushNil();
break;
}
case HB_IT_POINTER:
{
hb_vmPushSymbol( hb_dynsymSymbol( ( (PHB_SYMB) pExec ) -> pDynSym ) );
hb_vmPushNil();
break;
}
}
iArg = params->cArgs;
for( i = 1; i<= iArg; i++ )
{
pItem = hb_itemNew(NULL);
hb_oleVariantToItem( pItem, &(params->rgvarg[iArg-i]) );
pItemArray[i-1] = pItem;
// set bit i
ulRefMask |= ( 1L << (i-1) );
}
if( iArg )
{
pItems = pItemArray;
hb_itemPushList( ulRefMask, iArg, &pItems );
}
// execute
hb_vmDo( (USHORT) iArg );
// En caso de que los parametros sean pasados por referencia
for( i=iArg; i > 0; i-- )
{
if( ( (&(params->rgvarg[iArg-i]))->n1.n2.vt & VT_BYREF ) == VT_BYREF )
{
switch( (&(params->rgvarg[iArg-i]))->n1.n2.vt )
{
//case VT_UI1|VT_BYREF:
// *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pbVal) = va_arg(argList,unsigned char*); //pItemArray[i-1]
// break;
case VT_I2|VT_BYREF:
*((&(params->rgvarg[iArg-i]))->n1.n2.n3.piVal) = (short) hb_itemGetNI(pItemArray[i-1]);
break;
case VT_I4|VT_BYREF:
*((&(params->rgvarg[iArg-i]))->n1.n2.n3.plVal) = (long) hb_itemGetNL(pItemArray[i-1]);
break;
case VT_R4|VT_BYREF:
*((&(params->rgvarg[iArg-i]))->n1.n2.n3.pfltVal) = (float) hb_itemGetND(pItemArray[i-1]);
break;
case VT_R8|VT_BYREF:
*((&(params->rgvarg[iArg-i]))->n1.n2.n3.pdblVal) = (double) hb_itemGetND(pItemArray[i-1]);
break;
case VT_BOOL|VT_BYREF:
*((&(params->rgvarg[iArg-i]))->n1.n2.n3.pboolVal) = (VARIANT_BOOL) ( hb_itemGetL( pItemArray[i-1] ) ? 0xFFFF : 0 );
break;
//case VT_ERROR|VT_BYREF:
// *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pscode) = va_arg(argList, SCODE*);
// break;
case VT_DATE|VT_BYREF:
*((&(params->rgvarg[iArg-i]))->n1.n2.n3.pdate) = (DATE) (double) (hb_itemGetDL(pItemArray[i-1])-2415019 );
break;
//case VT_CY|VT_BYREF:
// *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pcyVal) = va_arg(argList, CY*);
// break;
//case VT_BSTR|VT_BYREF:
// *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pbstrVal = va_arg(argList, BSTR*);
// break;
//case VT_UNKNOWN|VT_BYREF:
// pArg->ppunkVal = va_arg(argList, LPUNKNOWN*);
// break;
//case VT_DISPATCH|VT_BYREF:
// pArg->ppdispVal = va_arg(argList, LPDISPATCH*);
// break;
} // EOF switch( (&(params->rgvarg[iArg-i]))->n1.n2.vt )
} // EOF if( (&(params->rgvarg[iArg-i]))->n1.n2.vt & VT_BYREF == VT_BYREF )
} // EOF for( i=iArg; i > 0; i-- )
hb_vmRequestRestore();
} // EOF if ( pExec )
} // EOF If Scan
hb_itemRelease( Key );
return S_OK;
} // EOF invoke
//------------------------------------------------------------------------------
// Here's IEventHandler's VTable. It never changes so we can declare it static
static const IEventHandlerVtbl IEventHandler_Vtbl = {
QueryInterface,
AddRef,
Release,
GetTypeInfoCount,
GetTypeInfo,
GetIDsOfNames,
Invoke
};
//------------------------------------------------------------------------------
// constructor
// params:
// device_interface - refers to the interface type of the COM object (whose event we are trying to receive).
// device_event_interface - indicates the interface type of the outgoing interface supported by the COM object.
// This will be the interface that must be implemented by the Sink object.
// is essentially derived from IDispatch, our Sink object (self IEventHandler)
// is also derived from IDispatch.
typedef IEventHandler device_interface;
// Hash // SetupConnectionPoint( oOle:hObj, @hSink, hEvents ) -> nError
// Array // SetupConnectionPoint( oOle:hObj, @hSink, aEvents, aExecEvent ) -> nError
HB_FUNC( SETUPCONNECTIONPOINT )
{
IConnectionPointContainer* pIConnectionPointContainerTemp = NULL;
IUnknown* pIUnknown = NULL;
IConnectionPoint* m_pIConnectionPoint;
IEnumConnectionPoints* m_pIEnumConnectionPoints;
HRESULT hr; //,r;
IID rriid;
register IEventHandler * selfobj;
DWORD dwCookie = 0;
device_interface* pdevice_interface = (device_interface*) HB_PARNL( 1 );
MyRealIEventHandler* pThis;
// Allocate our IEventHandler object (actually a MyRealIEventHandler)
// intentional misrepresentation of size
selfobj = ( IEventHandler *) GlobalAlloc( GMEM_FIXED, sizeof( MyRealIEventHandler ) );
if ( ! selfobj )
{
hr = E_OUTOFMEMORY;
}
else
{
// Store IEventHandler's VTable in the object
selfobj->lpVtbl = (IEventHandlerVtbl *) &IEventHandler_Vtbl;
// Increment the reference count so we can call Release() below and
// it will deallocate only if there is an error with QueryInterface()
((MyRealIEventHandler *) selfobj)->count = 0;
//((MyRealIEventHandler *) selfobj)->device_event_interface_iid = &riid;
((MyRealIEventHandler *) selfobj)->device_event_interface_iid = IID_IDispatch;
// Query self object itself for its IUnknown pointer which will be used
// later to connect to the Connection Point of the device_interface object.
hr = selfobj->lpVtbl->QueryInterface( selfobj, &IID_IUnknown, (void**) (void *) &pIUnknown );
if ( hr == S_OK && pIUnknown )
{
// Query the pdevice_interface for its connection point.
hr = pdevice_interface->lpVtbl->QueryInterface( pdevice_interface,
&IID_IConnectionPointContainer, (void**) (void *) &pIConnectionPointContainerTemp );
if ( hr == S_OK && pIConnectionPointContainerTemp )
{
// start uncomment
hr = pIConnectionPointContainerTemp->lpVtbl->EnumConnectionPoints( pIConnectionPointContainerTemp, &m_pIEnumConnectionPoints );
if ( hr == S_OK && m_pIEnumConnectionPoints )
{
do
{
hr = m_pIEnumConnectionPoints->lpVtbl->Next( m_pIEnumConnectionPoints, 1, &m_pIConnectionPoint , NULL);
if( hr == S_OK )
{
if ( m_pIConnectionPoint->lpVtbl->GetConnectionInterface( m_pIConnectionPoint, &rriid ) == S_OK )
{
break;
}
}
} while( hr == S_OK );
m_pIEnumConnectionPoints->lpVtbl->Release(m_pIEnumConnectionPoints);
}
// end uncomment
//hr = pIConnectionPointContainerTemp ->lpVtbl->FindConnectionPoint(pIConnectionPointContainerTemp , &IID_IDispatch, &m_pIConnectionPoint);
pIConnectionPointContainerTemp->lpVtbl->Release( pIConnectionPointContainerTemp );
pIConnectionPointContainerTemp = NULL;
}
if ( hr == S_OK && m_pIConnectionPoint )
{
//OutputDebugString("getting iid");
//Returns the IID of the outgoing interface managed by self connection point.
//hr = m_pIConnectionPoint->lpVtbl->GetConnectionInterface(m_pIConnectionPoint, &rriid );
//OutputDebugString("called");
if( hr == S_OK )
{
((MyRealIEventHandler *) selfobj)->device_event_interface_iid = rriid;
}
else
OutputDebugString("error getting iid");
//OutputDebugString("calling advise");
hr = m_pIConnectionPoint->lpVtbl->Advise( m_pIConnectionPoint, pIUnknown, &dwCookie );
((MyRealIEventHandler *) selfobj)->pIConnectionPoint = m_pIConnectionPoint;
((MyRealIEventHandler *) selfobj)->dwEventCookie = dwCookie;
}
pIUnknown->lpVtbl->Release(pIUnknown);
pIUnknown = NULL;
}
}
if( selfobj )
{
pThis = (MyRealIEventHandler *) selfobj;
#ifndef __USEHASHEVENTS
pThis->pEventsExec = hb_itemNew( hb_param( 4, HB_IT_ANY ) );
#endif
pThis->pEvents = hb_itemNew( hb_param( 3, HB_IT_ANY ) );
HB_STORNL2( (LONG_PTR) pThis, 2 );
}
HWNDret( hr );
}
//------------------------------------------------------------------------------
HB_FUNC( SHUTDOWNCONNECTIONPOINT )
{
MyRealIEventHandler *self = ( MyRealIEventHandler * ) HB_PARNL( 1 );
if( self->pIConnectionPoint )
{
self->pIConnectionPoint->lpVtbl->Unadvise( self->pIConnectionPoint, self->dwEventCookie );
self->dwEventCookie = 0;
self->pIConnectionPoint->lpVtbl->Release( self->pIConnectionPoint );
self->pIConnectionPoint = NULL;
}
}
//------------------------------------------------------------------------------
HB_FUNC( RELEASEDISPATCH )
{
IDispatch * pObj;
pObj = ( IDispatch * ) HWNDparam( 1 );
pObj->lpVtbl->Release( pObj );
}
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 );
}
/*
* Retrieve information about the current table/driver.
*/
static HB_ERRCODE hb_delimInfo( DELIMAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_delimInfo(%p,%hu,%p)", pArea, uiIndex, pItem ) );
switch( uiIndex )
{
case DBI_CANPUTREC:
hb_itemPutL( pItem, pArea->fTransRec );
break;
case DBI_GETRECSIZE:
hb_itemPutNL( pItem, pArea->uiRecordLen );
break;
case DBI_GETDELIMITER:
{
char szDelim[ 2 ];
szDelim[ 0 ] = pArea->cDelim;
szDelim[ 1 ] = '\0';
hb_itemPutC( pItem, szDelim );
break;
}
case DBI_SETDELIMITER:
if( hb_itemType( pItem ) & HB_IT_STRING )
{
const char * szDelim = hb_itemGetCPtr( pItem );
if( hb_stricmp( szDelim, "BLANK" ) == 0 )
{
pArea->cDelim = '\0';
pArea->cSeparator = ' ';
}
#ifndef HB_CLP_STRICT
else if( hb_stricmp( szDelim, "PIPE" ) == 0 )
{
pArea->cDelim = '\0';
pArea->cSeparator = '|';
}
else if( hb_stricmp( szDelim, "TAB" ) == 0 )
{
pArea->cDelim = '\0';
pArea->cSeparator = '\t';
}
else
#else
else if( *szDelim )
#endif
{
pArea->cDelim = *szDelim;
}
}
/*
* a small trick which allow to set character field delimiter and
* field separator in COPY TO ... and APPEND FROM ... commands as
* array. F.e.:
* COPY TO test DELIMITED WITH ({"","|"})
*/
#ifndef HB_CLP_STRICT
else if( hb_itemType( pItem ) & HB_IT_ARRAY )
{
char cSeparator;
if( hb_arrayGetType( pItem, 1 ) & HB_IT_STRING )
pArea->cDelim = *hb_arrayGetCPtr( pItem, 1 );
cSeparator = *hb_arrayGetCPtr( pItem, 2 );
if( cSeparator )
pArea->cSeparator = cSeparator;
}
#endif
break;
case DBI_SEPARATOR:
{
char szSeparator[ 2 ];
const char * szNew = hb_itemGetCPtr( pItem );
szSeparator[ 0 ] = pArea->cSeparator;
szSeparator[ 1 ] = '\0';
if( *szNew )
pArea->cSeparator = *szNew;
hb_itemPutC( pItem, szSeparator );
break;
}
case DBI_FULLPATH:
hb_itemPutC( pItem, pArea->szFileName);
break;
case DBI_FILEHANDLE:
hb_itemPutNInt( pItem, ( HB_NHANDLE ) hb_fileHandle( pArea->pFile ) );
break;
case DBI_SHARED:
hb_itemPutL( pItem, pArea->fShared );
break;
case DBI_ISREADONLY:
hb_itemPutL( pItem, pArea->fReadonly );
break;
case DBI_POSITIONED:
hb_itemPutL( pItem, pArea->fPositioned );
break;
case DBI_DB_VERSION:
case DBI_RDD_VERSION:
{
char szBuf[ 64 ];
int iSub = hb_itemGetNI( pItem );
if( iSub == 1 )
hb_snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s)", 0, 1, "DELIM" );
else if( iSub == 2 )
hb_snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s:%d)", 0, 1, "DELIM", pArea->area.rddID );
else
hb_snprintf( szBuf, sizeof( szBuf ), "%d.%d", 0, 1 );
hb_itemPutC( pItem, szBuf );
break;
}
default:
return SUPER_INFO( &pArea->area, uiIndex, pItem );
}
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 sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem )
{
HB_ULONG ulConn;
SQLDDCONNECTION * pConn;
HB_SYMBOL_UNUSED( pRDD );
ulConn = ulConnect ? ulConnect : s_ulConnectionCurrent;
if( ulConn > 0 && ulConn <= s_ulConnectionCount )
pConn = s_pConnection[ ulConn - 1 ];
else
pConn = NULL;
switch( uiIndex )
{
case RDDI_REMOTE:
hb_itemPutL( pItem, HB_TRUE );
break;
case RDDI_CONNECTION:
{
HB_ULONG ulNewConnection = 0;
if( hb_itemType( pItem ) & HB_IT_NUMERIC )
ulNewConnection = hb_itemGetNL( pItem );
hb_itemPutNL( pItem, ulConnect ? ulConnect : s_ulConnectionCurrent );
if( ulNewConnection )
s_ulConnectionCurrent = ulNewConnection;
break;
}
case RDDI_ISDBF:
hb_itemPutL( pItem, HB_FALSE );
break;
case RDDI_CANPUTREC:
hb_itemPutL( pItem, HB_TRUE );
break;
case RDDI_CONNECT:
{
PSDDNODE pNode = NULL;
HB_ULONG ul;
const char * pStr;
pStr = hb_arrayGetCPtr( pItem, 1 );
if( pStr )
{
pNode = s_pSdd;
while( pNode )
{
if( ! hb_stricmp( pNode->Name, pStr ) )
break;
pNode = pNode->pNext;
}
}
hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );
pConn = ( SQLDDCONNECTION * ) hb_xgrab( sizeof( SQLDDCONNECTION ) );
memset( pConn, 0, sizeof( SQLDDCONNECTION ) );
if( pNode && pNode->Connect( pConn, pItem ) == HB_SUCCESS )
{
pConn->pSDD = pNode;
/* Find free connection handle */
for( ul = 0; ul < s_ulConnectionCount; ul++ )
{
if( ! s_pConnection[ ul ] )
break;
}
if( ul >= s_ulConnectionCount )
{
/* Realloc connection table */
if( s_pConnection )
s_pConnection = ( SQLDDCONNECTION ** ) hb_xrealloc( s_pConnection, sizeof( SQLDDCONNECTION * ) * ( s_ulConnectionCount + CONNECTION_LIST_EXPAND ) );
else
s_pConnection = ( SQLDDCONNECTION ** ) hb_xgrab( sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND );
memset( s_pConnection + s_ulConnectionCount, 0, sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND );
ul = s_ulConnectionCount;
s_ulConnectionCount += CONNECTION_LIST_EXPAND;
}
s_pConnection[ ul ] = pConn;
ul++;
s_ulConnectionCurrent = ul;
}
else
{
hb_xfree( pConn );
ul = 0;
}
hb_itemPutNI( pItem, ul );
break;
}
case RDDI_DISCONNECT:
hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );
if( pConn && ! pConn->uiAreaCount && pConn->pSDD->Disconnect( pConn ) == HB_SUCCESS )
{
hb_xfree( pConn );
s_pConnection[ ulConn - 1 ] = NULL;
if( s_ulConnectionCurrent == ulConn )
s_ulConnectionCurrent = 0;
hb_itemPutL( pItem, HB_TRUE );
return HB_SUCCESS;
}
hb_itemPutL( pItem, HB_FALSE );
return HB_SUCCESS;
case RDDI_EXECUTE:
hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );
if( pConn )
hb_itemPutL( pItem, pConn->pSDD->Execute( pConn, pItem ) == HB_SUCCESS );
else
hb_itemPutL( pItem, HB_FALSE );
return HB_SUCCESS;
case RDDI_ERROR:
hb_itemPutC( pItem, s_szError );
return HB_SUCCESS;
case RDDI_ERRORNO:
hb_itemPutNI( pItem, s_errCode );
return HB_SUCCESS;
case RDDI_QUERY:
hb_itemPutC( pItem, s_szQuery );
return HB_SUCCESS;
case RDDI_NEWID:
hb_itemCopy( pItem, s_pItemNewID );
return HB_SUCCESS;
case RDDI_AFFECTEDROWS:
hb_itemPutNInt( pItem, s_ulAffectedRows );
return HB_SUCCESS;
#if 0
default:
return SUPER_RDDINFO( pRDD, uiIndex, ulConnect, pItem );
#endif
}
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 HRESULT STDMETHODCALLTYPE Invoke( IDispatch * lpThis, DISPID dispid, REFIID riid,
LCID lcid, WORD wFlags, DISPPARAMS * pParams,
VARIANT * pVarResult, EXCEPINFO * pExcepInfo,
UINT * puArgErr )
{
PHB_DYNS pDynSym;
PHB_ITEM pAction;
HB_USHORT uiClass = 0;
HB_SYMBOL_UNUSED( lcid );
HB_SYMBOL_UNUSED( pExcepInfo );
HB_SYMBOL_UNUSED( puArgErr );
if( ! IsEqualIID( riid, HB_ID_REF( IID_NULL ) ) )
return DISP_E_UNKNOWNINTERFACE;
pAction = ( ( IHbOleServer * ) lpThis )->pAction;
if( ! pAction )
pAction = s_pAction;
if( pAction )
{
HB_BOOL fResult = HB_FALSE;
if( s_pMsgHash )
{
if( ( wFlags & DISPATCH_METHOD ) != 0 ||
( ( wFlags & DISPATCH_PROPERTYGET ) != 0 && pParams->cArgs == 0 ) ||
( ( wFlags & DISPATCH_PROPERTYPUT ) != 0 && pParams->cArgs == 1 ) )
{
fResult = hb_oleDispInvoke( NULL, pAction,
hb_hashGetKeyAt( s_pMsgHash, ( HB_SIZE ) dispid ),
pParams, pVarResult, s_objItemToVariant, uiClass );
}
}
else if( HB_IS_HASH( pAction ) )
{
PHB_ITEM pItem;
if( ( ( IHbOleServer * ) lpThis )->fGuids )
{
PHB_ITEM pKey = hb_itemPutNL( hb_stackAllocItem(), ( long ) dispid );
pItem = hb_hashGetItemPtr( pAction, pKey, 0 );
hb_stackPop();
}
else
pItem = hb_hashGetValueAt( pAction, ( HB_SIZE ) dispid );
if( pItem )
{
if( HB_IS_EVALITEM( pItem ) )
{
if( ( wFlags & DISPATCH_METHOD ) != 0 )
{
PHB_SYMB pSym = hb_itemGetSymbol( pItem );
fResult = hb_oleDispInvoke( pSym, pSym ? pAction : pItem, NULL,
pParams, pVarResult,
s_objItemToVariant, uiClass );
}
}
else if( ( wFlags & DISPATCH_PROPERTYGET ) != 0 &&
pParams->cArgs == 0 )
{
if( pVarResult )
hb_oleItemToVariantEx( pVarResult, pItem, s_objItemToVariant );
fResult = HB_TRUE;
}
else if( ( wFlags & DISPATCH_PROPERTYPUT ) != 0 &&
pParams->cArgs == 1 )
{
hb_oleVariantToItemEx( pItem, &pParams->rgvarg[ 0 ], uiClass );
fResult = HB_TRUE;
}
}
}
else if( HB_IS_OBJECT( pAction ) )
{
pDynSym = hb_dispIdToDynsym( dispid );
if( pDynSym && ( wFlags & DISPATCH_PROPERTYPUT ) != 0 )
{
if( pParams->cArgs == 1 )
{
char szName[ HB_SYMBOL_NAME_LEN + 1 ];
szName[ 0 ] = '_';
hb_strncpy( szName + 1, hb_dynsymName( pDynSym ), sizeof( szName ) - 2 );
pDynSym = hb_dynsymFindName( szName );
}
else
pDynSym = NULL;
}
if( pDynSym && hb_objHasMessage( pAction, pDynSym ) )
{
fResult = hb_oleDispInvoke( hb_dynsymSymbol( pDynSym ),
pAction, NULL, pParams, pVarResult,
s_objItemToVariant, uiClass );
}
}
if( ! fResult )
return DISP_E_MEMBERNOTFOUND;
}
else
{
pDynSym = hb_dispIdToDynsym( dispid );
if( ! pDynSym )
return DISP_E_MEMBERNOTFOUND;
if( wFlags & DISPATCH_PROPERTYPUT )
{
if( pParams->cArgs == 1 && hb_dynsymIsMemvar( pDynSym ) )
{
PHB_ITEM pItem = hb_stackAllocItem();
hb_oleVariantToItemEx( pItem, &pParams->rgvarg[ 0 ], uiClass );
hb_memvarSetValue( hb_dynsymSymbol( pDynSym ), pItem );
hb_stackPop();
return S_OK;
}
else
return DISP_E_MEMBERNOTFOUND;
}
else if( ( wFlags & DISPATCH_PROPERTYGET ) &&
pParams->cArgs == 0 && hb_dynsymIsMemvar( pDynSym ) )
{
if( pVarResult )
{
PHB_ITEM pItem = hb_stackAllocItem();
hb_memvarGet( pItem, hb_dynsymSymbol( pDynSym ) );
hb_oleItemToVariantEx( pVarResult, pItem, s_objItemToVariant );
hb_stackPop();
}
return S_OK;
}
else if( ( wFlags & DISPATCH_METHOD ) == 0 ||
! hb_dynsymIsFunction( pDynSym ) )
return DISP_E_MEMBERNOTFOUND;
else if( ! hb_oleDispInvoke( hb_dynsymSymbol( pDynSym ),
NULL, NULL, pParams, pVarResult,
s_objItemToVariant, uiClass ) )
return DISP_E_MEMBERNOTFOUND;
}
return S_OK;
}
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;
}
