a6aa848aaa
* contrib/xhb/fparse.c
* contrib/rddsql/sddmy/mysqldd.c
* contrib/rddsql/sqlbase.c
* contrib/rddsql/sqlmix.c
* contrib/rddads/adsx.c
* contrib/examples/terminal/trm_client.prg
* source/rdd/dbfnsx/dbfnsx1.c
% "" -> NULL where applicable (hb_retc*(), hb_retds(), hb_itemPutC*(),
hb_arraySetC*(), hb_errInternal(), hb_itemPutDS(), hb_arraySetDS())
* contrib/hbqt/hbqt_qtextdocument.cpp
* contrib/hbqt/hbqt_qgridlayout.cpp
* contrib/hbqt/hbqt_qpainter.cpp
* contrib/hbqt/hbqt_qeventloop.cpp
* contrib/hbqt/hbqt_qicon.cpp
* contrib/hbqt/hbqt_qtreeview.cpp
* contrib/hbqt/hbqt_qtextline.cpp
* contrib/hbqt/hbqt_qdesktopwidget.cpp
* contrib/hbqt/hbqt_qhttp.cpp
* contrib/hbqt/hbqt_qlineedit.cpp
* contrib/hbqt/hbqt_qcombobox.cpp
* contrib/hbqt/hbqt_qlistwidget.cpp
* contrib/hbqt/hbqt_qtextcursor.cpp
* contrib/hbqt/hbqt_qtextlayout.cpp
* contrib/hbqt/hbqt_qftp.cpp
* contrib/hbqt/hbqt_qclipboard.cpp
* contrib/hbqt/hbqt_qurl.cpp
* contrib/hbqt/hbqt_qwebpage.cpp
* contrib/hbqt/hbqt_qtextedit.cpp
* contrib/hbqt/hbqt_qpixmap.cpp
* contrib/hbqt/hbqt_qsplashscreen.cpp
* contrib/hbqt/hbqt_qtablewidget.cpp
* contrib/hbqt/hbqt_qtreewidget.cpp
* contrib/hbqt/generator/hbqtgen.prg
* contrib/hbqt/hbqt_qfont.cpp
* contrib/hbqt/hbqt_qmainwindow.cpp
* contrib/hbqt/hbqt_qdir.cpp
* contrib/hbqt/hbqt_qwidget.cpp
* contrib/hbqt/hbqt_qstyle.cpp
* contrib/hbqt/hbqt_qabstractbutton.cpp
* contrib/hbqt/hbqt_qobject.cpp
* contrib/hbqt/hbqt_qcolor.cpp
* contrib/hbqt/hbqt_qtextstream.cpp
* contrib/hbqt/hbqt_qwebview.cpp
* contrib/hbqt/hbqt_qboxlayout.cpp
* contrib/hbqt/hbqt_qstatusbar.cpp
* contrib/hbqt/hbqt_qtabwidget.cpp
* contrib/hbqt/hbqt_qscrollarea.cpp
* contrib/hbqt/hbqt_qtextcharformat.cpp
! Fixed to use HB_ISNUM() instead of HB_ISNIL().
% Don't call HB_ISNUM() where the default value is
zero anyway. hb_parn*() functions will return zero
anyway. (well, maybe this exploits the array-type
bug in our Extend API.)
* contrib/gtwvg/wvgwin.c
* contrib/gtwvg/wvgsink.c
* Avoiding ISNIL(). Corrected just a few occurences.
This practice is still wrong in most of the cases in
GTWVG code, so if the goal is GPF-free and consitently
behaving apps, these would better be fixed. With
string params ISNIL() is either superfluous or simply
don't protect agains GPFs, for rest of the cases it
either causes unexpected defaults (zero), or simply
superfluous for the rest of the cases. IOW: Avoid it,
use HB_ISNUM(), HB_ISCHAR() / parcx() instead.
* contrib/hbgd/gdwrp.c
* Formatting.
2336 lines
64 KiB
C
2336 lines
64 KiB
C
/*
|
|
* $Id$
|
|
*/
|
|
|
|
/*
|
|
* SQL MIX (Memory Index) Database Driver
|
|
*
|
|
* Copyright 2007 Mindaugas Kavaliauskas <dbtopas at dbtopas.lt>
|
|
* www - http://www.harbour-project.org
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this software; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
|
|
* Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
|
|
*
|
|
* As a special exception, the Harbour Project gives permission for
|
|
* additional uses of the text contained in its release of Harbour.
|
|
*
|
|
* The exception is that, if you link the Harbour libraries with other
|
|
* files to produce an executable, this does not by itself cause the
|
|
* resulting executable to be covered by the GNU General Public License.
|
|
* Your use of that executable is in no way restricted on account of
|
|
* linking the Harbour library code into it.
|
|
*
|
|
* This exception does not however invalidate any other reasons why
|
|
* the executable file might be covered by the GNU General Public License.
|
|
*
|
|
* This exception applies only to the code released by the Harbour
|
|
* Project under the name Harbour. If you copy code from other
|
|
* Harbour Project or Free Software Foundation releases into a copy of
|
|
* Harbour, as the General Public License permits, the exception does
|
|
* not apply to the code that you add in this way. To avoid misleading
|
|
* anyone as to the status of such modified files, you must delete
|
|
* this exception notice from them.
|
|
*
|
|
* If you write modifications of your own for Harbour, it is your choice
|
|
* whether to permit this exception to apply to your modifications.
|
|
* If you do not wish that, delete this exception notice.
|
|
*
|
|
*/
|
|
|
|
#include "hbapi.h"
|
|
#include "hbinit.h"
|
|
#include "hbapiitm.h"
|
|
#include "hbapirdd.h"
|
|
#include "hbapierr.h"
|
|
#include "hbdbferr.h"
|
|
#include "hbapilng.h"
|
|
#include "hbdate.h"
|
|
#include "hbset.h"
|
|
#include "hbvm.h"
|
|
#include "rddsys.ch"
|
|
|
|
#include "hbrddsql.h"
|
|
|
|
#define SUPERTABLE ( &sqlmixSuper )
|
|
|
|
|
|
|
|
#define MIX_KEY( tag, node, index ) \
|
|
( (PMIXKEY) & ( (BYTE*) (node) ) [ ( (node)->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + (index) * (tag)->uiTotalLen ] )
|
|
|
|
#define MIX_COPY_KEYS_INTERNAL( tag, node, dst, src, count ) \
|
|
memmove( ( (BYTE*) (node) ) + ( (node)->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + (dst) * (tag)->uiTotalLen, \
|
|
( (BYTE*) (node) ) + ( (node)->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + (src) * (tag)->uiTotalLen, \
|
|
(count) * (tag)->uiTotalLen )
|
|
|
|
#define MIX_COPY_KEYS_EXTERNAL( tag, ndst, dst, nsrc, src, count ) \
|
|
memmove( ( (BYTE*) (ndst) ) + ( (ndst)->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + (dst) * (tag)->uiTotalLen, \
|
|
( (BYTE*) (nsrc) ) + ( (nsrc)->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + (src) * (tag)->uiTotalLen, \
|
|
(count) * (tag)->uiTotalLen )
|
|
|
|
#define MIX_ASSIGN_KEY( tag, node, dst, src ) \
|
|
memmove( ( (BYTE*) (node) ) + ( (node)->Leaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + (dst) * (tag)->uiTotalLen, \
|
|
(src), (tag)->uiTotalLen )
|
|
|
|
#define MIX_COPY_CHILDS_INTERNAL( tag, node, dst, src, count ) \
|
|
memmove( & ((node)->Child[ (dst) ]), & ((node)->Child[ (src) ]), (count) * sizeof( void* ) )
|
|
|
|
#define MIX_COPY_CHILDS_EXTERNAL( tag, ndst, dst, nsrc, src, count ) \
|
|
memmove( & ((ndst)->Child[ (dst) ]), & ((nsrc)->Child[ (src) ]), (count) * sizeof( void* ) )
|
|
|
|
|
|
|
|
static USHORT s_uiRddIdSQLMIX = ( USHORT ) -1;
|
|
|
|
static RDDFUNCS sqlmixSuper;
|
|
|
|
|
|
/*
|
|
=======================================================================
|
|
Misc functions
|
|
=======================================================================
|
|
*/
|
|
|
|
|
|
static HB_ERRCODE sqlmixErrorRT( SQLMIXAREAP pArea, USHORT uiGenCode, USHORT uiSubCode, char* filename, USHORT uiOsCode, USHORT uiFlags )
|
|
{
|
|
PHB_ITEM pError;
|
|
HB_ERRCODE iRet = HB_FAILURE;
|
|
|
|
if ( hb_vmRequestQuery() == 0 )
|
|
{
|
|
pError = hb_errNew();
|
|
hb_errPutGenCode( pError, uiGenCode );
|
|
hb_errPutSubCode( pError, uiSubCode );
|
|
hb_errPutOsCode( pError, uiOsCode );
|
|
hb_errPutDescription( pError, hb_langDGetErrorDesc( uiGenCode ) );
|
|
if ( filename )
|
|
hb_errPutFileName( pError, filename );
|
|
if ( uiFlags )
|
|
hb_errPutFlags( pError, uiFlags );
|
|
iRet = SELF_ERROR( (AREAP) pArea, pError );
|
|
hb_errRelease( pError );
|
|
}
|
|
return iRet;
|
|
}
|
|
|
|
|
|
/*
|
|
=======================================================================
|
|
Memory Index
|
|
=======================================================================
|
|
*/
|
|
|
|
/* -------------------------- Key management ---------------------------- */
|
|
/* hb_mixKey*() */
|
|
|
|
static PMIXKEY hb_mixKeyNew( PMIXTAG pTag )
|
|
{
|
|
return (PMIXKEY) hb_xgrab( pTag->uiTotalLen );
|
|
}
|
|
|
|
|
|
static PMIXKEY hb_mixKeyPutItem( PMIXKEY pKey, PHB_ITEM pItem, ULONG ulRecNo, PMIXTAG pTag )
|
|
{
|
|
ULONG ul;
|
|
double dbl;
|
|
BYTE buf[ 8 ];
|
|
|
|
if ( ! pKey )
|
|
pKey = hb_mixKeyNew( pTag );
|
|
|
|
pKey->rec = ulRecNo;
|
|
pKey->notnul = 1;
|
|
|
|
/* TODO: check valtype */
|
|
switch ( pTag->bType )
|
|
{
|
|
case 'C':
|
|
ul = hb_itemGetCLen( pItem );
|
|
|
|
if ( ul > (ULONG) pTag->uiKeyLen )
|
|
ul = pTag->uiKeyLen;
|
|
|
|
memcpy( pKey->val, hb_itemGetCPtr( pItem ), ul );
|
|
|
|
if ( ul < (ULONG) pTag->uiKeyLen )
|
|
memset( pKey->val + ul, ' ', (ULONG) pTag->uiKeyLen - ul );
|
|
|
|
break;
|
|
|
|
case 'N':
|
|
dbl = hb_itemGetND( pItem );
|
|
HB_DBL2ORD( &dbl, buf );
|
|
memcpy( pKey->val, buf, 8 );
|
|
break;
|
|
|
|
case 'D':
|
|
dbl = (double) hb_itemGetDL( pItem );
|
|
HB_DBL2ORD( &dbl, buf );
|
|
memcpy( pKey->val, buf, 8 );
|
|
break;
|
|
|
|
case 'L':
|
|
pKey->val[ 0 ] = (BYTE) (hb_itemGetL( pItem ) ? 'T' : 'F');
|
|
break;
|
|
|
|
default:
|
|
pKey->notnul = 0;
|
|
memset( pKey->val, ' ', pTag->uiKeyLen );
|
|
}
|
|
return pKey;
|
|
}
|
|
|
|
|
|
static PMIXKEY hb_mixKeyEval( PMIXKEY pKey, PMIXTAG pTag )
|
|
{
|
|
PHB_ITEM pItem;
|
|
SQLMIXAREAP pArea = pTag->pArea;
|
|
int iCurrArea = hb_rddGetCurrentWorkAreaNumber();
|
|
PHB_CODEPAGE pCodepage = hb_cdpSelect( pArea->cdPage );
|
|
|
|
if ( iCurrArea != pArea->uiArea )
|
|
hb_rddSelectWorkAreaNumber( pArea->uiArea );
|
|
else
|
|
iCurrArea = 0;
|
|
|
|
pItem = hb_vmEvalBlockOrMacro( pTag->pKeyItem );
|
|
|
|
pKey = hb_mixKeyPutItem( pKey, pItem, pArea->ulRecNo, pTag );
|
|
|
|
if ( iCurrArea )
|
|
hb_rddSelectWorkAreaNumber( iCurrArea );
|
|
|
|
hb_cdpSelect( pCodepage );
|
|
|
|
return pKey;
|
|
}
|
|
|
|
|
|
static BOOL hb_mixEvalCond( SQLMIXAREAP pArea, PHB_ITEM pCondItem )
|
|
{
|
|
int iCurrArea = 0;
|
|
BOOL fRet;
|
|
|
|
if ( pArea )
|
|
{
|
|
iCurrArea = hb_rddGetCurrentWorkAreaNumber();
|
|
|
|
if ( iCurrArea != pArea->uiArea )
|
|
hb_rddSelectWorkAreaNumber( pArea->uiArea );
|
|
else
|
|
iCurrArea = 0;
|
|
}
|
|
|
|
fRet = hb_itemGetL( hb_vmEvalBlockOrMacro( pCondItem ) );
|
|
|
|
if ( iCurrArea )
|
|
hb_rddSelectWorkAreaNumber( iCurrArea );
|
|
|
|
return fRet;
|
|
}
|
|
|
|
|
|
static void hb_mixKeyFree( PMIXKEY pKey )
|
|
{
|
|
hb_xfree( pKey );
|
|
}
|
|
|
|
|
|
#if 0
|
|
/* This function is unused */
|
|
static int hb_mixKeyCompareValue( PMIXTAG pTag, PMIXKEY pKey1, PMIXKEY pKey2, UINT uiLen )
|
|
{
|
|
BYTE* pSortTable = pTag->pSortTable;
|
|
UINT ui, uiSize;
|
|
int i;
|
|
|
|
if ( ! pKey1->notnul || ! pKey2->notnul )
|
|
{
|
|
return (int) pKey1->notnul - (int) pKey2->notnul;
|
|
}
|
|
|
|
i = 0;
|
|
uiSize = pTag->uiKeyLen > uiLen ? uiLen : pTag->uiKeyLen;
|
|
|
|
if ( pSortTable )
|
|
{
|
|
ui = 0;
|
|
while ( i == 0 && ui < uiSize )
|
|
{
|
|
i = pSortTable[ pKey1->val[ ui ] ] - pSortTable[ pKey2->val[ ui ] ];
|
|
ui++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( uiSize > 0 )
|
|
i = memcmp( pKey1->val, pKey2->val, uiSize );
|
|
}
|
|
|
|
if ( i == 0 )
|
|
{
|
|
/* This condition seems inverted, but it's ok for seek last */
|
|
if ( pTag->uiKeyLen > uiLen )
|
|
i = -1;
|
|
}
|
|
return i;
|
|
}
|
|
#endif
|
|
|
|
|
|
static int hb_mixKeyCompare( PMIXTAG pTag, PMIXKEY pKey1, PMIXKEY pKey2, UINT uiLen )
|
|
{
|
|
BYTE* pSortTable = pTag->pSortTable;
|
|
UINT ui, uiSize;
|
|
int i;
|
|
|
|
|
|
if ( ! pKey1->notnul || ! pKey2->notnul )
|
|
{
|
|
return (int) pKey1->notnul - (int) pKey2->notnul;
|
|
}
|
|
|
|
i = 0;
|
|
uiSize = pTag->uiKeyLen > uiLen ? uiLen : pTag->uiKeyLen;
|
|
|
|
if ( pSortTable )
|
|
{
|
|
ui = 0;
|
|
while ( i == 0 && ui < uiSize )
|
|
{
|
|
i = pSortTable[ pKey1->val[ ui ] ] - pSortTable[ pKey2->val[ ui ] ];
|
|
ui++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( uiSize > 0 )
|
|
i = memcmp( pKey1->val, pKey2->val, uiSize );
|
|
}
|
|
|
|
if ( i == 0 )
|
|
{
|
|
if ( pKey2->rec == (ULONG) -1 )
|
|
{
|
|
/* This condition seems inverted, but it's ok for seek last */
|
|
if ( pTag->uiKeyLen > uiLen )
|
|
i = -1;
|
|
}
|
|
else
|
|
{
|
|
if ( pTag->uiKeyLen > uiLen )
|
|
i = 1;
|
|
else if ( pTag->uiKeyLen < uiLen )
|
|
i = -1;
|
|
}
|
|
}
|
|
|
|
|
|
if ( i != 0 )
|
|
{
|
|
if ( i < 0 )
|
|
{
|
|
return -2;
|
|
}
|
|
return 2;
|
|
}
|
|
|
|
if ( pKey1->rec < pKey2->rec )
|
|
{
|
|
return -1;
|
|
}
|
|
else if ( pKey1->rec > pKey2->rec )
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* -------------------------- Tag management ---------------------------- */
|
|
/* hb_mixTag*() */
|
|
|
|
/* This function is used for debugging purposes. Uncomment it, if you need it.
|
|
static void hb_mixTagPrintNode( PMIXTAG pTag, PMIXNODE pNode, int iLevel )
|
|
{
|
|
UINT i;
|
|
|
|
if ( !pNode )
|
|
return;
|
|
|
|
if ( pNode->KeyCount < MIX_NODE_ORDER / 2 && pNode->Parent )
|
|
{
|
|
printf("!!! Too few keys\n");
|
|
}
|
|
|
|
for ( i = 0; i < pNode->KeyCount; i++ )
|
|
{
|
|
if ( ! pNode->Leaf )
|
|
{
|
|
if ( pNode->Child[ i ]->Parent != pNode )
|
|
printf("!!! Invalid parent\n");
|
|
|
|
hb_mixTagPrintNode( pTag, pNode->Child[ i ], iLevel + 1 );
|
|
}
|
|
printf("%*ld %*s\n", iLevel * 10 + 5, MIX_KEY( pTag, pNode, i )->rec, pTag->uiKeyLen,
|
|
MIX_KEY( pTag, pNode, i )->notnul ? ( char * ) MIX_KEY( pTag, pNode, i )->val : "NULL" );
|
|
}
|
|
|
|
if ( ! pNode->Leaf )
|
|
{
|
|
if ( pNode->Child[ pNode->KeyCount ]->Parent != pNode )
|
|
printf("!!! Invalid parent\n");
|
|
|
|
hb_mixTagPrintNode( pTag, pNode->Child[ pNode->KeyCount ], iLevel + 1 );
|
|
}
|
|
}
|
|
*/
|
|
|
|
static PMIXNODE hb_mixTagCreateNode( PMIXTAG pTag, BOOL fLeaf )
|
|
{
|
|
PMIXNODE pNode;
|
|
ULONG ulSize;
|
|
|
|
ulSize = ( fLeaf ? sizeof( MIXNODELEAF ) : sizeof( MIXNODE ) ) + MIX_NODE_ORDER * pTag->uiTotalLen;
|
|
|
|
pNode = (PMIXNODE) hb_xgrab( ulSize );
|
|
memset( pNode, 0, ulSize );
|
|
pNode->Leaf = fLeaf ? 1 : 0;
|
|
return pNode;
|
|
}
|
|
|
|
|
|
static UINT hb_mixTagNodeParentIndex( PMIXNODE pNode )
|
|
{
|
|
PMIXNODE pParent = pNode->Parent;
|
|
UINT ui;
|
|
|
|
/* Find position in the parent node */
|
|
ui = pParent->KeyCount;
|
|
do {
|
|
if ( pParent->Child[ ui ] == pNode )
|
|
return ui;
|
|
} while ( ui-- );
|
|
|
|
return (UINT) -1;
|
|
}
|
|
|
|
|
|
static int hb_mixTagFindKey( PMIXTAG pTag, PMIXKEY pKey, UINT uiLen, PMIXNODE* ppNode, UINT* puiPos, BOOL fValidKey )
|
|
{
|
|
PMIXNODE pNode;
|
|
UINT ui;
|
|
int i;
|
|
|
|
pNode = pTag->Root;
|
|
|
|
while ( 1 )
|
|
{
|
|
i = -2;
|
|
|
|
/* TODO: binary search */
|
|
for ( ui = 0; ui < pNode->KeyCount; ui++ )
|
|
{
|
|
i = hb_mixKeyCompare( pTag, MIX_KEY( pTag, pNode, ui ), pKey, uiLen );
|
|
|
|
if ( i >= 0 )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( i == 0 || pNode->Leaf )
|
|
break;
|
|
else
|
|
pNode = pNode->Child[ ui ];
|
|
}
|
|
|
|
if ( fValidKey && ui >= pNode->KeyCount )
|
|
{
|
|
/* unsuccessful find always finds position in leaf */
|
|
|
|
while ( pNode->Parent && pNode->Parent->Child[ pNode->Parent->KeyCount ] == pNode )
|
|
pNode = pNode->Parent;
|
|
|
|
if ( pNode->Parent )
|
|
{
|
|
for ( ui = 0; ui < pNode->Parent->KeyCount; ui++ )
|
|
{
|
|
if ( pNode->Parent->Child[ ui ] == pNode )
|
|
{
|
|
pNode = pNode->Parent;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ui = pNode->KeyCount + 1; /* EOF */
|
|
}
|
|
}
|
|
|
|
* ppNode = pNode;
|
|
* puiPos = ui;
|
|
return i;
|
|
}
|
|
|
|
|
|
static void hb_mixTagSetCurrent( PMIXTAG pTag, PMIXNODE pNode, UINT uiPos )
|
|
{
|
|
if ( uiPos < pNode->KeyCount )
|
|
{
|
|
pTag->CurNode = pNode;
|
|
pTag->CurPos = uiPos;
|
|
pTag->CurKey = MIX_KEY( pTag, pNode, uiPos );
|
|
pTag->fEof = FALSE;
|
|
}
|
|
else
|
|
{
|
|
pTag->fEof = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
static BOOL hb_mixTagRefreshKey( PMIXTAG pTag )
|
|
{
|
|
SQLMIXAREAP pArea;
|
|
|
|
pArea = pTag->pArea;
|
|
|
|
if ( pArea->lpdbPendingRel )
|
|
SELF_FORCEREL( ( AREAP ) pArea );
|
|
|
|
if ( ! pArea->fPositioned )
|
|
{
|
|
pTag->fEof = TRUE;
|
|
return FALSE;
|
|
}
|
|
else if ( pTag->fEof || pTag->CurKey->rec != pArea->ulRecNo )
|
|
{
|
|
PMIXKEY pKey;
|
|
PMIXNODE pNode;
|
|
UINT ui;
|
|
|
|
pKey = hb_mixKeyEval( NULL, pTag );
|
|
|
|
hb_mixTagFindKey( pTag, pKey, pTag->uiKeyLen, &pNode, &ui, FALSE );
|
|
hb_mixTagSetCurrent( pTag, pNode, ui );
|
|
|
|
hb_mixKeyFree( pKey );
|
|
return ! pTag->fEof && pTag->CurKey->rec == pArea->ulRecNo;
|
|
}
|
|
pTag->fBof = pTag->fEof = FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static void hb_mixTagAddKeyNode( PMIXTAG pTag, PMIXNODE pNode, UINT uiPos, PMIXKEY pKey, PMIXNODE pChildLeft, PMIXNODE pChildRight )
|
|
{
|
|
MIX_COPY_KEYS_INTERNAL( pTag, pNode, uiPos + 1, uiPos, pNode->KeyCount - uiPos );
|
|
if ( ! pNode->Leaf )
|
|
{
|
|
MIX_COPY_CHILDS_INTERNAL( pTag, pNode, uiPos + 2, uiPos + 1, pNode->KeyCount - uiPos );
|
|
pNode->Child[ uiPos ] = pChildLeft;
|
|
pNode->Child[ uiPos + 1 ] = pChildRight;
|
|
pChildLeft->Parent = pNode;
|
|
pChildRight->Parent = pNode;
|
|
}
|
|
MIX_ASSIGN_KEY( pTag, pNode, uiPos, pKey );
|
|
pNode->KeyCount++;
|
|
}
|
|
|
|
|
|
static void hb_mixTagAddKeyPos( PMIXTAG pTag, PMIXNODE pNode, UINT uiPos, PMIXKEY pKey, PMIXNODE pChildLeft, PMIXNODE pChildRight )
|
|
{
|
|
PMIXNODE pNewNode;
|
|
UINT j, k;
|
|
|
|
if ( pNode->KeyCount < MIX_NODE_ORDER )
|
|
{
|
|
hb_mixTagAddKeyNode( pTag, pNode, uiPos, pKey, pChildLeft, pChildRight );
|
|
return;
|
|
}
|
|
|
|
#ifdef USE_SIBLINGS
|
|
/* Try use siblings, if leaf node is full */
|
|
|
|
if ( pNode->Leaf && pNode->Parent )
|
|
{
|
|
j = hb_mixTagNodeParentIndex( pNode );
|
|
|
|
if ( j > 0 && pNode->Parent->Child[ j - 1 ]->KeyCount < MIX_NODE_ORDER )
|
|
{
|
|
MIX_COPY_KEYS_EXTERNAL( pTag, pNode->Parent->Child[ j - 1 ], pNode->Parent->Child[ j - 1 ]->KeyCount, pNode->Parent, j - 1, 1 );
|
|
pNode->Parent->Child[ j - 1 ]->KeyCount++;
|
|
|
|
if ( uiPos == 0 )
|
|
{
|
|
MIX_ASSIGN_KEY( pTag, pNode->Parent, j - 1, pKey );
|
|
pNode->Parent->Key[ j - 1 ] = pKey;
|
|
}
|
|
else
|
|
{
|
|
MIX_COPY_KEYS_EXTERNAL( pTag, pNode->Parent, j - 1, pNode, 0 , 1 );
|
|
uiPos--;
|
|
MIX_COPY_KEYS_INTERNAL( pTag, pNode, 0, 1, uiPos );
|
|
MIX_ASSIGN_KEY( pTag, pNode, uiPos, pKey );
|
|
}
|
|
|
|
return;
|
|
}
|
|
else if ( j < pNode->Parent->KeyCount && pNode->Parent->Child[ j + 1 ]->KeyCount < MIX_NODE_ORDER )
|
|
{
|
|
MIX_COPY_KEYS_INTERNAL( pTag, pNode->Parent->Child[ j + 1 ], 1, 0, pNode->Parent->Child[ j + 1 ]->KeyCount );
|
|
MIX_COPY_KEYS_EXTERNAL( pTag, pNode->Parent->Child[ j + 1 ], 0, pNode->Parent, j, 1 );
|
|
pNode->Parent->Child[ j + 1 ]->KeyCount++;
|
|
|
|
if ( uiPos == MIX_NODE_ORDER )
|
|
{
|
|
MIX_ASSIGN_KEY( pTag, pNode->Parent, j, pKey );
|
|
}
|
|
else
|
|
{
|
|
MIX_COPY_KEYS_EXTERNAL( pTag, pNode->Parent, j, pNode, MIX_NODE_ORDER - 1, 1 );
|
|
MIX_COPY_KEYS_INTERNAL( pTag, pNode, uiPos + 1, uiPos, MIX_NODE_ORDER - uiPos - 1 );
|
|
MIX_ASSIGN_KEY( pTag, pNode, uiPos, pKey );
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
#endif /* USE_SIBLINGS */
|
|
|
|
|
|
/* Create new node */
|
|
pNewNode = hb_mixTagCreateNode( pTag, pNode->Leaf );
|
|
|
|
/* Move half of items to new node */
|
|
k = MIX_NODE_ORDER / 2 + ( ( uiPos <= MIX_NODE_ORDER / 2 ) ? 0 : 1 );
|
|
MIX_COPY_KEYS_EXTERNAL( pTag, pNewNode, 0, pNode, k, MIX_NODE_ORDER - k );
|
|
if ( ! pNode->Leaf )
|
|
{
|
|
MIX_COPY_CHILDS_EXTERNAL( pTag, pNewNode, 1, pNode, k + 1, MIX_NODE_ORDER - k );
|
|
for ( j = 1; j <= MIX_NODE_ORDER - k; j++ )
|
|
{
|
|
pNewNode->Child[ j ]->Parent = pNewNode; // Do NOT forget to re-parent
|
|
}
|
|
}
|
|
pNode->KeyCount = k;
|
|
pNewNode->KeyCount = MIX_NODE_ORDER - k;
|
|
|
|
|
|
/* Insert new item to the left node or right node */
|
|
if ( uiPos <= MIX_NODE_ORDER / 2 )
|
|
hb_mixTagAddKeyNode( pTag, pNode, uiPos, pKey, pChildLeft, pChildRight );
|
|
else
|
|
hb_mixTagAddKeyNode( pTag, pNewNode, uiPos - MIX_NODE_ORDER / 2 - 1, pKey, pChildLeft, pChildRight );
|
|
|
|
|
|
/* Assign the leftmost child of the new node */
|
|
if ( ! pNode->Leaf )
|
|
{
|
|
pNewNode->Child[ 0 ] = pNode->Child[ pNode->KeyCount ];
|
|
pNewNode->Child[ 0 ]->Parent = pNewNode;
|
|
}
|
|
|
|
pNode->KeyCount--;
|
|
|
|
/* Move middle (last+1 in first node) item up */
|
|
if ( pNode->Parent )
|
|
{
|
|
hb_mixTagAddKeyPos( pTag, pNode->Parent, hb_mixTagNodeParentIndex( pNode ),
|
|
MIX_KEY( pTag, pNode, pNode->KeyCount ), pNode, pNewNode );
|
|
}
|
|
else
|
|
{
|
|
pTag->Root = hb_mixTagCreateNode( pTag, 0 );
|
|
hb_mixTagAddKeyNode( pTag, pTag->Root, 0, MIX_KEY( pTag, pNode, pNode->KeyCount ), pNode, pNewNode );
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static BOOL hb_mixTagAddKey( PMIXTAG pTag, PMIXKEY pKey )
|
|
{
|
|
PMIXNODE pNode;
|
|
UINT ui;
|
|
int i;
|
|
|
|
i = hb_mixTagFindKey( pTag, pKey, pTag->uiKeyLen, &pNode, &ui, FALSE );
|
|
|
|
/* Key can not be duplicated */
|
|
if ( ! i )
|
|
return FALSE;
|
|
|
|
hb_mixTagAddKeyPos( pTag, pNode, ui, pKey, NULL, NULL );
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static void hb_mixTagDelKeyNode( PMIXTAG pTag, PMIXNODE pNode, UINT uiPos )
|
|
{
|
|
MIX_COPY_KEYS_INTERNAL( pTag, pNode, uiPos, uiPos + 1, pNode->KeyCount - uiPos - 1 );
|
|
if ( ! pNode->Leaf )
|
|
{
|
|
MIX_COPY_CHILDS_INTERNAL( pTag, pNode, uiPos, uiPos + 1, pNode->KeyCount - uiPos );
|
|
}
|
|
pNode->KeyCount--;
|
|
}
|
|
|
|
|
|
static void hb_mixTagNodeAdjust( PMIXTAG pTag, PMIXNODE pNode )
|
|
{
|
|
UINT i, j;
|
|
PMIXNODE pParent, pSibling;
|
|
|
|
|
|
while ( 1 )
|
|
{
|
|
if ( pNode->KeyCount >= MIX_NODE_ORDER / 2 )
|
|
return;
|
|
|
|
/* Check siblings */
|
|
|
|
if ( pNode->Parent )
|
|
{
|
|
pParent = pNode->Parent;
|
|
j = hb_mixTagNodeParentIndex( pNode );
|
|
|
|
if ( j > 0 && pParent->Child[ j - 1 ]->KeyCount > MIX_NODE_ORDER / 2 )
|
|
{
|
|
/* Borrow from left */
|
|
|
|
pSibling = pParent->Child[ j - 1 ];
|
|
|
|
/* It could not be pNode->Child[ 0 ] if it is not Leaf!!! */
|
|
hb_mixTagAddKeyNode( pTag, pNode, 0, MIX_KEY( pTag, pParent, j - 1 ), pSibling->Child[ pSibling->KeyCount ], pNode->Child[ 0 ] );
|
|
MIX_COPY_KEYS_EXTERNAL( pTag, pParent, j - 1, pSibling, pSibling->KeyCount - 1, 1 );
|
|
pSibling->KeyCount--;
|
|
return;
|
|
}
|
|
else if ( j < pParent->KeyCount && pParent->Child[ j + 1 ]->KeyCount > MIX_NODE_ORDER / 2 )
|
|
{
|
|
/* Borrow from right */
|
|
|
|
pSibling = pParent->Child[ j + 1 ];
|
|
hb_mixTagAddKeyNode( pTag, pNode, pNode->KeyCount, MIX_KEY( pTag, pParent, j ), pNode->Child[ pNode->KeyCount ], pSibling->Child[ 0 ] );
|
|
MIX_COPY_KEYS_EXTERNAL( pTag, pParent, j, pSibling, 0, 1 );
|
|
hb_mixTagDelKeyNode( pTag, pSibling, 0 );
|
|
return;
|
|
}
|
|
else if ( j > 0 )
|
|
{
|
|
/* Join with left */
|
|
|
|
pSibling = pParent->Child[ j - 1 ];
|
|
MIX_COPY_KEYS_EXTERNAL( pTag, pSibling, pSibling->KeyCount, pParent, j - 1, 1 );
|
|
pSibling->KeyCount++;
|
|
MIX_COPY_KEYS_EXTERNAL( pTag, pSibling, pSibling->KeyCount, pNode, 0, pNode->KeyCount );
|
|
|
|
if ( pNode->Leaf )
|
|
{
|
|
pSibling->KeyCount += pNode->KeyCount;
|
|
}
|
|
else
|
|
{
|
|
MIX_COPY_CHILDS_EXTERNAL( pTag, pSibling, pSibling->KeyCount, pNode, 0, pNode->KeyCount );
|
|
for ( i = 0; i < pNode->KeyCount; i++ )
|
|
{
|
|
pSibling->Child[ pSibling->KeyCount++ ]->Parent = pSibling;
|
|
}
|
|
pSibling->Child[ pSibling->KeyCount ] = pNode->Child[ i ];
|
|
pSibling->Child[ pSibling->KeyCount ]->Parent = pSibling;
|
|
}
|
|
hb_xfree( pNode );
|
|
pParent->Child[ j ] = pSibling;
|
|
hb_mixTagDelKeyNode( pTag, pParent, j - 1 );
|
|
pNode = pParent;
|
|
}
|
|
else if ( j < pParent->KeyCount )
|
|
{
|
|
/* Join with right */
|
|
|
|
pSibling = pParent->Child[ j + 1 ];
|
|
MIX_COPY_KEYS_EXTERNAL( pTag, pNode, pNode->KeyCount, pParent, j, 1 );
|
|
pNode->KeyCount++;
|
|
MIX_COPY_KEYS_EXTERNAL( pTag, pNode, pNode->KeyCount, pSibling, 0, pSibling->KeyCount );
|
|
if ( pNode->Leaf )
|
|
{
|
|
pNode->KeyCount += pSibling->KeyCount;
|
|
}
|
|
else
|
|
{
|
|
MIX_COPY_CHILDS_EXTERNAL( pTag, pNode, pNode->KeyCount, pSibling, 0, pSibling->KeyCount );
|
|
for ( i = 0; i < pSibling->KeyCount; i++ )
|
|
{
|
|
pNode->Child[ pNode->KeyCount++ ]->Parent = pNode;
|
|
}
|
|
pNode->Child[ pNode->KeyCount ] = pSibling->Child[ i ];
|
|
pNode->Child[ pNode->KeyCount ]->Parent = pNode;
|
|
}
|
|
hb_xfree( pSibling );
|
|
pParent->Child[ j + 1 ] = pNode;
|
|
hb_mixTagDelKeyNode( pTag, pParent, j );
|
|
pNode = pParent;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Adjust root */
|
|
|
|
if ( ! pNode->KeyCount && ! pNode->Leaf )
|
|
{
|
|
pTag->Root = pNode->Child[ 0 ];
|
|
pTag->Root->Parent = NULL;
|
|
hb_xfree( pNode );
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void hb_mixTagDelKeyPos( PMIXTAG pTag, PMIXNODE pNode, UINT uiPos )
|
|
{
|
|
if ( pNode->Leaf )
|
|
{
|
|
hb_mixTagDelKeyNode( pTag, pNode, uiPos );
|
|
hb_mixTagNodeAdjust( pTag, pNode );
|
|
}
|
|
else
|
|
{
|
|
PMIXNODE pLeaf;
|
|
|
|
pLeaf = pNode->Child[ uiPos + 1 ];
|
|
while ( ! pLeaf->Leaf )
|
|
{
|
|
pLeaf = pLeaf->Child[ 0 ];
|
|
}
|
|
MIX_COPY_KEYS_EXTERNAL( pTag, pNode, uiPos, pLeaf, 0, 1 );
|
|
hb_mixTagDelKeyNode( pTag, pLeaf, 0 );
|
|
hb_mixTagNodeAdjust( pTag, pLeaf );
|
|
}
|
|
}
|
|
|
|
|
|
static BOOL hb_mixTagDelKey( PMIXTAG pTag, PMIXKEY pKey )
|
|
{
|
|
PMIXNODE pNode;
|
|
UINT ui;
|
|
int i;
|
|
|
|
i = hb_mixTagFindKey( pTag, pKey, pTag->uiKeyLen, &pNode, &ui, FALSE );
|
|
|
|
if ( i )
|
|
return FALSE;
|
|
|
|
hb_mixTagDelKeyPos( pTag, pNode, ui );
|
|
return 1;
|
|
}
|
|
|
|
|
|
static BYTE* hb_mixBuildSortTable( PHB_CODEPAGE pCodepage )
|
|
{
|
|
BYTE* pSortTable;
|
|
BYTE* pChars;
|
|
int i, j;
|
|
BYTE c;
|
|
|
|
pSortTable = (BYTE*) hb_xalloc( 256 );
|
|
|
|
if ( pCodepage && pCodepage->s_chars )
|
|
{
|
|
pChars = pCodepage->s_chars;
|
|
|
|
c = 0;
|
|
for ( i = 0; i < 256; i++ )
|
|
{
|
|
for ( j = 0; j < 256; j++ )
|
|
{
|
|
if ( pChars[ j ] == (BYTE) i )
|
|
{
|
|
pSortTable[ j ] = c;
|
|
c++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( i = 0; i < 256; i++ )
|
|
pSortTable[ i ] = ( BYTE ) i;
|
|
}
|
|
return pSortTable;
|
|
}
|
|
|
|
|
|
static PMIXTAG hb_mixTagCreate( char* szTagName, PHB_ITEM pKeyExpr, PHB_ITEM pKeyItem, PHB_ITEM pForItem, PHB_ITEM pWhileItem, BYTE bType, UINT uiKeyLen, SQLMIXAREAP pArea )
|
|
{
|
|
PMIXTAG pTag;
|
|
PMIXKEY pKey = NULL;
|
|
LPDBORDERCONDINFO pOrdCondInfo = pArea->lpdbOrdCondInfo;
|
|
ULONG ulStartRec, ulNextCount = 0;
|
|
LONG lStep = 0;
|
|
PHB_ITEM pItem, pEvalItem = NULL;
|
|
|
|
pTag = ( PMIXTAG ) hb_xgrab( sizeof( MIXTAG ) );
|
|
memset( pTag, 0, sizeof( MIXTAG ) );
|
|
|
|
pTag->pArea = pArea;
|
|
|
|
pTag->szName = (char*) hb_xgrab( MIX_MAXTAGNAMELEN + 1 );
|
|
hb_strncpyUpperTrim( pTag->szName, szTagName, MIX_MAXTAGNAMELEN );
|
|
|
|
pTag->szKeyExpr = (char*) hb_xgrab( hb_itemGetCLen( pKeyExpr ) + 1 );
|
|
hb_strncpyTrim( pTag->szKeyExpr, hb_itemGetCPtr( pKeyExpr ), hb_itemGetCLen( pKeyExpr ) );
|
|
|
|
/* TODO: FOR expresion */
|
|
pTag->szForExpr = NULL;
|
|
|
|
pTag->pKeyItem = pKeyItem;
|
|
pTag->pForItem = pForItem;
|
|
pTag->bType = bType;
|
|
pTag->uiKeyLen = uiKeyLen;
|
|
|
|
pTag->uiTotalLen = sizeof( MIXKEY ) + pTag->uiKeyLen;
|
|
|
|
/* Use national support */
|
|
if ( bType == 'C' )
|
|
{
|
|
if( pArea->cdPage && pArea->cdPage->lSort && !pArea->pSortTable )
|
|
{
|
|
pArea->pSortTable = hb_mixBuildSortTable( pArea->cdPage );
|
|
}
|
|
pTag->pSortTable = pArea->pSortTable;
|
|
}
|
|
|
|
pTag->Root = hb_mixTagCreateNode( pTag, TRUE );
|
|
|
|
ulStartRec = 0;
|
|
|
|
if ( pOrdCondInfo )
|
|
{
|
|
pEvalItem = pOrdCondInfo->itmCobEval;
|
|
lStep = pOrdCondInfo->lStep;
|
|
}
|
|
|
|
if ( ! pOrdCondInfo || pOrdCondInfo->fAll )
|
|
{
|
|
pArea->pTag = NULL;
|
|
}
|
|
else
|
|
{
|
|
if ( pOrdCondInfo->itmRecID )
|
|
ulStartRec = hb_itemGetNL( pOrdCondInfo->itmRecID );
|
|
|
|
if ( ulStartRec )
|
|
{
|
|
ulNextCount = 1;
|
|
}
|
|
else if ( pOrdCondInfo->fRest || pOrdCondInfo->lNextCount > 0 )
|
|
{
|
|
if ( pOrdCondInfo->itmStartRecID )
|
|
ulStartRec = hb_itemGetNL( pOrdCondInfo->itmStartRecID );
|
|
|
|
if ( !ulStartRec )
|
|
ulStartRec = pArea->ulRecNo;
|
|
|
|
if ( pArea->lpdbOrdCondInfo->lNextCount > 0 )
|
|
ulNextCount = pOrdCondInfo->lNextCount;
|
|
}
|
|
else if ( ! pOrdCondInfo->fUseCurrent )
|
|
{
|
|
pArea->pTag = NULL;
|
|
}
|
|
}
|
|
|
|
if ( ulStartRec == 0 && pArea->pTag == NULL )
|
|
ulStartRec = 1;
|
|
|
|
if ( ulStartRec )
|
|
{
|
|
SELF_GOTO( (AREAP) pArea, ulStartRec );
|
|
}
|
|
else
|
|
{
|
|
SELF_GOTOP( (AREAP) pArea );
|
|
}
|
|
|
|
while ( ! pArea->fEof )
|
|
{
|
|
if ( pEvalItem )
|
|
{
|
|
if ( lStep >= pOrdCondInfo->lStep )
|
|
{
|
|
lStep = 0;
|
|
if ( ! hb_mixEvalCond( NULL, pEvalItem ) )
|
|
break;
|
|
}
|
|
++lStep;
|
|
}
|
|
|
|
if ( pWhileItem && ! hb_mixEvalCond( NULL, pWhileItem ) )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if ( pForItem == NULL || hb_mixEvalCond( NULL, pForItem ) )
|
|
{
|
|
pItem = hb_vmEvalBlockOrMacro( pKeyItem );
|
|
|
|
pKey = hb_mixKeyPutItem( pKey, pItem, pArea->ulRecNo, pTag );
|
|
hb_mixTagAddKey( pTag, pKey );
|
|
}
|
|
|
|
if ( ulNextCount )
|
|
{
|
|
ulNextCount--;
|
|
if ( !ulNextCount ) break;
|
|
}
|
|
if ( SELF_SKIPRAW( ( AREAP ) pArea, 1 ) == HB_FAILURE )
|
|
break;
|
|
}
|
|
if ( pKey )
|
|
hb_mixKeyFree( pKey );
|
|
|
|
return pTag;
|
|
}
|
|
|
|
|
|
static void hb_mixTagDestroyNode( PMIXNODE pNode )
|
|
{
|
|
if ( ! pNode->Leaf )
|
|
{
|
|
UINT ui;
|
|
|
|
for ( ui = 0; ui <= pNode->KeyCount; ui++ )
|
|
hb_mixTagDestroyNode( pNode->Child[ ui ] );
|
|
}
|
|
hb_xfree( pNode );
|
|
}
|
|
|
|
|
|
static void hb_mixTagDestroy( PMIXTAG pTag )
|
|
{
|
|
if ( pTag->szName )
|
|
hb_xfree( pTag->szName );
|
|
|
|
if ( pTag->szKeyExpr )
|
|
hb_xfree( pTag->szKeyExpr );
|
|
|
|
if ( pTag->szForExpr )
|
|
hb_xfree( pTag->szForExpr );
|
|
|
|
if ( pTag->pKeyItem )
|
|
hb_vmDestroyBlockOrMacro( pTag->pKeyItem );
|
|
|
|
if ( pTag->pForItem )
|
|
hb_vmDestroyBlockOrMacro( pTag->pForItem );
|
|
|
|
if ( pTag->Root )
|
|
{
|
|
hb_mixTagDestroyNode( pTag->Root );
|
|
}
|
|
|
|
hb_xfree( pTag );
|
|
}
|
|
|
|
|
|
static void hb_mixTagGoTop( PMIXTAG pTag )
|
|
{
|
|
PMIXNODE pNode;
|
|
|
|
pNode = pTag->Root;
|
|
while ( ! pNode->Leaf )
|
|
{
|
|
pNode = pNode->Child[ 0 ];
|
|
}
|
|
|
|
if ( ! pNode->KeyCount )
|
|
{
|
|
pTag->fEof = TRUE;
|
|
return;
|
|
}
|
|
pTag->fEof = FALSE;
|
|
pTag->CurNode = pNode;
|
|
pTag->CurPos = 0;
|
|
pTag->CurKey = MIX_KEY( pTag, pTag->CurNode, 0 );
|
|
}
|
|
|
|
|
|
static void hb_mixTagGoBottom( PMIXTAG pTag )
|
|
{
|
|
PMIXNODE pNode;
|
|
|
|
pNode = pTag->Root;
|
|
while ( ! pNode->Leaf )
|
|
{
|
|
pNode = pNode->Child[ pNode->KeyCount ];
|
|
}
|
|
|
|
if ( ! pNode->KeyCount )
|
|
{
|
|
pTag->fEof = TRUE;
|
|
return;
|
|
}
|
|
pTag->fEof = FALSE;
|
|
pTag->CurNode = pNode;
|
|
pTag->CurPos = pNode->KeyCount - 1;
|
|
pTag->CurKey = MIX_KEY( pTag, pTag->CurNode, pTag->CurPos );
|
|
}
|
|
|
|
|
|
static void hb_mixTagSkip( PMIXTAG pTag, LONG lSkip )
|
|
{
|
|
PMIXNODE pNode, pNode2;
|
|
UINT uiPos, uiPos2;
|
|
|
|
pNode = pTag->CurNode;
|
|
uiPos = pTag->CurPos;
|
|
|
|
/* printf("hb_mixTagSkip: CurNode=%p, CurPos=%d lSkip=%d\n", pNode, uiPos, lSkip ); */
|
|
|
|
if ( lSkip > 0 )
|
|
{
|
|
pTag->fBof = FALSE;
|
|
while ( ! pTag->fEof && lSkip > 0 )
|
|
{
|
|
if ( pNode->Leaf )
|
|
{
|
|
if ( (LONG) (pNode->KeyCount - 1 - uiPos) >= lSkip )
|
|
{
|
|
uiPos += lSkip;
|
|
lSkip = 0;
|
|
}
|
|
else if ( pNode->KeyCount - 1 > uiPos )
|
|
{
|
|
lSkip -= (LONG) (pNode->KeyCount - 1 - uiPos);
|
|
uiPos = pNode->KeyCount - 1;
|
|
}
|
|
if ( lSkip )
|
|
{
|
|
do {
|
|
if ( pNode->Parent )
|
|
uiPos = hb_mixTagNodeParentIndex( pNode );
|
|
pNode = pNode->Parent;
|
|
} while ( pNode && uiPos == pNode->KeyCount );
|
|
|
|
if ( pNode )
|
|
{
|
|
lSkip--;
|
|
}
|
|
else
|
|
{
|
|
pTag->fEof = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pNode = pNode->Child[ uiPos + 1 ];
|
|
while ( ! pNode->Leaf )
|
|
{
|
|
pNode = pNode->Child[ 0 ];
|
|
}
|
|
uiPos = 0;
|
|
lSkip--;
|
|
}
|
|
}
|
|
}
|
|
else if ( lSkip < 0 )
|
|
{
|
|
lSkip = - lSkip;
|
|
|
|
/*
|
|
This is not needed. skip(-1) from Eof is processed inside sqlmixSkipRaw
|
|
if ( pTag->fEof )
|
|
{
|
|
hb_mixTagGoBottom( pTag );
|
|
lSkip--;
|
|
pTag->fBof = pTag->fEof;
|
|
}
|
|
*/
|
|
pTag->fBof = pTag->fEof;
|
|
|
|
while ( ! pTag->fBof && lSkip > 0 )
|
|
{
|
|
if ( pNode->Leaf )
|
|
{
|
|
if ( (LONG) uiPos >= lSkip )
|
|
{
|
|
uiPos -= lSkip;
|
|
lSkip = 0;
|
|
}
|
|
else if ( uiPos )
|
|
{
|
|
lSkip -= uiPos;
|
|
uiPos = 0;
|
|
}
|
|
if ( lSkip )
|
|
{
|
|
pNode2 = pNode;
|
|
uiPos2 = uiPos;
|
|
do {
|
|
if ( pNode->Parent )
|
|
uiPos = hb_mixTagNodeParentIndex( pNode );
|
|
pNode = pNode->Parent;
|
|
} while ( pNode && uiPos == 0 );
|
|
|
|
if ( pNode )
|
|
{
|
|
uiPos--;
|
|
lSkip--;
|
|
}
|
|
else
|
|
{
|
|
pNode = pNode2;
|
|
uiPos = uiPos2;
|
|
pTag->fBof = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
do
|
|
{
|
|
pNode = pNode->Child[ uiPos ];
|
|
uiPos = pNode->KeyCount;
|
|
}
|
|
while ( ! pNode->Leaf );
|
|
uiPos--;
|
|
lSkip--;
|
|
}
|
|
}
|
|
}
|
|
if ( ! pTag->fEof )
|
|
{
|
|
pTag->CurNode = pNode;
|
|
pTag->CurPos = uiPos;
|
|
pTag->CurKey = MIX_KEY( pTag, pNode, uiPos );
|
|
}
|
|
}
|
|
|
|
/* -------------------------- Misc functions ---------------------------- */
|
|
/* hb_mix*() */
|
|
|
|
static PMIXTAG hb_mixFindTag( SQLMIXAREAP pArea, PHB_ITEM pOrder )
|
|
{
|
|
PMIXTAG pTag;
|
|
|
|
if ( HB_IS_NUMBER( pOrder ) )
|
|
{
|
|
int iOrder, iCurr = 0;
|
|
|
|
iOrder = hb_itemGetNI( pOrder );
|
|
|
|
pTag = pArea->pTagList;
|
|
while ( pTag && iOrder != ++iCurr )
|
|
{
|
|
pTag = pTag->pNext;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
char szTag[ MIX_MAXTAGNAMELEN + 1 ];
|
|
|
|
hb_strncpyUpperTrim( szTag, hb_itemGetCPtr( pOrder ), MIX_MAXTAGNAMELEN );
|
|
pTag = pArea->pTagList;
|
|
while ( pTag && hb_stricmp( szTag, pTag->szName ) )
|
|
{
|
|
pTag = pTag->pNext;
|
|
}
|
|
}
|
|
return pTag;
|
|
}
|
|
|
|
|
|
/*=======================================================================*/
|
|
|
|
|
|
static ULONG hb_mixTagNodeKeyCount( PMIXNODE pNode )
|
|
{
|
|
ULONG ulKeyCount;
|
|
UINT ui;
|
|
|
|
ulKeyCount = pNode->KeyCount;
|
|
if ( ! pNode->Leaf )
|
|
{
|
|
for ( ui = 0; ui <= pNode->KeyCount; ui++ )
|
|
ulKeyCount += hb_mixTagNodeKeyCount( pNode->Child[ ui ] );
|
|
}
|
|
return ulKeyCount;
|
|
}
|
|
|
|
|
|
static BOOL hb_mixCheckRecordFilter( SQLMIXAREAP pArea, ULONG ulRecNo )
|
|
{
|
|
BOOL lResult = FALSE;
|
|
|
|
if ( pArea->dbfi.itmCobExpr || hb_setGetDeleted() )
|
|
{
|
|
if ( pArea->ulRecNo != ulRecNo || pArea->lpdbPendingRel )
|
|
SELF_GOTO( ( AREAP ) pArea, ulRecNo );
|
|
|
|
if ( hb_setGetDeleted() )
|
|
SUPER_DELETED( ( AREAP ) pArea, &lResult );
|
|
|
|
if ( !lResult && pArea->dbfi.itmCobExpr )
|
|
{
|
|
PHB_ITEM pResult = hb_vmEvalBlock( pArea->dbfi.itmCobExpr );
|
|
lResult = HB_IS_LOGICAL( pResult ) && !hb_itemGetL( pResult );
|
|
}
|
|
}
|
|
return !lResult;
|
|
}
|
|
|
|
|
|
static ULONG hb_mixDBOIKeyCount( PMIXTAG pTag, BOOL fFilter )
|
|
{
|
|
ULONG ulKeyCount;
|
|
|
|
if ( ! pTag )
|
|
return 0;
|
|
|
|
if ( fFilter && pTag->pArea->dbfi.fFilter )
|
|
{
|
|
PMIXNODE pNode = pTag->CurNode;
|
|
UINT uiPos = pTag->CurPos;
|
|
ULONG ulRecNo = pTag->pArea->ulRecNo;
|
|
|
|
ulKeyCount = 0;
|
|
|
|
hb_mixTagGoTop( pTag );
|
|
while ( ! pTag->fEof )
|
|
{
|
|
if ( hb_mixCheckRecordFilter( pTag->pArea, pTag->CurKey->rec ) )
|
|
ulKeyCount++;
|
|
hb_mixTagSkip( pTag, 1 );
|
|
}
|
|
hb_mixTagSetCurrent( pTag, pNode, uiPos );
|
|
SELF_GOTO( (AREAP) pTag->pArea, ulRecNo );
|
|
|
|
}
|
|
else
|
|
{
|
|
ulKeyCount = hb_mixTagNodeKeyCount( pTag->Root );
|
|
}
|
|
return ulKeyCount;
|
|
}
|
|
|
|
|
|
static ULONG hb_mixDBOIKeyNo( PMIXTAG pTag, BOOL fFilter )
|
|
{
|
|
ULONG ulKeyCount;
|
|
|
|
if ( ! pTag )
|
|
return 0;
|
|
|
|
if ( fFilter )
|
|
ulKeyCount = 0;
|
|
else
|
|
{
|
|
PMIXNODE pNode = pTag->CurNode;
|
|
UINT ui, uiPos = pTag->CurPos;
|
|
|
|
ulKeyCount = 1;
|
|
|
|
while ( pNode )
|
|
{
|
|
ulKeyCount += uiPos;
|
|
if ( ! pNode->Leaf )
|
|
{
|
|
for ( ui = 0; ui < uiPos; ui++ )
|
|
ulKeyCount += hb_mixTagNodeKeyCount( pNode->Child[ ui ] );
|
|
}
|
|
pNode = pNode->Parent;
|
|
if ( pNode )
|
|
uiPos = hb_mixTagNodeParentIndex( pNode );
|
|
}
|
|
}
|
|
return ulKeyCount;
|
|
}
|
|
|
|
|
|
/*
|
|
=======================================================================
|
|
SQLMIX RDD METHODS
|
|
=======================================================================
|
|
*/
|
|
|
|
static HB_ERRCODE sqlmixGoBottom( SQLMIXAREAP pArea )
|
|
{
|
|
HB_ERRCODE retval;
|
|
|
|
if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
|
|
return HB_FAILURE;
|
|
|
|
if ( ! pArea->pTag )
|
|
return SUPER_GOBOTTOM( ( AREAP ) pArea );
|
|
|
|
if ( pArea->lpdbPendingRel && pArea->lpdbPendingRel->isScoped )
|
|
SELF_FORCEREL( ( AREAP ) pArea );
|
|
|
|
hb_mixTagGoBottom( pArea->pTag );
|
|
|
|
pArea->fTop = FALSE;
|
|
pArea->fBottom = TRUE;
|
|
|
|
retval = SELF_GOTO( ( AREAP ) pArea, pArea->pTag->CurKey ? pArea->pTag->CurKey->rec : 0 );
|
|
if ( retval != HB_FAILURE && pArea->fPositioned )
|
|
retval = SELF_SKIPFILTER( ( AREAP ) pArea, -1 );
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
static HB_ERRCODE sqlmixGoTop( SQLMIXAREAP pArea )
|
|
{
|
|
HB_ERRCODE retval;
|
|
|
|
if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
|
|
return HB_FAILURE;
|
|
|
|
if ( ! pArea->pTag )
|
|
return SUPER_GOTOP( ( AREAP ) pArea );
|
|
|
|
if ( pArea->lpdbPendingRel && pArea->lpdbPendingRel->isScoped )
|
|
SELF_FORCEREL( ( AREAP ) pArea );
|
|
|
|
hb_mixTagGoTop( pArea->pTag );
|
|
|
|
pArea->fTop = TRUE;
|
|
pArea->fBottom = FALSE;
|
|
|
|
retval = SELF_GOTO( ( AREAP ) pArea, pArea->pTag->CurKey ? pArea->pTag->CurKey->rec : 0 );
|
|
if ( retval != HB_FAILURE && pArea->fPositioned )
|
|
retval = SELF_SKIPFILTER( ( AREAP ) pArea, -1 );
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
static HB_ERRCODE sqlmixSeek( SQLMIXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BOOL fFindLast )
|
|
{
|
|
if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
|
|
return HB_FAILURE;
|
|
|
|
if ( ! pArea->pTag )
|
|
{
|
|
sqlmixErrorRT( pArea, EG_NOORDER, 1201, NULL, 0, EF_CANDEFAULT );
|
|
return HB_FAILURE;
|
|
}
|
|
else
|
|
{
|
|
PMIXKEY pKey;
|
|
HB_ERRCODE retval = HB_SUCCESS;
|
|
BOOL fEOF;
|
|
PMIXTAG pTag = pArea->pTag;
|
|
PMIXNODE pNode;
|
|
UINT uiKeyLen, ui;
|
|
|
|
if ( pArea->lpdbPendingRel && pArea->lpdbPendingRel->isScoped )
|
|
SELF_FORCEREL( ( AREAP ) pArea );
|
|
|
|
pArea->fTop = pArea->fBottom = FALSE;
|
|
pArea->fEof = FALSE;
|
|
|
|
pKey = hb_mixKeyPutItem( NULL, pItem, fFindLast ? (ULONG) -1 : 0, pTag );
|
|
|
|
uiKeyLen = pTag->uiKeyLen;
|
|
if ( pTag->bType == 'C' )
|
|
{
|
|
uiKeyLen = (UINT) hb_itemGetCLen( pItem );
|
|
if ( uiKeyLen > pTag->uiKeyLen )
|
|
uiKeyLen = pTag->uiKeyLen;
|
|
}
|
|
|
|
hb_mixTagFindKey( pTag, pKey, uiKeyLen, &pNode, &ui, TRUE );
|
|
hb_mixTagSetCurrent( pTag, pNode, ui );
|
|
|
|
if ( fFindLast )
|
|
{
|
|
if ( pTag->fEof )
|
|
hb_mixTagGoBottom( pTag );
|
|
else
|
|
hb_mixTagSkip( pTag, -1 );
|
|
|
|
pArea->fFound = ! pTag->fEof && ( uiKeyLen == 0 || memcmp( pTag->CurKey->val, pKey->val, (ULONG) uiKeyLen ) == 0 );
|
|
|
|
if ( ! pArea->fFound )
|
|
hb_mixTagSetCurrent( pTag, pNode, ui );
|
|
}
|
|
else
|
|
{
|
|
pArea->fFound = ! pTag->fEof && ( uiKeyLen == 0 || memcmp( pTag->CurKey->val, pKey->val, (ULONG) uiKeyLen ) == 0 );
|
|
}
|
|
|
|
fEOF = pTag->fEof;
|
|
|
|
if ( !fEOF )
|
|
{
|
|
retval = SELF_GOTO( ( AREAP ) pArea, pTag->CurKey->rec );
|
|
if ( retval != HB_FAILURE && pArea->fPositioned )
|
|
{
|
|
retval = SELF_SKIPFILTER( ( AREAP ) pArea, fFindLast ? -1 : 1 );
|
|
if ( retval != HB_FAILURE && pArea->fPositioned )
|
|
{
|
|
pArea->fFound = ( uiKeyLen == 0 || memcmp( pTag->CurKey->val, pKey->val, (ULONG) uiKeyLen ) == 0 );
|
|
if ( ! pArea->fFound && ! fSoftSeek )
|
|
fEOF = TRUE;
|
|
}
|
|
}
|
|
}
|
|
if ( retval != HB_FAILURE && fEOF )
|
|
{
|
|
retval = SELF_GOTO( ( AREAP ) pArea, 0 );
|
|
}
|
|
pArea->fBof = FALSE;
|
|
|
|
hb_mixKeyFree( pKey );
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
|
|
static HB_ERRCODE sqlmixSkipRaw( SQLMIXAREAP pArea, LONG lToSkip )
|
|
{
|
|
PMIXTAG pTag = pArea->pTag;
|
|
BOOL fOut = FALSE;
|
|
|
|
if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
|
|
return HB_FAILURE;
|
|
|
|
if ( ! pTag || lToSkip == 0 )
|
|
return SUPER_SKIPRAW( ( AREAP ) pArea, lToSkip );
|
|
|
|
if ( pArea->lpdbPendingRel )
|
|
SELF_FORCEREL( ( AREAP ) pArea );
|
|
|
|
if ( ! hb_mixTagRefreshKey( pTag ) )
|
|
{
|
|
if ( lToSkip > 0 || pArea->fPositioned )
|
|
fOut = TRUE;
|
|
else
|
|
{
|
|
hb_mixTagGoBottom( pTag );
|
|
fOut = pTag->fEof;
|
|
lToSkip++;
|
|
}
|
|
}
|
|
|
|
if ( ! fOut )
|
|
hb_mixTagSkip( pTag, lToSkip );
|
|
|
|
if ( SELF_GOTO( ( AREAP ) pArea, ( pTag->fEof || fOut ) ? 0 : pTag->CurKey->rec ) != HB_SUCCESS )
|
|
return HB_FAILURE;
|
|
pArea->fEof = pTag->fEof;
|
|
pArea->fBof = pTag->fBof;
|
|
return HB_SUCCESS;
|
|
}
|
|
|
|
|
|
static HB_ERRCODE sqlmixGoCold( SQLMIXAREAP pArea )
|
|
{
|
|
BOOL fRecordChanged = pArea->fRecordChanged;
|
|
BOOL fAppend = pArea->fAppend;
|
|
|
|
if ( SUPER_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
|
|
return HB_FAILURE;
|
|
|
|
if ( fRecordChanged && pArea->pTagList )
|
|
{
|
|
PMIXTAG pTag;
|
|
PMIXKEY pKey = NULL;
|
|
BOOL fAdd, fDel;
|
|
LPDBRELINFO lpdbPendingRel;
|
|
|
|
lpdbPendingRel = pArea->lpdbPendingRel;
|
|
pArea->lpdbPendingRel = NULL;
|
|
|
|
pTag = pArea->pTagList;
|
|
while ( pTag )
|
|
{
|
|
|
|
if ( ! pTag->fCustom )
|
|
{
|
|
pKey = hb_mixKeyEval( pKey, pTag );
|
|
|
|
/* printf( "sqlmixGoCold NEWKEY:%s rec:%d\n", pKey->val, pKey->rec); */
|
|
|
|
if ( pTag->pForItem != NULL )
|
|
fAdd = hb_mixEvalCond( pArea, pTag->pForItem );
|
|
else
|
|
fAdd = TRUE;
|
|
|
|
if ( fAppend )
|
|
fDel = FALSE;
|
|
else
|
|
{
|
|
if ( hb_mixKeyCompare( pTag, pKey, pTag->HotKey, pTag->uiKeyLen ) == 0 )
|
|
{
|
|
fDel = !fAdd && pTag->HotFor;
|
|
fAdd = fAdd && !pTag->HotFor;
|
|
}
|
|
else
|
|
{
|
|
fDel = pTag->HotFor;
|
|
}
|
|
}
|
|
|
|
if ( fDel )
|
|
hb_mixTagDelKey( pTag, pTag->HotKey );
|
|
|
|
if ( fAdd )
|
|
hb_mixTagAddKey( pTag, pKey );
|
|
}
|
|
pTag = pTag->pNext;
|
|
}
|
|
|
|
if ( pKey )
|
|
hb_mixKeyFree( pKey );
|
|
|
|
pArea->lpdbPendingRel = lpdbPendingRel;
|
|
}
|
|
|
|
return HB_SUCCESS;
|
|
}
|
|
|
|
|
|
static HB_ERRCODE sqlmixGoHot( SQLMIXAREAP pArea )
|
|
{
|
|
PMIXTAG pTag;
|
|
|
|
/*
|
|
if ( pArea->fRecordChanged )
|
|
printf( "sqlmixGoHot: multiple marking buffer as hot." );
|
|
*/
|
|
|
|
if ( SUPER_GOHOT( (AREAP) pArea ) == HB_FAILURE )
|
|
return HB_FAILURE;
|
|
|
|
pTag = pArea->pTagList;
|
|
while ( pTag )
|
|
{
|
|
if ( !pTag->fCustom )
|
|
{
|
|
pTag->HotKey = hb_mixKeyEval( pTag->HotKey, pTag );
|
|
pTag->HotFor = pTag->pForItem == NULL || hb_mixEvalCond( pArea, pTag->pForItem );
|
|
}
|
|
pTag = pTag->pNext;
|
|
}
|
|
return HB_SUCCESS;
|
|
}
|
|
|
|
|
|
static HB_ERRCODE sqlmixClose( SQLMIXAREAP pArea )
|
|
{
|
|
if ( SELF_GOCOLD( (AREAP) pArea ) == HB_FAILURE )
|
|
return HB_FAILURE;
|
|
|
|
if ( SUPER_CLOSE( (AREAP) pArea ) == HB_FAILURE )
|
|
return HB_FAILURE;
|
|
|
|
if ( SELF_ORDLSTCLEAR( (AREAP) pArea ) == HB_FAILURE )
|
|
return HB_FAILURE;
|
|
|
|
if ( pArea->pSortTable )
|
|
hb_xfree( pArea->pSortTable );
|
|
|
|
return HB_SUCCESS;
|
|
}
|
|
|
|
|
|
static HB_ERRCODE sqlmixStructSize( SQLMIXAREAP pArea, USHORT* StructSize )
|
|
{
|
|
HB_SYMBOL_UNUSED( pArea );
|
|
|
|
* StructSize = sizeof( SQLMIXAREA );
|
|
return HB_SUCCESS;
|
|
}
|
|
|
|
|
|
static HB_ERRCODE sqlmixOrderListClear( SQLMIXAREAP pArea )
|
|
{
|
|
PMIXTAG pTag;
|
|
|
|
while ( pArea->pTagList )
|
|
{
|
|
pTag = pArea->pTagList;
|
|
pArea->pTagList = pTag->pNext;
|
|
hb_mixTagDestroy( pTag );
|
|
}
|
|
pArea->pTag = NULL;
|
|
return HB_SUCCESS;
|
|
}
|
|
|
|
|
|
static HB_ERRCODE sqlmixOrderListFocus( SQLMIXAREAP pArea, LPDBORDERINFO pOrderInfo )
|
|
{
|
|
if ( pArea->pTag )
|
|
{
|
|
pOrderInfo->itmResult = hb_itemPutC( pOrderInfo->itmResult, pArea->pTag->szName );
|
|
}
|
|
|
|
if ( pOrderInfo->itmOrder )
|
|
{
|
|
pArea->pTag = hb_mixFindTag( pArea, pOrderInfo->itmOrder );
|
|
}
|
|
return pArea->pTag ? HB_SUCCESS : HB_FAILURE;
|
|
}
|
|
|
|
|
|
static HB_ERRCODE sqlmixOrderCreate( SQLMIXAREAP pArea, LPDBORDERCREATEINFO pOrderInfo )
|
|
{
|
|
PMIXTAG pTagNew, pTag;
|
|
PHB_ITEM pKeyItem, pForItem = NULL, pWhileItem = NULL, pResult;
|
|
ULONG ulRecNo;
|
|
USHORT uiLen;
|
|
BYTE bType;
|
|
|
|
/* Obtain key codeblock */
|
|
if ( pOrderInfo->itmCobExpr )
|
|
{
|
|
pKeyItem = hb_itemNew( pOrderInfo->itmCobExpr );
|
|
}
|
|
else
|
|
{
|
|
if ( SELF_COMPILE( (AREAP) pArea, (BYTE*) hb_itemGetCPtr( pOrderInfo->abExpr ) ) == HB_FAILURE )
|
|
return HB_FAILURE;
|
|
pKeyItem = pArea->valResult;
|
|
pArea->valResult = NULL;
|
|
}
|
|
|
|
/* Test key codeblock on EOF */
|
|
ulRecNo = pArea->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->valResult;
|
|
pArea->valResult = NULL;
|
|
|
|
switch ( hb_itemType( pResult ) )
|
|
{
|
|
case HB_IT_STRING:
|
|
case HB_IT_STRING | HB_IT_MEMO:
|
|
bType = 'C';
|
|
uiLen = (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 );
|
|
sqlmixErrorRT( pArea, bType == 'U' ? EG_DATATYPE : EG_DATAWIDTH, 1026, NULL, 0, 0 );
|
|
return HB_FAILURE;
|
|
}
|
|
|
|
if ( pArea->lpdbOrdCondInfo )
|
|
{
|
|
/* Obtain FOR codeblock */
|
|
if ( pArea->lpdbOrdCondInfo->itmCobFor )
|
|
{
|
|
pForItem = hb_itemNew( pArea->lpdbOrdCondInfo->itmCobFor );
|
|
}
|
|
else if ( pArea->lpdbOrdCondInfo->abFor )
|
|
{
|
|
if ( SELF_COMPILE( (AREAP) pArea, pArea->lpdbOrdCondInfo->abFor ) == HB_FAILURE )
|
|
{
|
|
hb_vmDestroyBlockOrMacro( pKeyItem );
|
|
SELF_GOTO( (AREAP) pArea, ulRecNo );
|
|
return HB_FAILURE;
|
|
}
|
|
pForItem = pArea->valResult;
|
|
pArea->valResult = NULL;
|
|
}
|
|
|
|
/* Obtain WHILE codeblock */
|
|
if ( pArea->lpdbOrdCondInfo->itmCobWhile )
|
|
{
|
|
pWhileItem = hb_itemNew( pArea->lpdbOrdCondInfo->itmCobWhile );
|
|
}
|
|
else if ( pArea->lpdbOrdCondInfo->abWhile )
|
|
{
|
|
if ( SELF_COMPILE( (AREAP) pArea, pArea->lpdbOrdCondInfo->abWhile ) == HB_FAILURE )
|
|
{
|
|
hb_vmDestroyBlockOrMacro( pKeyItem );
|
|
if ( pForItem )
|
|
hb_vmDestroyBlockOrMacro( pForItem );
|
|
SELF_GOTO( (AREAP) pArea, ulRecNo );
|
|
return HB_FAILURE;
|
|
}
|
|
pWhileItem = pArea->valResult;
|
|
pArea->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->valResult ) != HB_IT_LOGICAL )
|
|
{
|
|
hb_itemRelease( pArea->valResult );
|
|
pArea->valResult = 0;
|
|
hb_vmDestroyBlockOrMacro( pKeyItem );
|
|
hb_vmDestroyBlockOrMacro( pForItem );
|
|
if ( pWhileItem )
|
|
hb_vmDestroyBlockOrMacro( pWhileItem );
|
|
SELF_GOTO( (AREAP) pArea, ulRecNo );
|
|
sqlmixErrorRT( pArea, EG_DATATYPE, EDBF_INVALIDFOR, NULL, 0, 0 );
|
|
return HB_FAILURE;
|
|
}
|
|
hb_itemRelease( pArea->valResult );
|
|
pArea->valResult = 0;
|
|
}
|
|
|
|
/* TODO: WHILE condition is not tested, like in DBFCDX. Why? Compatibility with Clipper? */
|
|
|
|
SELF_GOTO( (AREAP) pArea, ulRecNo );
|
|
|
|
pTagNew = hb_mixTagCreate( ( char * ) 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->pTag = pTagNew;
|
|
return HB_SUCCESS;
|
|
}
|
|
|
|
|
|
static HB_ERRCODE sqlmixOrderInfo( SQLMIXAREAP pArea, USHORT uiIndex, LPDBORDERINFO pOrderInfo )
|
|
{
|
|
PMIXTAG pTag;
|
|
USHORT uiTag = 0;
|
|
|
|
|
|
switch( uiIndex )
|
|
{
|
|
case DBOI_EVALSTEP:
|
|
pOrderInfo->itmResult = hb_itemPutNL( pOrderInfo->itmResult,
|
|
pArea->lpdbOrdCondInfo ? pArea->lpdbOrdCondInfo->lStep : 0 );
|
|
return HB_SUCCESS;
|
|
|
|
case DBOI_ORDERCOUNT:
|
|
pTag = pArea->pTagList;
|
|
while ( pTag )
|
|
{
|
|
pTag = pTag->pNext;
|
|
uiTag++;
|
|
}
|
|
pOrderInfo->itmResult = hb_itemPutNI( pOrderInfo->itmResult, uiTag );
|
|
return HB_SUCCESS;
|
|
}
|
|
|
|
|
|
if ( SELF_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
|
|
return HB_FAILURE;
|
|
|
|
|
|
if ( pOrderInfo->itmOrder )
|
|
pTag = hb_mixFindTag( pArea, pOrderInfo->itmOrder );
|
|
else
|
|
pTag = pArea->pTag;
|
|
|
|
|
|
switch( uiIndex )
|
|
{
|
|
case DBOI_CONDITION:
|
|
pOrderInfo->itmResult = hb_itemPutC( pOrderInfo->itmResult, ( pTag ? pTag->szForExpr : NULL ) );
|
|
if ( pTag && pOrderInfo->itmNewVal && HB_IS_STRING( pOrderInfo->itmNewVal ) )
|
|
{
|
|
if ( pTag->szForExpr != NULL )
|
|
{
|
|
hb_xfree( pTag->szForExpr );
|
|
pTag->szForExpr = NULL;
|
|
}
|
|
if ( pTag->pForItem != NULL )
|
|
{
|
|
hb_vmDestroyBlockOrMacro( pTag->pForItem );
|
|
pTag->pForItem = NULL;
|
|
}
|
|
if ( hb_itemGetCLen( pOrderInfo->itmNewVal ) > 0 )
|
|
{
|
|
char* pForExpr = hb_itemGetCPtr( pOrderInfo->itmNewVal );
|
|
|
|
if ( SELF_COMPILE( (AREAP) pArea, (BYTE*) pForExpr ) == HB_SUCCESS )
|
|
{
|
|
PHB_ITEM pForItem = pArea->valResult;
|
|
|
|
pArea->valResult = NULL;
|
|
if ( SELF_EVALBLOCK( (AREAP) pArea, pForItem ) == HB_SUCCESS )
|
|
{
|
|
if ( hb_itemType( pArea->valResult ) == HB_IT_LOGICAL )
|
|
{
|
|
pTag->szForExpr = hb_strdup( pForExpr );
|
|
pTag->pForItem = pForItem;
|
|
pForItem = NULL;
|
|
}
|
|
hb_itemRelease( pArea->valResult );
|
|
pArea->valResult = NULL;
|
|
}
|
|
if ( pForItem )
|
|
hb_vmDestroyBlockOrMacro( pForItem );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DBOI_EXPRESSION:
|
|
pOrderInfo->itmResult = hb_itemPutC( pOrderInfo->itmResult, pTag ? pTag->szKeyExpr : NULL );
|
|
break;
|
|
|
|
case DBOI_POSITION:
|
|
case DBOI_KEYNORAW:
|
|
if ( pOrderInfo->itmNewVal && HB_IS_NUMERIC( pOrderInfo->itmNewVal ) )
|
|
{
|
|
|
|
/* TODO:
|
|
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult,
|
|
hb_cdxDBOIKeyGoto( pArea, pTag,
|
|
hb_itemGetNL( pOrderInfo->itmNewVal ), uiIndex == DBOI_POSITION ) == HB_SUCCESS );
|
|
*/
|
|
}
|
|
else
|
|
pOrderInfo->itmResult = hb_itemPutNL( pOrderInfo->itmResult,
|
|
hb_mixDBOIKeyNo( pTag, uiIndex == DBOI_POSITION ) );
|
|
break;
|
|
|
|
case DBOI_KEYCOUNT:
|
|
case DBOI_KEYCOUNTRAW:
|
|
pOrderInfo->itmResult = hb_itemPutNL( pOrderInfo->itmResult,
|
|
hb_mixDBOIKeyCount( pTag, uiIndex == DBOI_KEYCOUNT ) );
|
|
break;
|
|
|
|
/* TODO:
|
|
case DBOI_FINDREC:
|
|
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult,
|
|
hb_cdxDBOIFindRec( pArea, pTag,
|
|
hb_itemGetNL( pOrderInfo->itmNewVal ), FALSE ) );
|
|
break;
|
|
|
|
case DBOI_FINDRECCONT:
|
|
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult,
|
|
hb_cdxDBOIFindRec( pArea, pTag,
|
|
hb_itemGetNL( pOrderInfo->itmNewVal ), TRUE ) );
|
|
break;
|
|
*/
|
|
case DBOI_NAME:
|
|
pOrderInfo->itmResult = hb_itemPutC( pOrderInfo->itmResult, pTag ? pTag->szName : NULL );
|
|
break;
|
|
|
|
case DBOI_NUMBER:
|
|
pOrderInfo->itmResult = hb_itemPutNI( pOrderInfo->itmResult, uiTag ); // kitaip
|
|
break;
|
|
|
|
case DBOI_ISCOND:
|
|
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, pTag && pTag->szForExpr != NULL );
|
|
break;
|
|
|
|
case DBOI_ISDESC:
|
|
case DBOI_UNIQUE:
|
|
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, FALSE );
|
|
break;
|
|
|
|
case DBOI_SCOPETOP:
|
|
case DBOI_SCOPEBOTTOM:
|
|
if ( pOrderInfo->itmResult )
|
|
hb_itemClear( pOrderInfo->itmResult );
|
|
break;
|
|
|
|
case DBOI_KEYTYPE:
|
|
if ( pTag )
|
|
{
|
|
char szType[ 2 ];
|
|
|
|
szType[ 0 ] = (char) pTag->bType;
|
|
szType[ 1 ] = 0;
|
|
pOrderInfo->itmResult = hb_itemPutC( pOrderInfo->itmResult, szType );
|
|
}
|
|
else
|
|
pOrderInfo->itmResult = hb_itemPutC( pOrderInfo->itmResult, NULL );
|
|
break;
|
|
|
|
case DBOI_KEYSIZE:
|
|
pOrderInfo->itmResult = hb_itemPutNI( pOrderInfo->itmResult, pTag ? pTag->uiKeyLen : 0 );
|
|
break;
|
|
|
|
case DBOI_KEYDEC:
|
|
pOrderInfo->itmResult = hb_itemPutNI( pOrderInfo->itmResult, 0 );
|
|
break;
|
|
|
|
/* TODO:
|
|
case DBOI_KEYVAL:
|
|
hb_itemClear( pOrderInfo->itmResult );
|
|
if ( pArea->lpdbPendingRel )
|
|
SELF_FORCEREL( ( AREAP ) pArea );
|
|
if ( pTag && pArea->fPositioned )
|
|
{
|
|
if ( pTag->CurKey->rec != pArea->ulRecNo )
|
|
{
|
|
hb_cdxIndexLockRead( pTag->pIndex );
|
|
hb_cdxCurKeyRefresh( pArea, pTag );
|
|
hb_cdxIndexUnLockRead( pTag->pIndex );
|
|
}
|
|
if ( pTag->CurKey->rec == pArea->ulRecNo )
|
|
pOrderInfo->itmResult = hb_cdxKeyGetItem( pTag->CurKey,
|
|
pOrderInfo->itmResult, pTag, TRUE );
|
|
}
|
|
break;
|
|
|
|
case DBOI_CUSTOM:
|
|
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, ( pTag ? pTag->fCustom : FALSE ) );
|
|
if ( pOrderInfo->itmNewVal && HB_IS_LOGICAL( pOrderInfo->itmNewVal )
|
|
&& hb_itemGetL( pOrderInfo->itmNewVal ) )
|
|
{
|
|
pTag->fCustom = TRUE;
|
|
}
|
|
break;
|
|
|
|
case DBOI_KEYADD:
|
|
if ( ! pTag )
|
|
{
|
|
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, FALSE );
|
|
}
|
|
else
|
|
{
|
|
if ( pTag->fCustom )
|
|
{
|
|
if ( pArea->lpdbPendingRel )
|
|
SELF_FORCEREL( ( AREAP ) pArea );
|
|
|
|
if ( ! pArea->fPositioned ||
|
|
( pTag->pForItem &&
|
|
! hb_cdxEvalCond( pArea, pTag->pForItem, TRUE ) ) )
|
|
{
|
|
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, FALSE );
|
|
}
|
|
else
|
|
{
|
|
LPCDXKEY pKey;
|
|
hb_cdxIndexLockWrite( pTag->pIndex );
|
|
if ( pOrderInfo->itmNewVal && ! HB_IS_NIL( pOrderInfo->itmNewVal ) )
|
|
pKey = hb_cdxKeyPutItem( NULL, pOrderInfo->itmNewVal, pArea->ulRecNo, pTag, TRUE, TRUE );
|
|
else
|
|
pKey = hb_cdxKeyEval( NULL, pTag );
|
|
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult,
|
|
hb_cdxTagKeyAdd( pTag, pKey ) );
|
|
hb_cdxIndexUnLockWrite( pTag->pIndex );
|
|
hb_cdxKeyFree( pKey );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sqlmixErrorRT( pArea, 0, 1052, NULL, 0, 0 );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DBOI_KEYDELETE:
|
|
if ( ! pTag )
|
|
{
|
|
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, FALSE );
|
|
}
|
|
else
|
|
{
|
|
if ( pTag->Custom )
|
|
{
|
|
if ( pArea->lpdbPendingRel )
|
|
SELF_FORCEREL( ( AREAP ) pArea );
|
|
|
|
if ( !pArea->fPositioned ||
|
|
( pTag->pForItem &&
|
|
!hb_cdxEvalCond( pArea, pTag->pForItem, TRUE ) ) )
|
|
{
|
|
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, FALSE );
|
|
}
|
|
else
|
|
{
|
|
LPCDXKEY pKey;
|
|
hb_cdxIndexLockWrite( pTag->pIndex );
|
|
if ( pOrderInfo->itmNewVal && !HB_IS_NIL( pOrderInfo->itmNewVal ) )
|
|
pKey = hb_cdxKeyPutItem( NULL, pOrderInfo->itmNewVal, pArea->ulRecNo, pTag, TRUE, TRUE );
|
|
else
|
|
pKey = hb_cdxKeyEval( NULL, pTag );
|
|
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult,
|
|
hb_cdxTagKeyDel( pTag, pKey ) );
|
|
hb_cdxIndexUnLockWrite( pTag->pIndex );
|
|
hb_cdxKeyFree( pKey );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sqlmixErrorRT( pArea, 0, 1052, NULL, 0, 0 );
|
|
}
|
|
}
|
|
break;
|
|
|
|
*/
|
|
case DBOI_SHARED:
|
|
case DBOI_ISREADONLY:
|
|
pOrderInfo->itmResult = hb_itemPutL( pOrderInfo->itmResult, FALSE );
|
|
break;
|
|
|
|
default:
|
|
return SUPER_ORDINFO( ( AREAP ) pArea, uiIndex, pOrderInfo );
|
|
|
|
}
|
|
return HB_SUCCESS;
|
|
}
|
|
|
|
|
|
static HB_ERRCODE sqlmixExit( LPRDDNODE pRDD )
|
|
{
|
|
/* This empty method is used to avoid duplicated sqlbase exit call */
|
|
HB_SYMBOL_UNUSED( pRDD );
|
|
return HB_SUCCESS;
|
|
}
|
|
|
|
|
|
static RDDFUNCS sqlmixTable =
|
|
{( DBENTRYP_BP ) NULL, /* sqlmixBof */
|
|
( DBENTRYP_BP ) NULL, /* sqlmixEof */
|
|
( DBENTRYP_BP ) NULL, /* sqlmixFound */
|
|
( DBENTRYP_V ) sqlmixGoBottom,
|
|
( DBENTRYP_UL ) NULL, /* sqlmixGoTo */
|
|
( DBENTRYP_I ) NULL, /* sqlmixGoToId */
|
|
( DBENTRYP_V ) sqlmixGoTop,
|
|
( DBENTRYP_BIB ) sqlmixSeek,
|
|
( DBENTRYP_L ) NULL, /* sqlmixSkip */
|
|
( DBENTRYP_L ) NULL, /* sqlmixSkipFilter */
|
|
( DBENTRYP_L ) sqlmixSkipRaw,
|
|
( DBENTRYP_VF ) NULL, /* sqlmixAddField */
|
|
( DBENTRYP_B ) NULL, /* sqlmixAppend */
|
|
( DBENTRYP_I ) NULL, /* sqlmixCreateFields */
|
|
( DBENTRYP_V ) NULL, /* sqlmixDeleteRec */
|
|
( DBENTRYP_BP ) NULL, /* sqlmixDeleted */
|
|
( DBENTRYP_SP ) NULL, /* sqlmixFieldCount */
|
|
( DBENTRYP_VF ) NULL, /* sqlmixFieldDisplay */
|
|
( DBENTRYP_SSI ) NULL, /* sqlmixFieldInfo */
|
|
( DBENTRYP_SVP ) NULL, /* sqlmixFieldName */
|
|
( DBENTRYP_V ) NULL, /* sqlmixFlush */
|
|
( DBENTRYP_PP ) NULL, /* sqlmixGetRec */
|
|
( DBENTRYP_SI ) NULL, /* sqlmixGetValue */
|
|
( DBENTRYP_SVL ) NULL, /* sqlmixGetVarLen */
|
|
( DBENTRYP_V ) sqlmixGoCold,
|
|
( DBENTRYP_V ) sqlmixGoHot,
|
|
( DBENTRYP_P ) NULL, /* sqlmixPutRec */
|
|
( DBENTRYP_SI ) NULL, /* sqlmixPutValue */
|
|
( DBENTRYP_V ) NULL, /* sqlmixRecall */
|
|
( DBENTRYP_ULP ) NULL, /* sqlmixRecCount */
|
|
( DBENTRYP_ISI ) NULL, /* sqlmixRecInfo */
|
|
( DBENTRYP_ULP ) NULL, /* sqlmixRecNo */
|
|
( DBENTRYP_I ) NULL, /* sqlmixRecId */
|
|
( DBENTRYP_S ) NULL, /* sqlmixSetFieldExtent */
|
|
( DBENTRYP_P ) NULL, /* sqlmixAlias */
|
|
( DBENTRYP_V ) sqlmixClose,
|
|
( DBENTRYP_VP ) NULL, /* sqlmixCreate */
|
|
( DBENTRYP_SI ) NULL, /* sqlmixInfo */
|
|
( DBENTRYP_V ) NULL, /* sqlmixNewArea */
|
|
( DBENTRYP_VP ) NULL, /* sqlmixOpen */
|
|
( DBENTRYP_V ) NULL, /* sqlmixRelease */
|
|
( DBENTRYP_SP ) sqlmixStructSize,
|
|
( DBENTRYP_P ) NULL, /* sqlmixSysName */
|
|
( DBENTRYP_VEI ) NULL, /* sqlmixEval */
|
|
( DBENTRYP_V ) NULL, /* sqlmixPack */
|
|
( DBENTRYP_LSP ) NULL, /* sqlmixPackRec */
|
|
( DBENTRYP_VS ) NULL, /* sqlmixSort */
|
|
( DBENTRYP_VT ) NULL, /* sqlmixTrans */
|
|
( DBENTRYP_VT ) NULL, /* sqlmixTransRec */
|
|
( DBENTRYP_V ) NULL, /* sqlmixZap */
|
|
( DBENTRYP_VR ) NULL, /* sqlmixChildEnd */
|
|
( DBENTRYP_VR ) NULL, /* sqlmixChildStart */
|
|
( DBENTRYP_VR ) NULL, /* sqlmixChildSync */
|
|
( DBENTRYP_V ) NULL, /* sqlmixSyncChildren */
|
|
( DBENTRYP_V ) NULL, /* sqlmixClearRel */
|
|
( DBENTRYP_V ) NULL, /* sqlmixForceRel */
|
|
( DBENTRYP_SVP ) NULL, /* sqlmixRelArea */
|
|
( DBENTRYP_VR ) NULL, /* sqlmixRelEval */
|
|
( DBENTRYP_SVP ) NULL, /* sqlmixRelText */
|
|
( DBENTRYP_VR ) NULL, /* sqlmixSetRel */
|
|
( DBENTRYP_OI ) NULL, /* sqlmixOrderListAdd */
|
|
( DBENTRYP_V ) sqlmixOrderListClear,
|
|
( DBENTRYP_OI ) NULL, /* sqlmixOrderListDelete */
|
|
( DBENTRYP_OI ) sqlmixOrderListFocus,
|
|
( DBENTRYP_V ) NULL, /* sqlmixOrderListRebuild */
|
|
( DBENTRYP_VOI ) NULL, /* sqlmixOrderCondition */
|
|
( DBENTRYP_VOC ) sqlmixOrderCreate,
|
|
( DBENTRYP_OI ) NULL, /* sqlmixOrderDestroy */
|
|
( DBENTRYP_OII ) sqlmixOrderInfo,
|
|
( DBENTRYP_V ) NULL, /* sqlmixClearFilter */
|
|
( DBENTRYP_V ) NULL, /* sqlmixClearLocate */
|
|
( DBENTRYP_V ) NULL, /* sqlmixClearScope */
|
|
( DBENTRYP_VPLP ) NULL, /* sqlmixCountScope */
|
|
( DBENTRYP_I ) NULL, /* sqlmixFilterText */
|
|
( DBENTRYP_SI ) NULL, /* sqlmixScopeInfo */
|
|
( DBENTRYP_VFI ) NULL, /* sqlmixSetFilter */
|
|
( DBENTRYP_VLO ) NULL, /* sqlmixSetLocate */
|
|
( DBENTRYP_VOS ) NULL, /* sqlmixSetScope */
|
|
( DBENTRYP_VPL ) NULL, /* sqlmixSkipScope */
|
|
( DBENTRYP_B ) NULL, /* sqlmixLocate */
|
|
( DBENTRYP_P ) NULL, /* sqlmixCompile */
|
|
( DBENTRYP_I ) NULL, /* sqlmixError */
|
|
( DBENTRYP_I ) NULL, /* sqlmixEvalBlock */
|
|
( DBENTRYP_VSP ) NULL, /* sqlmixRawLock */
|
|
( DBENTRYP_VL ) NULL, /* sqlmixLock */
|
|
( DBENTRYP_I ) NULL, /* sqlmixUnLock */
|
|
( DBENTRYP_V ) NULL, /* sqlmixCloseMemFile */
|
|
( DBENTRYP_VP ) NULL, /* sqlmixCreateMemFile */
|
|
( DBENTRYP_SVPB ) NULL, /* sqlmixGetValueFile */
|
|
( DBENTRYP_VP ) NULL, /* sqlmixOpenMemFile */
|
|
( DBENTRYP_SVPB ) NULL, /* sqlmixPutValueFile */
|
|
( DBENTRYP_V ) NULL, /* sqlmixReadDBHeader */
|
|
( DBENTRYP_V ) NULL, /* sqlmixWriteDBHeader */
|
|
( DBENTRYP_R ) NULL, /* sqlmixInit */
|
|
( DBENTRYP_R ) sqlmixExit,
|
|
( DBENTRYP_RVVL) NULL, /* sqlmixDrop */
|
|
( DBENTRYP_RVVL) NULL, /* sqlmixExists */
|
|
( DBENTRYP_RSLV ) NULL, /* sqlmixRddInfo */
|
|
( DBENTRYP_SVP ) NULL, /* sqlmixWhoCares */
|
|
};
|
|
|
|
|
|
HB_FUNC( SQLMIX_GETFUNCTABLE )
|
|
{
|
|
RDDFUNCS * pTable;
|
|
USHORT * uiCount, uiRddId;
|
|
|
|
uiCount = ( USHORT * ) hb_itemGetPtr( hb_param( 1, HB_IT_POINTER ) );
|
|
* uiCount = RDDFUNCSCOUNT;
|
|
pTable = ( RDDFUNCS * ) hb_itemGetPtr( hb_param( 2, HB_IT_POINTER ) );
|
|
uiRddId = ( USHORT ) hb_parni( 4 );
|
|
|
|
if ( pTable )
|
|
{
|
|
HB_ERRCODE errCode;
|
|
|
|
errCode = hb_rddInherit( pTable, &sqlmixTable, &sqlmixSuper, "SQLBASE" );
|
|
if ( errCode == HB_SUCCESS )
|
|
{
|
|
s_uiRddIdSQLMIX = uiRddId;
|
|
}
|
|
hb_retni( errCode );
|
|
}
|
|
else
|
|
{
|
|
hb_retni( HB_FAILURE );
|
|
}
|
|
}
|
|
|
|
|
|
HB_FUNC( SQLMIX ) { ; }
|
|
|
|
|
|
#define __PRG_SOURCE__ __FILE__
|
|
|
|
#ifdef HB_PCODE_VER
|
|
#undef HB_PRG_PCODE_VER
|
|
#define HB_PRG_PCODE_VER HB_PCODE_VER
|
|
#endif
|
|
|
|
|
|
HB_FUNC_EXTERN( SQLBASE );
|
|
|
|
|
|
static void hb_sqlmixRddInit( void * cargo )
|
|
{
|
|
HB_SYMBOL_UNUSED( cargo );
|
|
|
|
if ( hb_rddRegister( "SQLMIX", RDT_FULL ) > 1 )
|
|
{
|
|
/* try different RDD registrer order */
|
|
hb_rddRegister( "SQLBASE", RDT_FULL );
|
|
|
|
if ( hb_rddRegister( "SQLMIX", RDT_FULL ) > 1 )
|
|
{
|
|
hb_errInternal( HB_EI_RDDINVALID, NULL, NULL, NULL );
|
|
HB_FUNC_EXEC( SQLBASE ); /* force SQLBASE linking */
|
|
}
|
|
}
|
|
}
|
|
|
|
HB_INIT_SYMBOLS_BEGIN( sqlmix__InitSymbols )
|
|
{ "SQLMIX", {HB_FS_PUBLIC|HB_FS_LOCAL}, {HB_FUNCNAME( SQLMIX )}, NULL },
|
|
{ "SQLMIX_GETFUNCTABLE", {HB_FS_PUBLIC|HB_FS_LOCAL}, {HB_FUNCNAME( SQLMIX_GETFUNCTABLE )}, NULL }
|
|
HB_INIT_SYMBOLS_END( sqlmix__InitSymbols )
|
|
|
|
HB_CALL_ON_STARTUP_BEGIN( _hb_sqlmix_rdd_init_ )
|
|
hb_vmAtInit( hb_sqlmixRddInit, NULL );
|
|
HB_CALL_ON_STARTUP_END( _hb_sqlmix_rdd_init_ )
|
|
|
|
#if defined( HB_PRAGMA_STARTUP )
|
|
#pragma startup sqlmix__InitSymbols
|
|
#pragma startup _hb_sqlmix_rdd_init_
|
|
#elif defined( HB_MSC_STARTUP )
|
|
#if defined( HB_OS_WIN_64 )
|
|
#pragma section( HB_MSC_START_SEGMENT, long, read )
|
|
#endif
|
|
#pragma data_seg( HB_MSC_START_SEGMENT )
|
|
static HB_$INITSYM hb_vm_auto_sqlmix__InitSymbols = sqlmix__InitSymbols;
|
|
static HB_$INITSYM hb_vm_auto_sqlmix_rdd_init = _hb_sqlmix_rdd_init_;
|
|
#pragma data_seg()
|
|
#endif
|