1313 lines
45 KiB
C
Executable File
1313 lines
45 KiB
C
Executable File
/* i4remove.c (c)Copyright Sequiter Software Inc., 1988-1996. All rights reserved. */
|
|
|
|
#include "d4all.h"
|
|
#ifndef S4UNIX
|
|
#ifdef __TURBOC__
|
|
#pragma hdrstop
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef S4CLIENT
|
|
#ifndef S4OFF_WRITE
|
|
#ifndef S4INDEX_OFF
|
|
|
|
int tfile4remove( TAG4FILE *t4, const unsigned char *ptr, const long rec )
|
|
{
|
|
int rc ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( t4 == 0 )
|
|
return error4( 0, e4parm_null, E95404 ) ;
|
|
#endif
|
|
|
|
rc = tfile4go( t4, ptr, rec, 0 ) ; /* returns -1 if error4code( codeBase ) < 0 */
|
|
if ( rc < 0 )
|
|
return error4stack( t4->codeBase, rc, E95404 ) ;
|
|
if ( rc )
|
|
return r4entry ;
|
|
|
|
return tfile4removeCurrent( t4 ) ;
|
|
}
|
|
|
|
int tfile4removeCalc( TAG4FILE *t4, long rec )
|
|
{
|
|
unsigned char *ptr ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( t4 == 0 )
|
|
return error4( 0, e4parm_null, E95405 ) ;
|
|
#endif
|
|
|
|
if ( error4code( t4->codeBase ) < 0 )
|
|
return e4codeBase ;
|
|
|
|
tfile4exprKey( t4, &ptr ) ;
|
|
return tfile4remove( t4, ptr, rec ) ;
|
|
}
|
|
|
|
#ifndef N4OTHER
|
|
|
|
#ifdef S4FOX
|
|
/* remove the (current) branch block */
|
|
int tfile4removeBranch( TAG4FILE *t4, B4BLOCK *blockOn )
|
|
{
|
|
long lNode, rNode ;
|
|
INDEX4FILE *i4 ;
|
|
#ifdef S4BYTE_SWAP
|
|
char *swapPtr ;
|
|
S4LONG longVal ;
|
|
short shortVal ;
|
|
int i ;
|
|
#endif
|
|
|
|
i4 = t4->indexFile ;
|
|
|
|
if ( blockOn == (B4BLOCK *)l4first( &t4->blocks ) )
|
|
{
|
|
/* Root Block, do not delete */
|
|
#ifdef E4ANALYZE
|
|
if ( blockOn->header.leftNode != -1 || blockOn->header.rightNode != -1 || blockOn->header.nKeys != 1 )
|
|
return error4describe( t4->codeBase, e4info, E80401, tfile4alias( t4 ), i4->file.name, 0 ) ;
|
|
#endif
|
|
memset( blockOn->data, 0, B4BLOCK_SIZE - sizeof(B4STD_HEADER) - sizeof(B4NODE_HEADER) ) ;
|
|
if ( !b4leaf( blockOn ) ) /* if not a leaf, then reset nodeHdr too */
|
|
{
|
|
memset( (void *)&blockOn->nodeHdr, 0, sizeof(B4NODE_HEADER) ) ;
|
|
b4leafInit( blockOn ) ;
|
|
}
|
|
else
|
|
blockOn->nodeHdr.freeSpace = B4BLOCK_SIZE - sizeof( B4STD_HEADER ) - sizeof( B4NODE_HEADER ) ;
|
|
blockOn->header.nKeys = 0 ;
|
|
blockOn->header.leftNode = -1 ;
|
|
blockOn->header.rightNode = -1 ;
|
|
blockOn->keyOn = -1 ;
|
|
blockOn->builtOn = -1 ;
|
|
blockOn->header.nodeAttribute = 3 ; /* root and leaf */
|
|
blockOn->changed = 1 ;
|
|
}
|
|
else /* This block is to be deleted */
|
|
{
|
|
lNode = blockOn->header.leftNode ;
|
|
rNode = blockOn->header.rightNode ;
|
|
l4remove( &t4->blocks, blockOn ) ;
|
|
if ( index4shrink( i4, blockOn->fileBlock ) < 0 )
|
|
return 0 ;
|
|
blockOn->changed = 0 ;
|
|
|
|
if ( lNode != -1L )
|
|
{
|
|
if ( file4readAll( &i4->file, I4MULTIPLY*lNode, &blockOn->header, B4BLOCK_SIZE) < 0 )
|
|
return 0 ;
|
|
|
|
#ifdef S4BYTE_SWAP
|
|
blockOn->header.nodeAttribute = x4reverseShort( (void *)&blockOn->header.nodeAttribute ) ;
|
|
blockOn->header.nKeys = x4reverseShort( (void *)&blockOn->header.nKeys ) ;
|
|
blockOn->header.leftNode = x4reverseLong( (void *)&blockOn->header.leftNode ) ;
|
|
blockOn->header.rightNode = x4reverseLong( (void *)&blockOn->header.rightNode ) ;
|
|
|
|
/* if block is a leaf */
|
|
if (blockOn->header.nodeAttribute >= 2 )
|
|
{
|
|
blockOn->nodeHdr.freeSpace = x4reverseShort( (void *)&blockOn->nodeHdr.freeSpace ) ;
|
|
longVal = x4reverseLong( (void *)&blockOn->nodeHdr.recNumMask[0] ) ;
|
|
memcpy( (void *)&blockOn->nodeHdr.recNumMask[0], (void *)&longVal, sizeof(long) ) ;
|
|
}
|
|
else /* if block is a branch */
|
|
{
|
|
shortVal = blockOn->tag->header.keyLen + sizeof(S4LONG) ;
|
|
/* position swapPtr to end of first key expression */
|
|
swapPtr = (char *) &blockOn->nodeHdr.freeSpace + blockOn->tag->header.keyLen ;
|
|
|
|
/* move through all B4KEY's to swap 'long's */
|
|
for ( i = 0 ; i < (int) blockOn->header.nKeys ; i++ )
|
|
{
|
|
longVal = x4reverseLong( (void *)swapPtr ) ;
|
|
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
|
|
swapPtr += sizeof(S4LONG) ;
|
|
longVal = x4reverseLong( (void *)swapPtr ) ;
|
|
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
|
|
swapPtr += shortVal ;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
blockOn->fileBlock = lNode ;
|
|
blockOn->header.rightNode = rNode ;
|
|
blockOn->changed = 1 ;
|
|
b4flush( blockOn ) ;
|
|
}
|
|
|
|
if ( rNode != -1L )
|
|
{
|
|
if ( file4readAll( &i4->file, I4MULTIPLY*rNode, &blockOn->header, B4BLOCK_SIZE) < 0 )
|
|
return 0 ;
|
|
|
|
#ifdef S4BYTE_SWAP
|
|
blockOn->header.nodeAttribute = x4reverseShort( (void *)&blockOn->header.nodeAttribute ) ;
|
|
blockOn->header.nKeys = x4reverseShort( (void *)&blockOn->header.nKeys ) ;
|
|
blockOn->header.leftNode = x4reverseLong( (void *)&blockOn->header.leftNode ) ;
|
|
blockOn->header.rightNode = x4reverseLong( (void *)&blockOn->header.rightNode ) ;
|
|
|
|
/* if block is a leaf */
|
|
if (blockOn->header.nodeAttribute >= 2 )
|
|
{
|
|
blockOn->nodeHdr.freeSpace = x4reverseShort( (void *)&blockOn->nodeHdr.freeSpace ) ;
|
|
longVal = x4reverseLong( (void *)blockOn->nodeHdr.recNumMask ) ;
|
|
memcpy( (void *)blockOn->nodeHdr.recNumMask, (void *)&longVal, sizeof(long) ) ;
|
|
}
|
|
else /* if block is a branch */
|
|
{
|
|
shortVal = blockOn->tag->header.keyLen + sizeof(S4LONG) ;
|
|
/* position swapPtr to end of first key expression */
|
|
swapPtr = (char *) &blockOn->nodeHdr.freeSpace + blockOn->tag->header.keyLen ;
|
|
|
|
/* move through all B4KEY's to swap 'long's */
|
|
for ( i = 0 ; i < (int) blockOn->header.nKeys ; i++ )
|
|
{
|
|
longVal = x4reverseLong( (void *)swapPtr ) ;
|
|
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
|
|
swapPtr += sizeof(S4LONG) ;
|
|
longVal = x4reverseLong( (void *)swapPtr ) ;
|
|
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
|
|
swapPtr += shortVal ;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
blockOn->fileBlock = rNode ;
|
|
blockOn->header.leftNode = lNode ;
|
|
blockOn->changed = 1 ;
|
|
b4flush( blockOn ) ;
|
|
}
|
|
|
|
return b4free( blockOn ) ;
|
|
}
|
|
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
/* Remove the current key */
|
|
int tfile4removeCurrent( TAG4FILE *t4 )
|
|
{
|
|
B4BLOCK *blockOn ;
|
|
INDEX4FILE *i4 ;
|
|
#ifdef S4FOX
|
|
void *newKeyInfo ;
|
|
long rec = 0L ;
|
|
int blRemoved, lessThanLast ;
|
|
#else
|
|
int removeDone, updateReqd ;
|
|
B4BLOCK *blockIterate ;
|
|
#endif
|
|
|
|
i4 = t4->indexFile ;
|
|
|
|
#ifdef S4FOX
|
|
i4->tagIndex->header.version = i4->versionOld+1 ;
|
|
newKeyInfo = 0 ;
|
|
|
|
for ( blockOn = (B4BLOCK *)t4->blocks.lastNode ; blockOn ; )
|
|
{
|
|
blRemoved = 0 ;
|
|
if ( newKeyInfo == 0 ) /* then delete entry */
|
|
{
|
|
if ( b4lastpos( blockOn ) == 0 )
|
|
{
|
|
if ( blockOn != (B4BLOCK *)l4first( &t4->blocks ) )
|
|
blRemoved = 1 ;
|
|
tfile4removeBranch( t4, blockOn ) ;
|
|
blockOn = (B4BLOCK *)t4->blocks.lastNode ;
|
|
}
|
|
else
|
|
{
|
|
lessThanLast = 0 ;
|
|
if ( blockOn->keyOn < b4lastpos( blockOn ) )
|
|
lessThanLast = 1 ;
|
|
b4remove( blockOn ) ;
|
|
if ( lessThanLast )
|
|
return 0 ;
|
|
|
|
/* On last entry */
|
|
b4goEof( blockOn ) ;
|
|
blockOn->keyOn-- ; /* update keyOn for goint to last spot */
|
|
newKeyInfo = b4keyKey( blockOn, blockOn->keyOn ) ;
|
|
rec = b4recNo( blockOn, blockOn->keyOn ) ;
|
|
}
|
|
}
|
|
else /* Adjust entry */
|
|
{
|
|
if ( b4brReplace( blockOn, (unsigned char *)newKeyInfo, rec ) < 0 )
|
|
return -1 ;
|
|
if ( blockOn->keyOn != b4lastpos( blockOn ) ) /* not on end key, so exit, else continue */
|
|
return 0 ;
|
|
}
|
|
|
|
if ( !blRemoved )
|
|
{
|
|
blockOn = (B4BLOCK *)blockOn->link.p ;
|
|
if ( blockOn == (B4BLOCK *)t4->blocks.lastNode )
|
|
break ;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef S4MDX
|
|
removeDone = 0 ;
|
|
updateReqd = 0 ;
|
|
i4->changed = 1 ;
|
|
t4->changed = 1 ;
|
|
t4->header.version++ ;
|
|
|
|
blockIterate = (B4BLOCK *)l4last( &t4->blocks ) ;
|
|
for ( ;; )
|
|
{
|
|
blockOn = blockIterate ;
|
|
if ( blockOn == 0 )
|
|
break ;
|
|
blockIterate = (B4BLOCK *)l4prev( &t4->blocks, blockIterate ) ; /* Calculate the previous block while the current block exists. */
|
|
|
|
if ( !removeDone ) /* either removing or else updating */
|
|
{
|
|
if ( b4lastpos( blockOn ) == 0 ) /* delete block */
|
|
{
|
|
if ( blockOn == (B4BLOCK *)l4first( &t4->blocks ) ) /* root block, don't delete */
|
|
{
|
|
blockOn->changed = 1 ;
|
|
blockOn->keyOn = 0 ;
|
|
memset( (void *)&blockOn->nKeys, 0, i4->header.blockRw ) ;
|
|
if (t4->filter ) /* must modify the filter setting for dBASE IV compatibility */
|
|
{
|
|
file4write( &t4->indexFile->file, t4->headerOffset+sizeof(t4->header)+222, (char *)"\0", (int)1 ) ;
|
|
t4->hasKeys = 0 ;
|
|
#ifdef S4MDX
|
|
t4->hadKeys = 1 ;
|
|
#endif
|
|
}
|
|
return 0 ;
|
|
}
|
|
else
|
|
{
|
|
l4remove( &t4->blocks, blockOn ) ;
|
|
if ( index4shrink( i4, blockOn->fileBlock) < 0 )
|
|
return -1 ;
|
|
b4free( blockOn ) ;
|
|
blockOn = 0 ;
|
|
}
|
|
}
|
|
else /* just remove entry */
|
|
{
|
|
if ( blockIterate && blockOn->keyOn == b4lastpos( blockOn ) && b4lastpos( blockOn ) > 0 ) /* save to become last key of the block for parent update */
|
|
{
|
|
memcpy( t4->codeBase->savedKey, b4keyKey( blockOn, blockOn->nKeys - 1 - b4leaf(blockOn) ), t4->header.keyLen ) ;
|
|
updateReqd = 1 ;
|
|
}
|
|
else
|
|
updateReqd = 0 ;
|
|
|
|
b4remove( blockOn ) ;
|
|
if ( !b4leaf( blockOn ) && b4lastpos( blockOn ) == 0 ) /* branch with only one entry, so have the entry take place of this block */
|
|
{
|
|
if (blockOn == (B4BLOCK *)l4first( &t4->blocks ) ) /* the entry becomes the new root */
|
|
{
|
|
/* first update the tags root */
|
|
t4->header.root = b4key( blockOn, 0 )->num ;
|
|
#ifdef S4BYTE_SWAP
|
|
t4->header.root = x4reverseLong( (void *)&t4->header.root ) ;
|
|
#endif
|
|
file4write( &t4->indexFile->file, t4->headerOffset, (void *)&t4->header.root, sizeof(t4->header.root) ) ;
|
|
#ifdef S4BYTE_SWAP
|
|
t4->header.root = x4reverseLong( (void *)&t4->header.root ) ;
|
|
#endif
|
|
updateReqd = 0 ;
|
|
}
|
|
else /* remove this branch block */
|
|
{
|
|
blockIterate->changed = 1 ;
|
|
b4key( blockIterate, blockIterate->keyOn )->num = b4key( blockOn, 0 )->num ;
|
|
}
|
|
l4remove( &t4->blocks, blockOn ) ;
|
|
if ( index4shrink( t4->indexFile, blockOn->fileBlock) < 0 )
|
|
return -1 ;
|
|
blockOn->changed = 0 ;
|
|
b4free( blockOn ) ;
|
|
blockOn = 0 ;
|
|
}
|
|
else
|
|
blockOn->keyOn = b4lastpos( blockOn ) ;
|
|
|
|
if ( !updateReqd )
|
|
return 0 ;
|
|
removeDone = 1 ;
|
|
}
|
|
}
|
|
else /* Adjust entry - at most one update will be required in MDX */
|
|
{
|
|
if ( blockOn->keyOn < b4lastpos( blockOn ) )
|
|
{
|
|
blockOn->changed = 1 ;
|
|
memcpy( b4keyKey( blockOn, blockOn->keyOn), t4->codeBase->savedKey, t4->header.keyLen ) ;
|
|
return 0 ;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
#endif /* ifndef N4OTHER */
|
|
|
|
#ifdef S4CLIPPER
|
|
int tfile4balanceBranch( TAG4FILE *, B4BLOCK * ) ;
|
|
|
|
static int tfile4removeRef( TAG4FILE *t4 )
|
|
{
|
|
B4KEY_DATA *myKeyData ;
|
|
B4BLOCK *blockOn, *blockUp, *neighborBlock ;
|
|
long reference, neighborRef ;
|
|
int i, rc ;
|
|
|
|
blockOn = (B4BLOCK *)t4->blocks.lastNode ;
|
|
|
|
tfile4up( t4 ) ;
|
|
blockUp = (B4BLOCK *)t4->blocks.lastNode ;
|
|
|
|
if ( blockUp == 0 ) /* root block only, so reference doesn't exist */
|
|
{
|
|
/* reset the block */
|
|
short offset = ( t4->header.keysMax + 2 + ( (t4->header.keysMax/2)*2 != t4->header.keysMax ) ) * sizeof(short) ;
|
|
for ( i = 0 ; i <= t4->header.keysMax ; i++ )
|
|
blockOn->pointers[i] = (short)( t4->header.groupLen * i ) + offset ;
|
|
return 0 ;
|
|
}
|
|
else /* delete the block */
|
|
{
|
|
tfile4shrink( t4, blockOn->fileBlock ) ;
|
|
l4pop( &t4->saved ) ;
|
|
blockOn->changed = 0 ;
|
|
b4free( blockOn ) ;
|
|
blockOn = 0 ;
|
|
}
|
|
blockOn = blockUp ;
|
|
|
|
myKeyData = (B4KEY_DATA *)u4allocEr( t4->codeBase, t4->header.groupLen ) ;
|
|
if ( myKeyData == 0 )
|
|
return e4memory ;
|
|
if ( blockOn->keyOn >= blockOn->nKeys )
|
|
memcpy( &(myKeyData->num), &( b4key( blockOn, blockOn->keyOn - 1 )->num), sizeof(long) + t4->header.keyLen ) ;
|
|
else
|
|
memcpy( &(myKeyData->num), &( b4key( blockOn, blockOn->keyOn )->num), sizeof(long) + t4->header.keyLen ) ;
|
|
|
|
if ( blockOn->nKeys == 1 )
|
|
{
|
|
/* take the branch, and put in place of me, then delete and add me */
|
|
if ( blockOn->keyOn >= blockOn->nKeys )
|
|
reference = (long)b4key( blockOn, 0 )->pointer ;
|
|
else
|
|
reference = (long)b4key( blockOn, 1 )->pointer ;
|
|
b4remove( blockOn ) ;
|
|
if ( t4->blocks.nLink == 1 ) /* root block, so reference will take over */
|
|
{
|
|
tfile4shrink( t4, blockOn->fileBlock ) ;
|
|
tfile4up( t4 ) ;
|
|
l4pop(&t4->saved ) ;
|
|
blockOn->changed = 0 ;
|
|
b4free( blockOn ) ;
|
|
blockOn = (B4BLOCK *)t4->blocks.lastNode ;
|
|
t4->header.root = reference ;
|
|
}
|
|
else /* special case -- blocks contain very large keys. try balancing */
|
|
{
|
|
tfile4up( t4 ) ;
|
|
blockUp = (B4BLOCK *)t4->blocks.lastNode ;
|
|
if ( blockUp->keyOn == 0 )
|
|
{
|
|
/* move one right neighbour into left */
|
|
neighborRef = (long)b4key( blockUp, 1 )->pointer ;
|
|
neighborBlock = b4alloc( t4, neighborRef ) ;
|
|
if ( neighborBlock == 0 )
|
|
{
|
|
u4free( myKeyData ) ;
|
|
return e4memory ;
|
|
}
|
|
if ( i4readBlock( &t4->file, neighborRef, 0, neighborBlock ) < 0 )
|
|
{
|
|
b4free( neighborBlock ) ;
|
|
neighborBlock = 0 ;
|
|
u4free( myKeyData ) ;
|
|
return -1 ;
|
|
}
|
|
if ( neighborBlock->nKeys == t4->header.keysMax ) /* already maxed out, must shift */
|
|
{
|
|
/* borrow for the current block */
|
|
reference = b4key( blockOn, 0 )->pointer ;
|
|
blockOn->keyOn = 0 ;
|
|
b4insert( blockOn, b4keyKey( blockUp, 0 ), b4recNo( blockUp, 0 ), reference / 512 ) ;
|
|
memcpy( b4keyKey( blockUp, 0 ), b4keyKey( neighborBlock, 0 ), t4->header.keyLen ) ;
|
|
b4key( blockUp, 0 )->num = b4key( neighborBlock, 0 )->num ;
|
|
b4key( blockOn, 1 )->pointer = b4key( neighborBlock, 0 )->pointer ;
|
|
neighborBlock->keyOn = 0 ;
|
|
b4remove( neighborBlock ) ;
|
|
blockUp->changed = 1 ;
|
|
blockOn->changed = 1 ;
|
|
neighborBlock->changed = 1 ;
|
|
b4flush( neighborBlock ) ;
|
|
b4free( neighborBlock ) ;
|
|
neighborBlock = 0 ;
|
|
}
|
|
else
|
|
{
|
|
/* move current reference over, and delete from parent */
|
|
neighborBlock->keyOn = 0 ;
|
|
b4insert( neighborBlock, b4keyKey( blockUp, blockUp->keyOn ), b4key( blockUp, blockUp->keyOn )->num, b4key( blockOn, 0 )->pointer / 512 ) ;
|
|
b4remove( blockUp ) ;
|
|
#ifdef E4INDEX_VERIFY
|
|
if ( (B4BLOCK *)t4->saved.lastNode != blockOn )
|
|
return error4( t4->codeBase, e4index, E81601 ) ;
|
|
#endif
|
|
l4pop( &t4->saved ) ;
|
|
blockOn->changed = 0 ;
|
|
tfile4shrink( t4, blockOn->fileBlock ) ;
|
|
b4free( blockOn ) ;
|
|
blockOn = 0 ;
|
|
blockUp->changed = 1 ;
|
|
neighborBlock->changed = 1 ;
|
|
|
|
/* now check that parent is still valid */
|
|
if ( blockUp->nKeys == 0 ) /* just removed last entry... */
|
|
{
|
|
if ( t4->header.root == blockUp->fileBlock * 512 )
|
|
{
|
|
tfile4shrink( t4, blockUp->fileBlock ) ;
|
|
l4pop(&t4->blocks ) ; /* remov ourselves */
|
|
reference = (long)b4key( blockUp, 0 )->pointer ;
|
|
blockUp->changed = 0 ;
|
|
b4free( blockUp ) ;
|
|
blockOn = 0 ;
|
|
l4add( &t4->blocks, neighborBlock ) ;
|
|
t4->header.root = reference ;
|
|
}
|
|
else
|
|
{
|
|
b4flush( neighborBlock ) ;
|
|
b4free( neighborBlock ) ;
|
|
neighborBlock = 0 ;
|
|
tfile4balanceBranch( t4, blockUp ) ;
|
|
}
|
|
}
|
|
else /* save and free */
|
|
{
|
|
b4flush( neighborBlock ) ;
|
|
b4free( neighborBlock ) ;
|
|
neighborBlock = 0 ;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* move to left neighbor */
|
|
neighborRef = (long)b4key( blockUp, blockUp->keyOn - 1 )->pointer ;
|
|
neighborBlock = b4alloc( t4, neighborRef ) ;
|
|
if ( neighborBlock == 0 )
|
|
{
|
|
u4free( myKeyData ) ;
|
|
return e4memory ;
|
|
}
|
|
if ( i4readBlock( &t4->file, neighborRef, 0, neighborBlock ) < 0 )
|
|
{
|
|
b4free( neighborBlock ) ;
|
|
neighborBlock = 0 ;
|
|
u4free( myKeyData ) ;
|
|
return -1 ;
|
|
}
|
|
if ( neighborBlock->nKeys == t4->header.keysMax ) /* already maxed out */
|
|
{
|
|
/* borrow for the current block */
|
|
blockOn->keyOn = 0 ;
|
|
reference = b4key( blockOn, 0 )->pointer ;
|
|
b4insert( blockOn, b4keyKey( blockUp, blockUp->keyOn - 1 ), b4key( blockUp, blockUp->keyOn - 1 )->num, b4key( neighborBlock, neighborBlock->nKeys )->pointer / 512 ) ;
|
|
memcpy( b4keyKey( blockUp, blockUp->keyOn - 1 ), b4keyKey( neighborBlock, neighborBlock->nKeys - 1 ), t4->header.keyLen ) ;
|
|
b4key( blockUp, blockUp->keyOn - 1 )->num = b4key( neighborBlock, neighborBlock->nKeys - 1 )->num ;
|
|
b4key( blockOn, 1 )->pointer = reference ;
|
|
neighborBlock->nKeys-- ;
|
|
blockUp->changed = 1 ;
|
|
blockOn->changed = 1 ;
|
|
neighborBlock->changed = 1 ;
|
|
b4flush( neighborBlock ) ;
|
|
b4free( neighborBlock ) ;
|
|
neighborBlock = 0 ;
|
|
}
|
|
else
|
|
{
|
|
/* move current reference over, and delete from parent */
|
|
neighborBlock->keyOn = neighborBlock->nKeys ;
|
|
/* just re-insert the last key, then change the values */
|
|
b4insert( neighborBlock, b4keyKey( neighborBlock, neighborBlock->keyOn - 1 ),
|
|
b4key( neighborBlock, neighborBlock->keyOn - 1 )->num,
|
|
b4key( neighborBlock, neighborBlock->keyOn )->pointer / 512 ) ;
|
|
|
|
memcpy( b4keyKey( neighborBlock, neighborBlock->nKeys - 1 ), b4keyKey( blockUp, blockUp->keyOn - 1 ), t4->header.keyLen ) ;
|
|
b4key( neighborBlock, neighborBlock->nKeys - 1 )->num = b4key( blockUp, blockUp->keyOn - 1 )->num ;
|
|
b4key( neighborBlock, neighborBlock->nKeys )->pointer = b4key( blockOn, 0 )->pointer ;
|
|
#ifdef E4INDEX_VERIFY
|
|
if ( (B4BLOCK *)t4->saved.lastNode != blockOn )
|
|
return error4( t4->codeBase, e4index, E81601 ) ;
|
|
#endif
|
|
l4pop( &t4->saved ) ;
|
|
blockOn->changed = 0 ;
|
|
tfile4shrink( t4, blockOn->fileBlock ) ;
|
|
b4free( blockOn ) ;
|
|
blockOn = 0 ;
|
|
b4key( blockUp, blockUp->keyOn )->pointer = b4key( blockUp, blockUp->keyOn - 1 )->pointer ;
|
|
blockUp->keyOn-- ;
|
|
b4remove( blockUp ) ;
|
|
blockUp->changed = 1 ;
|
|
neighborBlock->changed = 1 ;
|
|
|
|
/* now check that parent is still valid */
|
|
if ( blockUp->nKeys == 0 ) /* just removed last entry... */
|
|
{
|
|
if ( t4->header.root == blockUp->fileBlock * 512 )
|
|
{
|
|
reference = (long)b4key( blockUp, 0 )->pointer ;
|
|
tfile4shrink( t4, blockUp->fileBlock ) ;
|
|
l4pop(&t4->blocks ) ; /* remov ourselves */
|
|
blockUp->changed = 0 ;
|
|
b4free( blockUp ) ;
|
|
blockUp = 0 ;
|
|
l4add( &t4->blocks, neighborBlock ) ;
|
|
t4->header.root = reference ;
|
|
}
|
|
else
|
|
{
|
|
b4flush( neighborBlock ) ;
|
|
b4free( neighborBlock ) ;
|
|
neighborBlock = 0 ;
|
|
tfile4balanceBranch( t4, blockUp ) ;
|
|
}
|
|
}
|
|
else /* save and free */
|
|
{
|
|
b4flush( neighborBlock ) ;
|
|
b4free( neighborBlock ) ;
|
|
neighborBlock = 0 ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else /* just remove myself, add later */
|
|
{
|
|
b4remove( blockOn ) ;
|
|
if ( blockOn->nKeys < t4->header.keysHalf && blockOn->fileBlock != t4->header.root ) /* if not root may have to balance the tree */
|
|
{
|
|
if ( tfile4balanceBranch( t4, blockOn ) < 0 )
|
|
{
|
|
u4free( myKeyData ) ;
|
|
return -1 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* now add the removed reference back into the index */
|
|
rc = tfile4add( t4, (unsigned char *)myKeyData->value, myKeyData->num, 0 ) ;
|
|
|
|
u4free( myKeyData ) ;
|
|
|
|
return rc ;
|
|
}
|
|
|
|
static int tfile4balanceBlock( TAG4FILE *t4, B4BLOCK *parent, B4BLOCK *b4, B4BLOCK *b4temp, char isRight, char balanceMode )
|
|
{
|
|
B4KEY_DATA *bdata, *bdata2 ;
|
|
int avg, i ;
|
|
long tempFb, reference ;
|
|
|
|
if ( balanceMode == 2 && b4leaf( b4temp ) )
|
|
return error4( t4->codeBase, e4index, E81601 ) ;
|
|
else
|
|
{
|
|
if ( b4temp->nKeys + b4->nKeys < t4->header.keysMax )
|
|
{
|
|
if ( isRight )
|
|
{
|
|
if ( balanceMode == 2 )
|
|
{
|
|
b4->keyOn = 0 ;
|
|
parent->keyOn-- ;
|
|
bdata = b4key( parent, parent->keyOn ) ;
|
|
if ( b4->keyOn == 0 && b4->nKeys == 0 ) /* must do reference as well */
|
|
{
|
|
reference = b4key( b4, 0 )->pointer ;
|
|
b4insert( b4, bdata->value, bdata->num, b4key( b4temp, b4temp->nKeys )->pointer / 512 ) ;
|
|
b4key( b4, 1 ) ->pointer = reference ;
|
|
}
|
|
else
|
|
b4insert( b4, bdata->value, bdata->num, b4key( b4temp, b4temp->nKeys )->pointer / 512 ) ;
|
|
for ( i = b4temp->nKeys - 1 ; i >= 0 ; i-- )
|
|
{
|
|
b4->keyOn = 0 ;
|
|
bdata = b4key( b4temp, i ) ;
|
|
b4insert( b4, bdata->value, bdata->num, bdata->pointer / 512 ) ;
|
|
}
|
|
b4temp->changed = 0 ;
|
|
tfile4shrink( t4, b4temp->fileBlock ) ;
|
|
b4remove( parent ) ;
|
|
if ( parent->nKeys < t4->header.keysHalf )
|
|
tfile4balanceBranch( t4, parent ) ;
|
|
}
|
|
else
|
|
{
|
|
for ( i = 0 ; i < b4->nKeys ; i++ )
|
|
{
|
|
b4goEof( b4temp ) ;
|
|
bdata = b4key( b4, i ) ;
|
|
b4insert( b4temp, bdata->value, bdata->num, 0L ) ;
|
|
}
|
|
|
|
t4->codeBase->doIndexVerify = 0 ; /* avoid verify errors due to our partial removal */
|
|
do
|
|
{
|
|
tfile4down( t4 ) ;
|
|
if ( t4->blocks.lastNode == 0 )
|
|
break ;
|
|
} while( !b4leaf( (B4BLOCK *)t4->blocks.lastNode ) ) ; /* don't use tfile4block() due to borland problems */
|
|
t4->codeBase->doIndexVerify = 1 ;
|
|
|
|
b4flush( b4temp ) ;
|
|
if ( tfile4removeRef( t4 ) != 0 ) /* will delete b4 and will remove and re-add the reference if required */
|
|
return -1 ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* put parent entry, then all but one child, then last child to parent */
|
|
b4goEof( b4 ) ;
|
|
if ( balanceMode == 2 )
|
|
{
|
|
b4temp->keyOn = 0 ;
|
|
bdata = b4key( parent, parent->keyOn ) ;
|
|
b4insert( b4temp, bdata->value, bdata->num, b4key( b4, b4->nKeys )->pointer / 512 ) ;
|
|
for ( i = b4->nKeys - 1 ; i >= 0 ; i-- )
|
|
{
|
|
b4temp->keyOn = 0 ;
|
|
bdata = b4key( b4, i ) ;
|
|
b4insert( b4temp, bdata->value, bdata->num, bdata->pointer / 512 ) ;
|
|
}
|
|
tfile4shrink( t4, b4->fileBlock ) ;
|
|
l4pop( &t4->saved ) ;
|
|
b4->changed = 0 ;
|
|
b4free( b4 ) ;
|
|
b4 = 0 ;
|
|
b4flush( b4temp ) ;
|
|
b4remove( parent ) ;
|
|
if ( parent->nKeys < t4->header.keysHalf )
|
|
tfile4balanceBranch( t4, parent ) ;
|
|
}
|
|
else
|
|
{
|
|
bdata = b4key( parent, parent->keyOn ) ;
|
|
if ( b4->keyOn == 0 && b4->nKeys == 0 ) /* must do reference as well */
|
|
{
|
|
reference = b4key( b4, 0 )->pointer ;
|
|
b4insert( b4, bdata->value, bdata->num, 0L ) ;
|
|
b4key( b4, 1 ) ->pointer = reference ;
|
|
}
|
|
else
|
|
b4insert( b4, bdata->value, bdata->num, 0L ) ;
|
|
for ( i = 0 ; i < b4temp->nKeys - 1 ; i++ )
|
|
{
|
|
b4goEof( b4 ) ;
|
|
bdata = b4key( b4temp, i ) ;
|
|
b4insert( b4, bdata->value, bdata->num, 0L ) ;
|
|
}
|
|
bdata = b4key( parent, parent->keyOn ) ;
|
|
bdata2 = b4key( b4temp, b4temp->nKeys - 1 ) ;
|
|
memcpy( bdata->value, bdata2->value, t4->header.keyLen ) ;
|
|
memcpy( &( bdata->num ), &bdata2->num, sizeof( long ) ) ;
|
|
|
|
parent->keyOn++ ;
|
|
parent->changed = 1 ;
|
|
|
|
t4->codeBase->doIndexVerify = 0 ; /* avoid verify errors due to our partial removal */
|
|
b4flush( b4 ) ;
|
|
do
|
|
{
|
|
if ( tfile4down( t4 ) == 1 )
|
|
break ;
|
|
} while( ((B4BLOCK *)t4->blocks.lastNode)->fileBlock != b4temp->fileBlock ) ;
|
|
t4->codeBase->doIndexVerify = 1 ;
|
|
if ( tfile4removeRef( t4 ) != 0 ) /* will delete b4temp and will remove and re-add the reference if required */
|
|
return -1 ;
|
|
b4temp->changed = 0 ;
|
|
}
|
|
}
|
|
}
|
|
else /* will have to redistribute keys */
|
|
{
|
|
avg = ( b4->nKeys + b4temp->nKeys + 1 ) / 2 ;
|
|
if ( avg < t4->header.keysHalf )
|
|
avg = t4->header.keysHalf ;
|
|
if ( isRight )
|
|
{
|
|
b4->keyOn = 0 ;
|
|
parent->keyOn-- ;
|
|
bdata = b4key( parent, parent->keyOn ) ;
|
|
|
|
if ( balanceMode == 2 )
|
|
{
|
|
if ( b4->nKeys == 0 )
|
|
{
|
|
tempFb = b4key( b4, 0 )->pointer ;
|
|
b4insert( b4, bdata->value, bdata->num, b4key( b4temp, b4temp->nKeys )->pointer / 512 ) ;
|
|
b4append( b4, tempFb / 512 ) ;
|
|
}
|
|
else
|
|
b4insert( b4, bdata->value, bdata->num, b4key( b4temp, b4temp->nKeys )->pointer / 512 ) ;
|
|
}
|
|
else
|
|
b4insert( b4, bdata->value, bdata->num, 0L ) ;
|
|
|
|
while ( b4temp->nKeys > avg && b4->nKeys < avg )
|
|
{
|
|
b4->keyOn = 0 ;
|
|
b4temp->keyOn = b4temp->nKeys - 1 ;
|
|
bdata = b4key( b4temp, b4temp->keyOn ) ;
|
|
if ( balanceMode == 2 )
|
|
b4insert( b4, bdata->value, bdata->num, bdata->pointer / 512 ) ;
|
|
else
|
|
b4insert( b4, bdata->value, bdata->num, 0L ) ;
|
|
b4remove( b4temp ) ;
|
|
}
|
|
b4temp->keyOn = b4temp->nKeys - 1 ;
|
|
}
|
|
else
|
|
{
|
|
b4goEof( b4 ) ;
|
|
if ( balanceMode == 2 )
|
|
{
|
|
bdata = b4key( b4, b4->nKeys ) ;
|
|
bdata2 = b4key( parent, parent->keyOn ) ;
|
|
memcpy( bdata->value, bdata2->value, t4->header.keyLen ) ;
|
|
memcpy( &(bdata->num), &bdata2->num, sizeof( long ) ) ;
|
|
b4->nKeys++ ;
|
|
}
|
|
else
|
|
{
|
|
bdata = b4key( parent, parent->keyOn ) ;
|
|
b4insert( b4, bdata->value, bdata->num, 0L ) ;
|
|
}
|
|
|
|
while ( b4->nKeys - (balanceMode == 2) < avg )
|
|
{
|
|
b4goEof( b4 ) ;
|
|
b4temp->keyOn = 0 ;
|
|
bdata = b4key( b4temp, b4temp->keyOn ) ;
|
|
if ( balanceMode == 2 )
|
|
b4insert( b4, bdata->value, bdata->num, bdata->pointer / 512 ) ;
|
|
else
|
|
b4insert( b4, bdata->value, bdata->num, 0L ) ;
|
|
b4remove( b4temp ) ;
|
|
}
|
|
|
|
if ( balanceMode == 2 )
|
|
{
|
|
b4->nKeys-- ;
|
|
b4->keyOn-- ;
|
|
}
|
|
b4temp->keyOn = 0 ;
|
|
}
|
|
/* and add a key back to the parent */
|
|
bdata = b4key( parent, parent->keyOn ) ;
|
|
if ( balanceMode == 2 )
|
|
{
|
|
if ( isRight )
|
|
bdata2 = b4key( b4temp, b4temp->nKeys - 1 ) ;
|
|
else
|
|
bdata2 = b4key( b4, b4->nKeys ) ;
|
|
memcpy( bdata->value, bdata2->value, t4->header.keyLen ) ;
|
|
memcpy( &(bdata->num), &bdata2->num, sizeof( long ) ) ;
|
|
if ( isRight )
|
|
{
|
|
b4temp->keyOn = b4temp->nKeys ;
|
|
b4remove( b4temp ) ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bdata2 = b4key( b4temp, b4temp->keyOn ) ;
|
|
memcpy( bdata->value, bdata2->value, t4->header.keyLen ) ;
|
|
memcpy( &(bdata->num), &bdata2->num, sizeof( long ) ) ;
|
|
b4remove( b4temp ) ;
|
|
}
|
|
parent->changed = 1 ;
|
|
b4flush( b4temp ) ;
|
|
}
|
|
}
|
|
return 0 ;
|
|
}
|
|
|
|
static int tfile4balanceBranchLeaf( TAG4FILE *t4, B4BLOCK *parent, B4BLOCK *branch, B4BLOCK *leaf )
|
|
{
|
|
B4BLOCK *b4temp ;
|
|
long newFileBlock ;
|
|
B4KEY_DATA *key ;
|
|
|
|
t4->header.version++ ;
|
|
newFileBlock = tfile4extend( t4 ) ;
|
|
b4temp = b4alloc( t4, newFileBlock ) ;
|
|
if ( b4temp == 0 )
|
|
return -1 ;
|
|
|
|
key = b4key( b4temp, 0 ) ;
|
|
key->pointer = leaf->fileBlock * I4MULTIPLY ;
|
|
b4temp->changed = 1 ;
|
|
key = b4key( parent, parent->keyOn ) ;
|
|
#ifdef E4ANALYZE_ALL
|
|
if ( key->pointer != leaf->fileBlock * I4MULTIPLY )
|
|
return error4( t4->codeBase, e4index, E95407 ) ;
|
|
#endif
|
|
key->pointer = newFileBlock * I4MULTIPLY ;
|
|
parent->changed = 1 ;
|
|
l4add( &t4->blocks, b4temp ) ;
|
|
|
|
return tfile4balanceBlock( t4, parent, b4temp, branch, 1, 2 ) ;
|
|
}
|
|
|
|
/* if doFull is true, the whole branch set will be balanced, not just the current leaf block and reqd. Also, this will balance top down instead of the other way. */
|
|
int tfile4balance( TAG4FILE *t4, B4BLOCK *b4, int doFull )
|
|
{
|
|
B4BLOCK *b4temp, *parent ;
|
|
long tempFb ;
|
|
int rc, noKeys, doRightSpecial ;
|
|
char isRight, balanceMode ; /* balanceMode = 0 for done, 1 for leaf, and 2 for branch */
|
|
B4KEY_DATA *myKeyData ;
|
|
|
|
if ( !b4leaf( b4 ) )
|
|
return 0 ;
|
|
|
|
b4temp = b4alloc( t4, 0L ) ;
|
|
if ( b4temp == 0 )
|
|
return -1 ;
|
|
|
|
if ( doFull )
|
|
{
|
|
tfile4upToRoot( t4 ) ;
|
|
balanceMode = 2 ; /* branch */
|
|
}
|
|
else
|
|
balanceMode = 1 ; /* leaf */
|
|
|
|
noKeys = 0 ;
|
|
while ( balanceMode != 0 || doFull )
|
|
{
|
|
if ( doFull )
|
|
{
|
|
parent = (B4BLOCK *)t4->blocks.lastNode ;
|
|
if ( noKeys == 0 )
|
|
parent->keyOn = parent->nKeys ;
|
|
rc = tfile4down( t4 ) ;
|
|
if ( rc == 1 ) /* make sure siblings are also leafs */
|
|
{
|
|
tfile4up( t4 ) ;
|
|
parent = (B4BLOCK *)t4->blocks.lastNode ;
|
|
if ( parent != 0 )
|
|
{
|
|
if ( parent->keyOn > 0 )
|
|
{
|
|
tempFb = (long)b4key( parent, parent->keyOn - 1 )->pointer ;
|
|
if ( i4readBlock( &t4->file, tempFb, 0, b4temp ) < 0 )
|
|
{
|
|
b4free( b4temp ) ;
|
|
return -1 ;
|
|
}
|
|
if ( b4leaf( b4temp ) == 0 && b4leaf( b4 ) == 1 )
|
|
{
|
|
rc = tfile4balanceBranchLeaf( t4, parent, b4temp, b4 ) ;
|
|
b4free( b4temp ) ;
|
|
return rc ;
|
|
}
|
|
}
|
|
}
|
|
|
|
break ;
|
|
}
|
|
else
|
|
if ( noKeys == 1 ) /* need to check the siblings to make sure also branches */
|
|
{
|
|
tfile4up( t4 ) ;
|
|
parent = (B4BLOCK *)t4->blocks.lastNode ;
|
|
if ( parent != 0 )
|
|
{
|
|
if ( parent->keyOn > 0 )
|
|
{
|
|
tempFb = (long)b4key( parent, parent->keyOn - 1 )->pointer ;
|
|
if ( i4readBlock( &t4->file, tempFb, 0, b4temp ) < 0 )
|
|
{
|
|
b4free( b4temp ) ;
|
|
return -1 ;
|
|
}
|
|
if ( b4leaf( b4temp ) == 0 && b4leaf( b4 ) == 1 )
|
|
{
|
|
rc = tfile4balanceBranchLeaf( t4, parent, b4temp, b4 ) ;
|
|
b4free( b4temp ) ;
|
|
return rc ;
|
|
}
|
|
if ( b4leaf( b4temp ) == 1 && b4leaf( b4 ) == 0 )
|
|
{
|
|
rc = tfile4balanceBranchLeaf( t4, parent, b4, b4temp ) ;
|
|
b4free( b4temp ) ;
|
|
return rc ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
parent->keyOn = 0 ;
|
|
tempFb = (long)b4key( parent, parent->keyOn + 1 )->pointer ;
|
|
if ( i4readBlock( &t4->file, tempFb, 0, b4temp ) < 0 )
|
|
{
|
|
b4free( b4temp ) ;
|
|
return -1 ;
|
|
}
|
|
if ( b4leaf( b4temp ) == 0 && b4leaf( b4 ) == 1 )
|
|
{
|
|
rc = tfile4balanceBranchLeaf( t4, parent, b4temp, b4 ) ;
|
|
b4free( b4temp ) ;
|
|
return rc ;
|
|
}
|
|
if ( b4leaf( b4temp ) == 1 && b4leaf( b4 ) == 0 )
|
|
{
|
|
rc = tfile4balanceBranchLeaf( t4, parent, b4, b4temp ) ;
|
|
b4free( b4temp ) ;
|
|
return rc ;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( b4leaf( b4 ) )
|
|
break ;
|
|
tfile4down( t4 ) ;
|
|
tfile4down( t4 ) ;
|
|
b4 = (B4BLOCK *)t4->blocks.lastNode ;
|
|
tfile4up( t4 ) ;
|
|
continue ;
|
|
}
|
|
|
|
if ( rc < 0 )
|
|
return -1 ;
|
|
|
|
b4 = (B4BLOCK *)t4->blocks.lastNode ;
|
|
b4->keyOn = b4->nKeys ;
|
|
|
|
if ( b4->nKeys >= t4->header.keysHalf )
|
|
continue ;
|
|
|
|
if ( b4leaf( b4 ) )
|
|
balanceMode = 1 ;
|
|
tempFb = b4key( parent, parent->keyOn - 1 )->pointer ;
|
|
isRight = 1 ;
|
|
}
|
|
else
|
|
{
|
|
if ( balanceMode == 2 ) /* branch */
|
|
{
|
|
b4 = parent ;
|
|
while( t4->blocks.lastNode != (LINK4 *)b4 ) /* re-align ourselves */
|
|
tfile4up( t4 ) ;
|
|
}
|
|
tfile4up( t4 ) ;
|
|
parent = (B4BLOCK *)t4->blocks.lastNode ;
|
|
|
|
if ( parent == 0 ) /* root block */
|
|
{
|
|
tfile4down( t4 ) ;
|
|
parent = (B4BLOCK *)t4->blocks.lastNode ;
|
|
if ( !b4leaf( parent ) && parent->nKeys == 0 ) /* remove */
|
|
{
|
|
tempFb = (long)b4key( parent, 0 )->pointer ;
|
|
tfile4shrink( t4, parent->fileBlock ) ;
|
|
tfile4up( t4 ) ;
|
|
l4pop( &t4->saved ) ;
|
|
parent->changed = 0 ;
|
|
b4free( parent ) ;
|
|
parent = 0 ;
|
|
t4->header.root = tempFb ;
|
|
tfile4down( t4 ) ;
|
|
}
|
|
break ;
|
|
}
|
|
|
|
if ( parent->nKeys == 0 ) /* try to replace parent with ourself */
|
|
return error4describe( t4->codeBase, e4index, E81601, tfile4alias( t4 ), 0, 0 ) ;
|
|
|
|
if ( b4->nKeys >= t4->header.keysHalf )
|
|
{
|
|
balanceMode = 0 ;
|
|
continue ;
|
|
}
|
|
isRight = (parent->keyOn == parent->nKeys ) ;
|
|
if ( isRight )
|
|
tempFb = b4key( parent, parent->keyOn - 1 )->pointer ;
|
|
else
|
|
tempFb = b4key( parent, parent->keyOn + 1 )->pointer ;
|
|
}
|
|
|
|
b4temp->fileBlock = tempFb ;
|
|
for ( ;; )
|
|
{
|
|
if ( i4readBlock( &t4->file, tempFb, 0, b4temp ) < 0 )
|
|
{
|
|
b4free( b4temp ) ;
|
|
return -1 ;
|
|
}
|
|
|
|
if ( balanceMode == 2 || b4leaf( b4temp ) ) /* if branch mode or leaf mode and leaf block found */
|
|
break ;
|
|
|
|
if ( isRight )
|
|
tempFb = b4key( b4temp, b4temp->nKeys )->pointer ;
|
|
else
|
|
tempFb = b4key( b4temp, 0 )->pointer ;
|
|
}
|
|
|
|
/* save a key position for after-seek */
|
|
myKeyData = (B4KEY_DATA *)u4allocEr( t4->codeBase, t4->header.groupLen ) ;
|
|
if ( myKeyData == 0 )
|
|
return e4memory ;
|
|
|
|
doRightSpecial = 0 ;
|
|
if ( b4->nKeys == 0 ) /* can't do a seek on, so after just go to far left */
|
|
{
|
|
noKeys = 1 ;
|
|
if ( isRight == 1 && parent != 0 ) /* get parents key, since performing a right-op */
|
|
{
|
|
memcpy( &(myKeyData->num), &( b4key( parent, parent->nKeys - 1 )->num), sizeof(long) + t4->header.keyLen ) ;
|
|
doRightSpecial = 1 ;
|
|
}
|
|
else
|
|
memcpy( &(myKeyData->num), &( b4key( b4temp, 0 )->num), sizeof(long) + t4->header.keyLen ) ;
|
|
}
|
|
else
|
|
{
|
|
noKeys = 0 ;
|
|
if ( b4->keyOn > 0 )
|
|
memcpy( &(myKeyData->num), &( b4key( b4, 0 )->num), sizeof(long) + t4->header.keyLen ) ;
|
|
else
|
|
memcpy( &(myKeyData->num), &( b4key( b4, 1 )->num), sizeof(long) + t4->header.keyLen ) ;
|
|
}
|
|
|
|
if ( tfile4balanceBlock( t4, parent, b4, b4temp, isRight, balanceMode ) < 0 )
|
|
{
|
|
u4free( myKeyData ) ;
|
|
return -1 ;
|
|
}
|
|
|
|
/* need to re-find position */
|
|
rc = tfile4go( t4, myKeyData->value, myKeyData->num, 0 ) ; /* returns -1 if error4code( codeBase ) < 0 */
|
|
if ( noKeys == 1 ) /* can't find position, so just go to far left */
|
|
{
|
|
for ( ;; )
|
|
{
|
|
b4 = tfile4block( t4 ) ;
|
|
if ( b4->nKeys < t4->header.keysHalf || b4leaf( b4 ) )
|
|
{
|
|
if ( doRightSpecial == 1 ) /* in this case, don't reset position, just go up */
|
|
while ( tfile4up( t4 ) != 1 ) ;
|
|
else
|
|
tfile4upToRoot( t4 ) ;
|
|
balanceMode = 2 ;
|
|
doFull = 1 ;
|
|
break ;
|
|
}
|
|
if ( doRightSpecial == 1 )
|
|
{
|
|
b4->keyOn = b4->nKeys ;
|
|
tfile4down( t4 ) ;
|
|
}
|
|
else
|
|
if ( tfile4skip( t4, 1L ) != 1L )
|
|
break ;
|
|
}
|
|
}
|
|
b4 = tfile4block( t4 ) ;
|
|
u4free( myKeyData ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
|
|
if ( b4 == 0 ) /* in theory should never happen, but would maybe mean done */
|
|
return 0 ;
|
|
|
|
parent = (B4BLOCK *)b4->link.p ;
|
|
if ( parent == 0 || b4leaf( parent ) ) /* no parent */
|
|
break ;
|
|
|
|
if ( parent == b4 ) /* move down one to avoid problems (b4 should never be root) */
|
|
{
|
|
if ( tfile4down( t4 ) == 0 )
|
|
{
|
|
b4 = (B4BLOCK *)t4->blocks.lastNode ;
|
|
tfile4up( t4 ) ;
|
|
}
|
|
}
|
|
|
|
if ( balanceMode != 2 || noKeys != 1 )
|
|
{
|
|
if ( doFull )
|
|
{
|
|
if ( b4leaf( b4 ) )
|
|
balanceMode = 0 ;
|
|
}
|
|
else
|
|
{
|
|
if ( parent->nKeys < t4->header.keysHalf ) /* do parent as well */
|
|
balanceMode = 2 ;
|
|
else
|
|
balanceMode = 0 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
b4free( b4temp ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
int tfile4getReplaceEntry( TAG4FILE *t4, B4KEY_DATA *insertSpot, B4BLOCK *saveBlock )
|
|
{
|
|
int rc ;
|
|
B4BLOCK *blockOn ;
|
|
|
|
blockOn = saveBlock ;
|
|
|
|
if ( b4leaf( blockOn ) )
|
|
return 0 ;
|
|
|
|
blockOn->keyOn = blockOn->keyOn + 1 ;
|
|
while ( !b4leaf( blockOn ) )
|
|
{
|
|
rc = tfile4down( t4 ) ;
|
|
if ( rc < 0 || rc == 2 )
|
|
return -1 ;
|
|
blockOn = (B4BLOCK *)t4->blocks.lastNode ;
|
|
}
|
|
memcpy( &insertSpot->num, &(b4key( blockOn, blockOn->keyOn )->num), sizeof(long) + t4->header.keyLen ) ;
|
|
saveBlock->changed = 1 ;
|
|
b4remove( blockOn ) ;
|
|
if ( blockOn->nKeys < t4->header.keysHalf && blockOn->fileBlock != t4->header.root ) /* if not root may have to balance the tree */
|
|
if ( tfile4balance( t4, blockOn, 0 ) < 0 )
|
|
return -1 ;
|
|
return 1 ;
|
|
}
|
|
|
|
int tfile4balanceBranch( TAG4FILE *t4, B4BLOCK *b4 )
|
|
{
|
|
B4BLOCK *parent, *b4temp ;
|
|
int rc ;
|
|
char isRight ;
|
|
long tempFb, reference ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( b4leaf( b4 ) )
|
|
return error4describe( t4->codeBase, e4index, E95406, tfile4alias( t4 ), 0, 0 ) ;
|
|
#endif
|
|
|
|
if ( b4 == (B4BLOCK *)l4first( &t4->blocks ) )
|
|
{
|
|
if ( b4->nKeys == 0 ) /* empty, so just remove */
|
|
{
|
|
reference = (long)b4key( b4, 0 )->pointer ;
|
|
b4->changed = 0 ;
|
|
tfile4shrink( t4, b4->fileBlock ) ;
|
|
tfile4up( t4 ) ;
|
|
l4pop(&t4->saved ) ;
|
|
b4free( b4 ) ;
|
|
b4 = 0 ;
|
|
t4->header.root = reference ;
|
|
}
|
|
return 0 ;
|
|
}
|
|
|
|
tfile4up( t4 ) ;
|
|
parent = (B4BLOCK *)t4->blocks.lastNode ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( b4key( parent, parent->keyOn )->pointer != I4MULTIPLY * b4->fileBlock )
|
|
return error4describe( t4->codeBase, e4index, E95406, tfile4alias( t4 ), 0, 0 ) ;
|
|
#endif
|
|
|
|
if ( parent->keyOn == parent->nKeys )
|
|
{
|
|
tempFb = b4key( parent, parent->keyOn - 1 )->pointer ;
|
|
isRight = 1 ;
|
|
}
|
|
else
|
|
{
|
|
tempFb = b4key( parent, parent->keyOn + 1 )->pointer ;
|
|
isRight = 0 ;
|
|
}
|
|
|
|
b4temp = b4alloc( t4, 0L ) ;
|
|
if ( b4temp == 0 )
|
|
return error4stack( t4->codeBase, e4memory, E95406 ) ;
|
|
|
|
rc = i4readBlock( &t4->file, tempFb, 0, b4temp ) ;
|
|
if ( rc < 0 )
|
|
{
|
|
b4free( b4temp ) ;
|
|
return error4stack( t4->codeBase, rc, E95406 ) ;
|
|
}
|
|
|
|
rc = tfile4balanceBlock( t4, parent, b4, b4temp, isRight, 2 ) ;
|
|
b4free( b4temp ) ;
|
|
if ( rc < 0 )
|
|
return error4stack( t4->codeBase, rc, E95406 ) ;
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
int tfile4removeCurrent( TAG4FILE *t4 )
|
|
{
|
|
B4BLOCK *blockOn ;
|
|
|
|
t4->header.version = (short)( t4->header.oldVersion + 1L ) ;
|
|
|
|
blockOn = (B4BLOCK *)t4->blocks.lastNode ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( b4lastpos( blockOn ) == -b4leaf( blockOn ) )
|
|
return error4describe( t4->codeBase, e4index, E85401, tfile4alias( t4 ), 0, 0 ) ;
|
|
#endif
|
|
|
|
switch( tfile4getReplaceEntry( t4, b4key( blockOn, blockOn->keyOn ), blockOn ) )
|
|
{
|
|
case 0 : /* leaf delete */
|
|
b4remove( blockOn ) ;
|
|
if ( blockOn->nKeys == 0 ) /* last entry deleted! -- remove upward reference */
|
|
{
|
|
if ( tfile4removeRef( t4 ) != 0 )
|
|
return -1 ;
|
|
}
|
|
else
|
|
{
|
|
if ( blockOn->nKeys < t4->header.keysHalf && blockOn->fileBlock != t4->header.root ) /* if not root may have to balance the tree */
|
|
return tfile4balance( t4, blockOn, 0 ) ;
|
|
}
|
|
break ;
|
|
|
|
case 1 : /* branch delete */
|
|
if( tfile4block( t4 )->nKeys == 0 ) /* removed the last key of */
|
|
if ( tfile4removeRef( t4 ) != 0 )
|
|
return -1 ;
|
|
break ;
|
|
|
|
default:
|
|
return error4describe( t4->codeBase, e4index, E81601, tfile4alias( t4 ), 0, 0 ) ;
|
|
}
|
|
return 0 ;
|
|
}
|
|
#endif /* S4CLIPPER */
|
|
|
|
#endif /* S4INDEX_OFF */
|
|
#endif /* S4OFF_WRITE */
|
|
#endif
|