campo-sirio/cb5/i4remove.c

1091 lines
31 KiB
C
Raw Normal View History

/* i4remove.c (c)Copyright Sequiter Software Inc., 1990-1994. All rights reserved. */
#include "d4all.h"
#ifndef S4UNIX
#ifdef __TURBOC__
#pragma hdrstop
#endif
#endif
#ifndef S4OFF_WRITE
#ifndef S4INDEX_OFF
int S4FUNCTION t4remove( TAG4 *t4, char *ptr, long rec )
{
int rc ;
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4REMOVE ) ;
#endif
rc = t4go( t4, ptr, rec ) ; /* returns -1 if code_base->error_code < 0 */
if ( rc < 0 )
return rc ;
if ( rc )
return r4entry ;
return t4remove_current( t4 ) ;
}
int S4FUNCTION t4remove_calc( TAG4 *t4, long rec )
{
char *ptr ;
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4REM_CALC ) ;
#endif
if ( t4->code_base->error_code < 0 )
return -1 ;
t4expr_key( t4, &ptr ) ;
return t4remove( t4, ptr, rec ) ;
}
#ifndef N4OTHER
#ifdef S4FOX
/* remove the (current) branch block */
void S4FUNCTION t4remove_branch( TAG4 *t4, B4BLOCK *block_on )
{
long l_node, r_node ;
INDEX4 *i4 ;
#ifdef S4BYTE_SWAP
char *swap_ptr ;
S4LONG long_val ;
short short_val ;
int i ;
#endif
i4 = t4->index ;
if ( block_on == (B4BLOCK *)l4first( &t4->blocks ) )
{
/* Root Block, do not delete */
#ifdef S4DEBUG
if ( block_on->header.left_node != -1 || block_on->header.right_node != -1 || block_on->header.n_keys != 1 )
e4severe( e4info, E4_INFO_CIB ) ;
#endif
memset( block_on->data, 0, B4BLOCK_SIZE - sizeof(B4STD_HEADER) - sizeof(B4NODE_HEADER) ) ;
if ( !b4leaf( block_on ) ) /* if not a leaf, then reset node_hdr too */
{
memset( (void *)&block_on->node_hdr, 0, sizeof(B4NODE_HEADER) ) ;
b4leaf_init( block_on ) ;
}
else
block_on->node_hdr.free_space = B4BLOCK_SIZE - sizeof( B4STD_HEADER ) - sizeof( B4NODE_HEADER ) ;
block_on->header.n_keys = 0 ;
block_on->header.left_node = -1 ;
block_on->header.right_node = -1 ;
block_on->key_on = -1 ;
block_on->built_on = -1 ;
block_on->header.node_attribute = 3 ; /* root and leaf */
block_on->changed = 1 ;
}
else /* This block is to be deleted */
{
l_node = block_on->header.left_node ;
r_node = block_on->header.right_node ;
l4remove( &t4->blocks, block_on ) ;
if ( i4shrink( i4, block_on->file_block ) < 0 )
return ;
block_on->changed = 0 ;
if ( l_node != -1L )
{
if ( file4read_all( &i4->file, I4MULTIPLY*l_node, &block_on->header, B4BLOCK_SIZE) < 0 )
return ;
#ifdef S4BYTE_SWAP
block_on->header.node_attribute = x4reverse_short( (void *)&block_on->header.node_attribute ) ;
block_on->header.n_keys = x4reverse_short( (void *)&block_on->header.n_keys ) ;
block_on->header.left_node = x4reverse_long( (void *)&block_on->header.left_node ) ;
block_on->header.right_node = x4reverse_long( (void *)&block_on->header.right_node ) ;
/* if block is a leaf */
if (block_on->header.node_attribute >= 2 )
{
block_on->node_hdr.free_space = x4reverse_short( (void *)&block_on->node_hdr.free_space ) ;
long_val = x4reverse_long( (void *)&block_on->node_hdr.rec_num_mask[0] ) ;
memcpy( (void *)&block_on->node_hdr.rec_num_mask[0], (void *)&long_val, sizeof(S4LONG) ) ;
}
else /* if block is a branch */
{
short_val = block_on->tag->header.key_len + sizeof(S4LONG) ;
/* position swap_ptr to end of first key expression */
swap_ptr = (char *) &block_on->node_hdr.free_space + block_on->tag->header.key_len ;
/* move through all B4KEY's to swap 'long's */
for ( i = 0 ; i < (int) block_on->header.n_keys ; i++ )
{
long_val = x4reverse_long( (void *)swap_ptr ) ;
memcpy( swap_ptr, (void *) &long_val, sizeof(S4LONG) ) ;
swap_ptr += sizeof(S4LONG) ;
long_val = x4reverse_long( (void *)swap_ptr ) ;
memcpy( swap_ptr, (void *) &long_val, sizeof(S4LONG) ) ;
swap_ptr += short_val ;
}
}
#endif
block_on->file_block = l_node ;
block_on->header.right_node = r_node ;
block_on->changed = 1 ;
b4flush( block_on ) ;
}
if ( r_node != -1L )
{
if ( file4read_all( &i4->file, I4MULTIPLY*r_node, &block_on->header, B4BLOCK_SIZE) < 0 )
return ;
#ifdef S4BYTE_SWAP
block_on->header.node_attribute = x4reverse_short( (void *)&block_on->header.node_attribute ) ;
block_on->header.n_keys = x4reverse_short( (void *)&block_on->header.n_keys ) ;
block_on->header.left_node = x4reverse_long( (void *)&block_on->header.left_node ) ;
block_on->header.right_node = x4reverse_long( (void *)&block_on->header.right_node ) ;
/* if block is a leaf */
if (block_on->header.node_attribute >= 2 )
{
block_on->node_hdr.free_space = x4reverse_short( (void *)&block_on->node_hdr.free_space ) ;
long_val = x4reverse_long( (void *)block_on->node_hdr.rec_num_mask ) ;
memcpy( (void *)block_on->node_hdr.rec_num_mask, (void *)&long_val, sizeof(S4LONG) ) ;
}
else /* if block is a branch */
{
short_val = block_on->tag->header.key_len + sizeof(S4LONG) ;
/* position swap_ptr to end of first key expression */
swap_ptr = (char *) &block_on->node_hdr.free_space + block_on->tag->header.key_len ;
/* move through all B4KEY's to swap 'long's */
for ( i = 0 ; i < (int) block_on->header.n_keys ; i++ )
{
long_val = x4reverse_long( (void *)swap_ptr ) ;
memcpy( swap_ptr, (void *) &long_val, sizeof(S4LONG) ) ;
swap_ptr += sizeof(S4LONG) ;
long_val = x4reverse_long( (void *)swap_ptr ) ;
memcpy( swap_ptr, (void *) &long_val, sizeof(S4LONG) ) ;
swap_ptr += short_val ;
}
}
#endif
block_on->file_block = r_node ;
block_on->header.left_node = l_node ;
block_on->changed = 1 ;
b4flush( block_on ) ;
}
b4free( block_on ) ;
}
}
#endif
/* Remove the current key */
int S4FUNCTION t4remove_current( TAG4 *t4 )
{
B4BLOCK *block_on ;
INDEX4 *i4 ;
#ifdef S4FOX
void *new_key_info ;
long rec ;
int bl_removed, less_than_last ;
#else
int remove_done, update_reqd ;
B4BLOCK *block_iterate ;
#endif
i4 = t4->index ;
#ifdef S4FOX
i4->tag_index->header.version = i4->version_old+1 ;
new_key_info = 0 ;
for ( block_on = (B4BLOCK *)t4->blocks.last_node ; block_on ; )
{
bl_removed = 0 ;
if ( new_key_info == 0 ) /* then delete entry */
{
if ( b4lastpos( block_on ) == 0 )
{
if ( block_on != (B4BLOCK *)l4first( &t4->blocks ) )
bl_removed = 1 ;
t4remove_branch( t4, block_on ) ;
block_on = (B4BLOCK *)t4->blocks.last_node ;
}
else
{
less_than_last = 0 ;
if ( block_on->key_on < b4lastpos( block_on ) )
less_than_last = 1 ;
b4remove( block_on ) ;
if ( less_than_last )
return 0 ;
/* On last entry */
b4go_eof( block_on ) ;
block_on->key_on-- ; /* update key_on for goint to last spot */
new_key_info = b4key_key( block_on, block_on->key_on ) ;
rec = b4recno( block_on, block_on->key_on ) ;
}
}
else /* Adjust entry */
{
b4br_replace( block_on, (char *)new_key_info, rec ) ;
if ( block_on->key_on != b4lastpos( block_on ) ) /* not on end key, so exit, else continue */
return 0 ;
}
if ( !bl_removed )
{
block_on = (B4BLOCK *)block_on->link.p ;
if ( block_on == (B4BLOCK *)t4->blocks.last_node )
break ;
}
}
#endif
#ifdef S4MDX
remove_done = 0 ;
update_reqd = 0 ;
i4->changed = 1 ;
t4->changed = 1 ;
t4->header.version++ ;
block_iterate = (B4BLOCK *)l4last( &t4->blocks ) ;
for ( ;; )
{
block_on = block_iterate ;
if ( block_on == 0 )
break ;
block_iterate = (B4BLOCK *)l4prev( &t4->blocks, block_iterate ) ; /* Calculate the previous block while the current block exists. */
if ( !remove_done ) /* either removing or else updating */
{
if ( b4lastpos( block_on ) == 0 ) /* delete block */
{
if ( block_on == (B4BLOCK *)l4first( &t4->blocks ) ) /* root block, don't delete */
{
block_on->changed = 1 ;
block_on->key_on = 0 ;
memset( (void *)&block_on->n_keys, 0, i4->header.block_rw ) ;
if (t4->filter ) /* must modify the filter setting for dBASE IV compatibility */
{
file4write(&t4->index->file, t4->header_offset+sizeof(t4->header)+222, (char *)"\0", (int)1 ) ;
t4->has_keys = 0 ;
#ifdef S4MDX
t4->had_keys = 1 ;
#endif
}
return 0 ;
}
else
{
l4remove( &t4->blocks, block_on ) ;
if ( i4shrink( i4, block_on->file_block) < 0 )
return -1 ;
b4free( block_on ) ;
}
}
else /* just remove entry */
{
if ( block_iterate && block_on->key_on == b4lastpos( block_on ) && b4lastpos( block_on ) > 0 ) /* save to become last key of the block for parent update */
{
memcpy( t4->code_base->saved_key, b4key_key( block_on, block_on->n_keys - 1 - b4leaf(block_on) ), t4->header.key_len ) ;
update_reqd = 1 ;
}
else
update_reqd = 0 ;
b4remove( block_on ) ;
if ( !b4leaf( block_on ) && b4lastpos( block_on ) == 0 ) /* branch with only one entry, so have the entry take place of this block */
{
if (block_on == (B4BLOCK *)l4first( &t4->blocks ) ) /* the entry becomes the new root */
{
/* first update the tags root */
t4->header.root = b4key( block_on, 0 )->num ;
#ifdef S4BYTE_SWAP
t4->header.root = x4reverse_long( (void *)&t4->header.root ) ;
#endif
file4write( &t4->index->file, t4->header_offset, (void *)&t4->header.root, sizeof(t4->header.root) ) ;
#ifdef S4BYTE_SWAP
t4->header.root = x4reverse_long( (void *)&t4->header.root ) ;
#endif
update_reqd = 0 ;
}
else /* remove this branch block */
{
block_iterate->changed = 1 ;
b4key( block_iterate, block_iterate->key_on )->num = b4key( block_on, 0 )->num ;
}
l4remove( &t4->blocks, block_on ) ;
if ( i4shrink( t4->index, block_on->file_block) < 0 )
return -1 ;
block_on->changed = 0 ;
b4free( block_on ) ;
}
else
block_on->key_on = b4lastpos( block_on ) ;
if ( !update_reqd )
return 0 ;
remove_done = 1 ;
}
}
else /* Adjust entry - at most one update will be required in MDX */
{
if ( block_on->key_on < b4lastpos( block_on ) )
{
block_on->changed = 1 ;
memcpy( b4key_key( block_on, block_on->key_on), t4->code_base->saved_key, t4->header.key_len ) ;
return 0 ;
}
}
}
#endif
return 0 ;
}
#endif /* ifndef N4OTHER */
#ifdef N4OTHER
#ifdef S4NDX
int S4FUNCTION t4remove_current( TAG4 *t4 )
{
B4BLOCK *block_on, *block_iterate ;
int remove_done, update_reqd ;
#ifdef S4USE_OLD
void *new_key_info ;
long shrink_br = 0 ;
B4BLOCK *shrink_block = 0 ;
new_key_info = 0 ;
#endif
t4->header.version = t4->header.old_version+1 ;
remove_done = 0 ;
update_reqd = 0 ;
t4->header.version++ ;
block_iterate = (B4BLOCK *)l4last( &t4->blocks ) ;
for ( ;; )
{
block_on = block_iterate ;
if ( block_on == 0 )
break ;
block_iterate = (B4BLOCK *)l4prev( &t4->blocks, block_iterate ) ; /* Calculate the previous block while the current block exists. */
if ( !remove_done ) /* either removing or else updating */
{
if ( b4lastpos( block_on ) == 0 ) /* delete block */
{
block_on->changed = 1 ;
block_on->key_on = 0 ;
memset( (void *)&block_on->n_keys, 0, B4BLOCK_SIZE ) ;
if ( block_on == (B4BLOCK *)l4first( &t4->blocks ) ) /* root block, don't delete */
return 0 ;
else
{
l4remove( &t4->blocks, block_on ) ;
if ( b4flush( block_on ) < 0 )
return -1 ;
b4free( block_on ) ;
}
}
else /* just remove entry */
{
if ( block_iterate && block_on->key_on == b4lastpos( block_on ) && b4lastpos( block_on ) > 0 ) /* save to become last key of the block for parent update */
{
memcpy( t4->code_base->saved_key, b4key_key( block_on, block_on->n_keys - 1 - b4leaf(block_on) ), t4->header.key_len ) ;
update_reqd = 1 ;
}
else
update_reqd = 0 ;
b4remove( block_on ) ;
if ( !b4leaf( block_on ) && b4lastpos( block_on ) == 0 ) /* branch with only one entry, so have the entry take place of this block */
{
if (block_on == (B4BLOCK *)l4first( &t4->blocks ) ) /* the entry becomes the new root */
{
/* first update the tags root */
t4->header.root = b4key( block_on, 0 )->num ;
#ifdef S4BYTE_SWAP
t4->header.root = x4reverse_long( (void *)&t4->header.root ) ;
#endif
file4write( &t4->file, t4->header_offset, (void *)&t4->header.root, sizeof(t4->header.root) ) ;
#ifdef S4BYTE_SWAP
t4->header.root = x4reverse_long( (void *)&t4->header.root ) ;
#endif
update_reqd = 0 ;
}
else /* remove this branch block */
{
block_iterate->changed = 1 ;
b4key( block_iterate, block_iterate->key_on )->pointer = b4key( block_on, 0 )->pointer ;
}
l4remove( &t4->blocks, block_on ) ;
block_on->changed = 1 ;
memset( &block_on->n_keys, 0, B4BLOCK_SIZE ) ;
if ( b4flush( block_on ) < 0 )
return -1 ;
b4free( block_on ) ;
}
else
block_on->key_on = b4lastpos( block_on ) ;
if ( !update_reqd )
return 0 ;
remove_done = 1 ;
}
}
else /* Adjust entry - at most one update will be required in MDX */
{
if ( block_on->key_on < b4lastpos( block_on ) )
{
block_on->changed = 1 ;
memcpy( b4key_key( block_on, block_on->key_on), t4->code_base->saved_key, t4->header.key_len ) ;
return 0 ;
}
}
}
return 0 ;
}
#else
#ifdef S4CLIPPER
int S4FUNCTION t4balance_branch( TAG4 *, B4BLOCK * ) ;
int S4FUNCTION t4remove_ref( TAG4 *t4 )
{
B4KEY_DATA *my_key_data ;
B4BLOCK *block_on, *block_up ;
long reference ;
int i ;
int rc ;
my_key_data = (B4KEY_DATA *)u4alloc_er( t4->code_base, t4->header.group_len ) ;
if ( my_key_data == 0 )
return -1 ;
block_on = (B4BLOCK *)t4->blocks.last_node ;
/* no longer required...
#ifdef S4DEBUG
if ( block_on->n_keys )
e4severe( e4info, E4_INFO_DEL ) ;
#endif
*/
t4up( t4 ) ;
block_up = (B4BLOCK *)t4->blocks.last_node ;
if ( block_up == 0 ) /* root block only, so reference doesn't exist */
{
/* reset the block */
short offset = ( t4->header.keys_max + 2 + ( (t4->header.keys_max/2)*2 != t4->header.keys_max ) ) * sizeof(short) ;
for ( i = 0 ; i <= t4->header.keys_max ; i++ )
block_on->pointers[i] = (short)( t4->header.group_len * i ) + offset ;
return 0 ;
}
else /* delete the block */
{
t4shrink( t4, block_on->file_block ) ;
l4pop( &t4->saved ) ;
block_on->changed = 0 ;
b4free( block_on ) ;
}
block_on = block_up ;
if ( block_on->key_on >= block_on->n_keys )
memcpy( &(my_key_data->num), &( b4key( block_on, block_on->key_on - 1 )->num), sizeof(long) + t4->header.key_len ) ;
else
memcpy( &(my_key_data->num), &( b4key( block_on, block_on->key_on )->num), sizeof(long) + t4->header.key_len ) ;
if ( block_on->n_keys == 1 )
{
/* take the branch, and put in place of me, then delete and add me */
if ( block_on->key_on >= block_on->n_keys )
reference = (long) b4key( block_on, 0 )->pointer ;
else
reference = (long) b4key( block_on, 1 )->pointer ;
t4shrink( t4, block_on->file_block ) ;
t4up( t4 ) ;
l4pop(&t4->saved ) ;
block_on->changed = 0 ;
b4free( block_on ) ;
block_on = (B4BLOCK *)t4->blocks.last_node ;
if ( block_on == 0 ) /* just removed root, so make reference root! */
t4->header.root = reference ;
else
{
memcpy( &(b4key( block_on, block_on->key_on )->pointer), &reference, sizeof( reference ) ) ;
block_on->changed = 1 ;
}
}
else /* just remove myself, add later */
{
b4remove( block_on ) ;
if ( block_on->n_keys < t4->header.keys_half && block_on->file_block != t4->header.root ) /* if not root may have to balance the tree */
{
if ( t4balance_branch( t4, block_on ) < 0 )
return -1 ;
}
}
/* now add the removed reference back into the index */
rc = t4add( t4, (unsigned char *)my_key_data->value, my_key_data->num ) ;
u4free( my_key_data ) ;
return rc ;
}
static int t4balance_block( TAG4 *t4, B4BLOCK *parent, B4BLOCK *b4, B4BLOCK *b4temp, char is_right, char balance_mode )
{
B4KEY_DATA *bdata, *bdata2 ;
int avg, i ;
long temp_fb ;
if ( balance_mode == 2 && b4leaf( b4temp ) )
{
#ifdef S4DEBUG
e4severe( e4info, E4_INFO_CIF ) ;
#endif
return -1 ;
}
else
{
if ( b4temp->n_keys + b4->n_keys < t4->header.keys_max ) /* join the two */
{
if ( is_right )
{
if ( balance_mode == 2 )
{
b4->key_on = 0 ;
parent->key_on-- ;
bdata = b4key( parent, parent->key_on ) ;
b4insert( b4, bdata->value, bdata->num, b4key( b4temp, b4temp->n_keys )->pointer / 512 ) ;
for ( i = b4temp->n_keys - 1 ; i >= 0 ; i-- )
{
b4->key_on = 0 ;
bdata = b4key( b4temp, i ) ;
b4insert( b4, bdata->value, bdata->num, bdata->pointer / 512 ) ;
}
b4temp->changed = 0 ;
t4shrink( t4, b4temp->file_block ) ;
b4remove( parent ) ;
if ( parent->n_keys < t4->header.keys_half )
t4balance_branch( t4, parent ) ;
}
else
{
for ( i = 0 ; i < b4->n_keys ; i++ )
{
b4go_eof( b4temp ) ;
bdata = b4key( b4, i ) ;
b4insert( b4temp, bdata->value, bdata->num, 0L ) ;
}
t4->index->code_base->do_index_verify = 0 ; /* avoid verify errors due to our partial removal */
do
{
t4down( t4 ) ;
} while( !b4leaf( t4block( t4 ) ) ) ;
t4->index->code_base->do_index_verify = 1 ;
b4flush( b4temp ) ;
if ( t4remove_ref( 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 */
b4go_eof( b4 ) ;
if ( balance_mode == 2 )
{
b4temp->key_on = 0 ;
bdata = b4key( parent, parent->key_on ) ;
b4insert( b4temp, bdata->value, bdata->num, b4key( b4, b4->n_keys )->pointer / 512 ) ;
for ( i = b4->n_keys - 1 ; i >= 0 ; i-- )
{
b4temp->key_on = 0 ;
bdata = b4key( b4, i ) ;
b4insert( b4temp, bdata->value, bdata->num, bdata->pointer / 512 ) ;
}
t4shrink( t4, b4->file_block ) ;
l4pop( &t4->saved ) ;
b4->changed = 0 ;
b4free( b4 ) ;
b4flush( b4temp ) ;
b4remove( parent ) ;
if ( parent->n_keys < t4->header.keys_half )
t4balance_branch( t4, parent ) ;
}
else
{
bdata = b4key( parent, parent->key_on ) ;
b4insert( b4, bdata->value, bdata->num, 0L ) ;
for ( i = 0 ; i < b4temp->n_keys - 1 ; i++ )
{
b4go_eof( b4 ) ;
bdata = b4key( b4temp, i ) ;
b4insert( b4, bdata->value, bdata->num, 0L ) ;
}
bdata = b4key( parent, parent->key_on ) ;
bdata2 = b4key( b4temp, b4temp->n_keys - 1 ) ;
memcpy( bdata->value, bdata2->value, t4->header.key_len ) ;
memcpy( &( bdata->num ), &bdata2->num, sizeof( long ) ) ;
parent->key_on++ ;
parent->changed = 1 ;
t4->index->code_base->do_index_verify = 0 ; /* avoid verify errors due to our partial removal */
b4flush( b4 ) ;
do
{
if ( t4down( t4 ) == 1 )
break ;
} while( ((B4BLOCK *)t4->blocks.last_node)->file_block != b4temp->file_block ) ;
t4->index->code_base->do_index_verify = 1 ;
if ( t4remove_ref( 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->n_keys + b4temp->n_keys + 1 ) / 2 ;
if ( avg < t4->header.keys_half )
avg = t4->header.keys_half ;
if ( is_right )
{
b4->key_on = 0 ;
parent->key_on-- ;
bdata = b4key( parent, parent->key_on ) ;
if ( balance_mode == 2 )
{
if ( b4->n_keys == 0 )
{
temp_fb = b4key( b4, 0 )->pointer ;
b4insert( b4, bdata->value, bdata->num, b4key( b4temp, b4temp->n_keys )->pointer / 512 ) ;
b4append( b4, temp_fb / 512 ) ;
}
else
b4insert( b4, bdata->value, bdata->num, b4key( b4temp, b4temp->n_keys )->pointer / 512 ) ;
}
else
b4insert( b4, bdata->value, bdata->num, 0L ) ;
while ( b4temp->n_keys > avg && b4->n_keys < avg )
{
b4->key_on = 0 ;
b4temp->key_on = b4temp->n_keys - 1 ;
bdata = b4key( b4temp, b4temp->key_on ) ;
if ( balance_mode == 2 )
b4insert( b4, bdata->value, bdata->num, bdata->pointer / 512 ) ;
else
b4insert( b4, bdata->value, bdata->num, 0L ) ;
b4remove( b4temp ) ;
}
b4temp->key_on = b4temp->n_keys - 1 ;
}
else
{
b4go_eof( b4 ) ;
if ( balance_mode == 2 )
{
bdata = b4key( b4, b4->n_keys ) ;
bdata2 = b4key( parent, parent->key_on ) ;
memcpy( bdata->value, bdata2->value, t4->header.key_len ) ;
memcpy( &(bdata->num), &bdata2->num, sizeof( long ) ) ;
b4->n_keys++ ;
}
else
{
bdata = b4key( parent, parent->key_on ) ;
b4insert( b4, bdata->value, bdata->num, 0L ) ;
}
while ( b4->n_keys - (balance_mode == 2) < avg )
{
b4go_eof( b4 ) ;
b4temp->key_on = 0 ;
bdata = b4key( b4temp, b4temp->key_on ) ;
if ( balance_mode == 2 )
b4insert( b4, bdata->value, bdata->num, bdata->pointer / 512 ) ;
else
b4insert( b4, bdata->value, bdata->num, 0L ) ;
b4remove( b4temp ) ;
}
if ( balance_mode == 2 )
{
b4->n_keys-- ;
b4->key_on-- ;
}
b4temp->key_on = 0 ;
}
/* and add a key back to the parent */
bdata = b4key( parent, parent->key_on ) ;
if ( balance_mode == 2 )
{
if ( is_right )
bdata2 = b4key( b4temp, b4temp->n_keys - 1 ) ;
else
bdata2 = b4key( b4, b4->n_keys ) ;
memcpy( bdata->value, bdata2->value, t4->header.key_len ) ;
memcpy( &(bdata->num), &bdata2->num, sizeof( long ) ) ;
if ( is_right )
{
b4temp->key_on = b4temp->n_keys ;
b4remove( b4temp ) ;
}
}
else
{
bdata2 = b4key( b4temp, b4temp->key_on ) ;
memcpy( bdata->value, bdata2->value, t4->header.key_len ) ;
memcpy( &(bdata->num), &bdata2->num, sizeof( long ) ) ;
b4remove( b4temp ) ;
}
parent->changed = 1 ;
b4flush( b4temp ) ;
}
}
return 0 ;
}
static int t4balance_branch_leaf( TAG4 *t4, B4BLOCK *parent, B4BLOCK *branch, B4BLOCK *leaf )
{
B4BLOCK *b4temp ;
long new_file_block ;
B4KEY_DATA *key ;
t4->header.version++ ;
new_file_block = t4extend( t4 ) ;
b4temp = b4alloc( t4, new_file_block ) ;
if ( b4temp == 0 )
return -1 ;
key = b4key( b4temp, 0 ) ;
key->pointer = leaf->file_block * I4MULTIPLY ;
b4temp->changed = 1 ;
key = b4key( parent, parent->key_on ) ;
#ifdef S4DEBUG_DEV
if ( key->pointer != leaf->file_block * I4MULTIPLY )
e4severe( e4info, "t4balance_branch_leaf - corruption" ) ;
#endif
key->pointer = new_file_block * I4MULTIPLY ;
parent->changed = 1 ;
l4add( &t4->blocks, b4temp ) ;
return t4balance_block( t4, parent, b4temp, branch, 1, 2 ) ;
}
/* if do_full 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 S4FUNCTION t4balance( TAG4 *t4, B4BLOCK *b4, int do_full )
{
B4BLOCK *b4temp, *parent ;
long temp_fb ;
int rc, i ;
char is_right, balance_mode ; /* balance_mode = 0 for done, 1 for leaf, and 2 for branch */
if ( !b4leaf( b4 ) )
return 0 ;
b4temp = b4alloc( t4, 0L ) ;
if ( b4temp == 0 )
return -1 ;
if ( do_full )
{
t4up_to_root( t4 ) ;
balance_mode = 2 ; /* branch */
}
else
balance_mode = 1 ; /* leaf */
while ( balance_mode != 0 || do_full )
{
if ( do_full )
{
parent = (B4BLOCK *)t4->blocks.last_node ;
parent->key_on = parent->n_keys ;
rc = t4down( t4 ) ;
if ( rc == 1 ) /* make sure siblings are also leafs */
{
t4up( t4 ) ;
parent = (B4BLOCK *)t4->blocks.last_node ;
if ( parent != 0 )
{
if ( parent->key_on > 0 )
{
temp_fb = (long)b4key( parent, parent->key_on - 1 )->pointer ;
if ( i4read_block( &t4->file, temp_fb, 0, b4temp ) < 0 )
{
b4free( b4temp ) ;
return -1 ;
}
if ( b4leaf( b4temp ) == 0 && b4leaf( b4 ) == 1 )
{
rc = t4balance_branch_leaf( t4, parent, b4temp, b4 ) ;
b4free( b4temp ) ;
return rc ;
}
}
}
break ;
}
if ( rc < 0 )
return -1 ;
b4 = (B4BLOCK *)t4->blocks.last_node ;
b4->key_on = b4->n_keys ;
if ( b4->n_keys >= t4->header.keys_half )
continue ;
if ( b4leaf( b4 ) )
balance_mode = 1 ;
temp_fb = b4key( parent, parent->key_on - 1 )->pointer ;
is_right = 1 ;
}
else
{
if ( balance_mode == 2 ) /* branch */
{
b4 = parent ;
while( t4->blocks.last_node != (LINK4 *)b4 ) /* re-align ourselves */
t4up( t4 ) ;
}
t4up( t4 ) ;
parent = (B4BLOCK *)t4->blocks.last_node ;
if ( parent == 0 ) /* root block */
{
t4down( t4 ) ;
parent = (B4BLOCK *)t4->blocks.last_node ;
if ( !b4leaf( parent ) && parent->n_keys == 0 ) /* remove */
{
temp_fb = (long)b4key( parent, 0 )->pointer ;
t4shrink( t4, parent->file_block ) ;
t4up( t4 ) ;
l4pop( &t4->saved ) ;
parent->changed = 0 ;
b4free( parent ) ;
t4->header.root = temp_fb ;
t4down( t4 ) ;
}
break ;
}
if ( parent->n_keys == 0 ) /* try to replace parent with ourself */
{
#ifdef S4DEBUG
e4severe( e4info, E4_INFO_CIF ) ;
#endif
return -1 ;
}
if ( b4->n_keys >= t4->header.keys_half )
{
balance_mode = 0 ;
continue ;
}
is_right = (parent->key_on == parent->n_keys ) ;
if ( is_right )
temp_fb = b4key( parent, parent->key_on - 1 )->pointer ;
else
temp_fb = b4key( parent, parent->key_on + 1 )->pointer ;
}
b4temp->file_block = temp_fb ;
for ( ;; )
{
if ( i4read_block( &t4->file, temp_fb, 0, b4temp ) < 0 )
{
b4free( b4temp ) ;
return -1 ;
}
if ( balance_mode == 2 || b4leaf( b4temp ) ) /* if branch mode or leaf mode and leaf block found */
break ;
if ( is_right )
temp_fb = b4key( b4temp, b4temp->n_keys )->pointer ;
else
temp_fb = b4key( b4temp, 0 )->pointer ;
}
if ( t4balance_block( t4, parent, b4, b4temp, is_right, balance_mode ) < 0 )
return -1 ;
if ( do_full )
{
if ( b4leaf( b4 ) )
balance_mode = 0 ;
}
else
{
if ( parent->n_keys < t4->header.keys_half ) /* do parent as well */
balance_mode = 2 ;
else
balance_mode = 0 ;
}
}
b4free( b4temp ) ;
return 0 ;
}
int S4FUNCTION t4get_replace_entry( TAG4 *t4, B4KEY_DATA *insert_spot, B4BLOCK *save_block )
{
int rc ;
B4BLOCK *block_on ;
block_on = save_block ;
if ( b4leaf( block_on ) )
return 0 ;
block_on->key_on = block_on->key_on + 1 ;
while ( !b4leaf( block_on ) )
{
rc = t4down( t4 ) ;
if ( rc < 0 || rc == 2 )
return -1 ;
block_on = (B4BLOCK *)t4->blocks.last_node ;
}
memcpy( &insert_spot->num, &(b4key( block_on, block_on->key_on )->num), sizeof(long) + t4->header.key_len ) ;
save_block->changed = 1 ;
b4remove( block_on ) ;
if ( block_on->n_keys < t4->header.keys_half && block_on->file_block != t4->header.root ) /* if not root may have to balance the tree */
if ( t4balance( t4, block_on, 0 ) < 0 )
return -1 ;
return 1 ;
}
int S4FUNCTION t4balance_branch( TAG4 *t4, B4BLOCK *b4 )
{
B4BLOCK *parent, *b4temp ;
int is_right ;
long temp_fb, reference ;
#ifdef S4DEBUG
if ( b4leaf( b4 ) )
e4severe( e4info, E4_T4BALANCE_BR ) ;
#endif
if ( b4 == (B4BLOCK *)l4first( &t4->blocks ) )
{
if ( b4->n_keys == 0 ) /* empty, so just remove */
{
reference = (long)b4key( b4, 0 )->pointer ;
b4->changed = 0 ;
t4shrink( t4, b4->file_block ) ;
t4up( t4 ) ;
l4pop(&t4->saved ) ;
t4->header.root = reference ;
}
return 0 ;
}
#ifdef S4DEBUG
if ( b4->n_keys < 2 )
e4severe( e4info, E4_T4BALANCE_BR ) ;
#endif
t4up( t4 ) ;
parent = (B4BLOCK *)t4->blocks.last_node ;
#ifdef S4DEBUG
if ( b4key( parent, parent->key_on )->pointer != I4MULTIPLY * b4->file_block )
e4severe( e4info, E4_T4BALANCE_BR ) ;
#endif
if ( parent->key_on == parent->n_keys )
{
temp_fb = b4key( parent, parent->key_on - 1 )->pointer ;
is_right = 1 ;
}
else
{
temp_fb = b4key( parent, parent->key_on + 1 )->pointer ;
is_right = 0 ;
}
b4temp = b4alloc( t4, 0L ) ;
if ( b4temp == 0 )
return -1 ;
if ( i4read_block( &t4->file, temp_fb, 0, b4temp ) < 0 )
{
b4free( b4temp ) ;
return -1 ;
}
if ( t4balance_block( t4, parent, b4, b4temp, is_right, 2 ) < 0 )
return -1 ;
b4free( b4temp ) ;
return 0 ;
}
int S4FUNCTION t4remove_current( TAG4 *t4 )
{
B4BLOCK *block_on ;
t4->header.version = (short)( t4->header.old_version + 1L ) ;
block_on = (B4BLOCK *)t4->blocks.last_node ;
#ifdef S4DEBUG
if ( b4lastpos( block_on ) == -b4leaf( block_on ) )
e4severe( e4info, E4_INFO_UNE ) ;
#endif
switch( t4get_replace_entry( t4, b4key( block_on, block_on->key_on ), block_on ) )
{
case 0 : /* leaf delete */
b4remove( block_on ) ;
if ( block_on->n_keys == 0 ) /* last entry deleted! -- remove upward reference */
{
if ( t4remove_ref( t4 ) != 0 )
return -1 ;
}
else
{
if ( block_on->n_keys < t4->header.keys_half && block_on->file_block != t4->header.root ) /* if not root may have to balance the tree */
return t4balance( t4, block_on, 0 ) ;
}
break ;
case 1 : /* branch delete */
/* block_on->changed = 1 ;*/ /* mark as changed for all entries */
if( t4block( t4 )->n_keys == 0 ) /* removed the last key of */
if ( t4remove_ref( t4 ) != 0 )
return -1 ;
break ;
default:
e4severe( e4info, E4_INFO_INT ) ;
break ;
}
return 0 ;
}
#endif /* S4CLIPPER */
#endif /* S4NDX */
#endif /* N4OTHER */
#endif /* S4INDEX_OFF */
#endif /* S4OFF_WRITE */