#include "ccommon.h"
#include "genconst.h"
#include "ccustio.h"
#include "cbpltree.h"
#include "bplpriv.h"
#include "btrread.h"
#include "btrbase.h"
#include "checks.h"
#ifdef __WATCOMC__
#include <malloc.h>
#else
#include <memory.h>
#endif
void Move(byte ,int ,int ,int ,char *,char *);
/*
@(SHF) Funzioni di base per il B+Tree
@($) ZPage B+TREE
@(ID)
Azzera una pagina del B+TREE.
@(FD)
*/
void ZPage(ActPage)
Page *ActPage; /* pagina attuale */
{
ActPage->PA.PageHeader.TPage = EmptyPage;
ActPage->PA.PageHeader.PathNumber = 0;
ActPage->PA.PageHeader.Flags = 0;
ActPage->PA.PageHeader.Father = NoLink;
ActPage->PA.PageHeader.Prev = NoLink;
ActPage->PA.PageHeader.Next = NoLink;
ActPage->PA.PageHeader.NKey = 0;
memset(ActPage->PA.AreaForKey, ' ', AreaLen);
}
/*
@($) GetHeader B+TREE
@(ID)
Legge l'header di un indice.
Restituisce il codice di errore.
@(FD)
@(ISV)
junk = variabile spazzatura per la chiamata della funzione "sleep".
w = descrittore della finestra.
@(FSV)
*/
int GetHeader(FilCheck, HPage, LockMode, Err)
FilCtrl *FilCheck; /* identificatore indice */
Page *HPage; /* pagina dell' indice */
int LockMode; /* lock sull'header */
int *Err; /* codice di errore */
{
do
{
CRead(&FilCheck->Fil, (char *) HPage, 1L, LockMode);
if (TESTLOCK(FilCheck->Fil.IOR))
message_box("Sono in attesa dell' indice");
} while TESTLOCK(FilCheck->Fil.IOR);
return((*Err = FilCheck->Fil.IOR));
}
/*
@($) PutHeader B+TREE
@(ID)
Scrive l'header di un indice.
Restituisce il codice di errore.
@(FD)
*/
int PutHeader(FilCheck, HPage, LockMode, Err)
FilCtrl *FilCheck; /* identificatore indice */
Page *HPage; /* pagina in cui scrivere l'header */
int LockMode; /* lock sull'header */
int *Err; /* errore */
{
CWrite(&FilCheck->Fil, (char *) HPage, 1L, LockMode);
return((*Err = FilCheck->Fil.IOR));
}
/*
@($) GetAPage B+TREE
@(ID)
Legge una pagina generica dell'indice.
Restituisce il codice di errore.
@(FD)
*/
int GetAPage(FilCheck, ActPage, Pg, Err)
FilCtrl *FilCheck; /* identificatore indice */
Page *ActPage; /* pagina letta */
RecNoType Pg; /* numero di pagina */
int *Err; /* codice di errore */
{
CRead(&FilCheck->Fil, (char *) ActPage, Pg + FilCheck->FHead.CABlock + 1,
NoLock);
return((*Err = FilCheck->Fil.IOR));
}
/*
@($) PutAPage B+TREE
@(ID)
Scrive una pagina generica dell'indice.
Restituisce il codice di errore.
@(FD)
*/
int PutAPage(FilCheck, ActPage, Pg, Err)
FilCtrl *FilCheck; /* identificatore indice */
Page *ActPage; /* pagina attiva */
RecNoType Pg; /* numero della pagina */
int *Err; /* codice errore */
{
CWrite(&FilCheck->Fil, (char *) ActPage, Pg + FilCheck->FHead.CABlock + 1,
NoLock);
return((*Err = FilCheck->Fil.IOR));
}
/*
@($) GetAKey B+TREE
@(ID)
Estrae una chiave da una pagina.
@(FD)
@(ISV)
BgnItem = numero di byte precedenti alla chiave dall'inizio della pagina.
@(FSV)
*/
void GetAKey(ActPage, KeyLen, Pstion, KKey, Index)
Page ActPage; /* pagina attiva */
int KeyLen; /* lunghezza della chiave */
int Pstion; /* numero chiave nella pagina */
TKey KKey; /* Valore chiave (in output) */
RecNoType *Index; /* indice associato a questa chiave */
{
int BgnItem;
BgnItem = (Pstion - 1) * (KeyLen + IndLen);
strcpy(KKey, (char *)(ActPage.PA.AreaForKey + BgnItem));
*Index = *((RecNoType *)(ActPage.PA.AreaForKey + BgnItem + KeyLen));
}
/*
@($) PutAKey B+TREE
@(ID)
Mette una chiave in una pagina.
@(FD)
@(ISV)
BgnItem = numero di byte precedenti alla chiave dall'inizio della pagina.
@(FSV)
*/
void PutAKey(KKey, Index, Pstion, KeyLen, ActPage)
TKey KKey; /* valore della chiave */
RecNoType Index; /* indice */
int Pstion; /* posizione nella quale scrivere la chiave */
int KeyLen; /* lunghezza della chiave */
Page *ActPage;/* pagina attiva */
{
register int BgnItem;
BgnItem = (Pstion - 1) * (KeyLen + IndLen);
strcpy((char *)(ActPage->PA.AreaForKey + BgnItem), KKey);
*((RecNoType *)(ActPage->PA.AreaForKey + BgnItem + KeyLen)) = Index;
}
/*
@($) Repos B+TREE
@(ID)
Riposizione all'ultima chiave letta dall'ultima operazione.
@(FD)
@(ISV)
WKey, WKey1 = variabili di lavoro contenenti chiavi.
WPos = variabile di lavoro contenente il numero di chiave nella pagina.
WPag = variabile di lavoro contenente il numero di pagina attuale.
WInd,WInd1 = variabili di lavoro contenenti indici associati alle chavi Wkey.
@(FSV)
@(IN)
Serve solo in multiutenza (XENIX).
@(FN)
*/
void Repos(FilCheck, BError)
FilCtrl *FilCheck; /* identificatore indice */
int *BError; /* codice errore (in output) */
{
TKey WKey, WKey1;
int WPos = FilCheck->Pos, WError;
RecNoType WPag = FilCheck->CurPag, WInd, WInd1;
if (GetAPage(FilCheck, &PathPage, WPag, BError) != NoErr) return;
if (PathPage.PA.PageHeader.NKey < WPos) WPos = PathPage.PA.PageHeader.NKey ;
GetAKey(PathPage, FilCheck->Base[FilCheck->PN].KeyLen, WPos, WKey, &WInd);
if ((strcmp(WKey, FilCheck->Key) == 0) && (WInd == FilCheck->Ind)) return ;
strcpy(WKey1, FilCheck->Key) ;
WInd = FilCheck->Ind ;
BTrRead(FilCheck, FilCheck->Key, WKey, &WInd1, BError) ;
WPag = FilCheck->CurPag ;
WPos = FilCheck->Pos ;
if (*BError == BTrEmptyTree) return ;
if (FilCheck->Base[FilCheck->PN].DupKeys == TRUE)
{
while ((strcmp(WKey, WKey1) == 0) && (WInd1 < WInd))
{
if (WPos < PathPage.PA.PageHeader.NKey) WPos++;
else
if (PathPage.PA.PageHeader.Next == NoLink) break;
else
{
WPag = PathPage.PA.PageHeader.Next;
if (GetAPage(FilCheck, &PathPage, WPag, BError) != NoErr) return;
WPos = 1;
}
GetAKey(PathPage, FilCheck->Base[FilCheck->PN].KeyLen, WPos, WKey, &WInd1);
}
}
if (GetAPage(FilCheck, &PathPage, WPag, &WError) != NoErr) return;
if ((strcmp(WKey, WKey1) == 0) && (WInd == WInd1))
{
FilCheck->CurPag = WPag;
FilCheck->Pos = WPos;
}
else
{
if (*BError != BTrEOF)
{
FilCheck->CurPag = WPag;
FilCheck->Pos = WPos;
strcpy(FilCheck->Key, WKey) ;
FilCheck->Ind = WInd1;
*BError = BTrKeyNotFound;
}
}
}
/*
@($) BTrNext B+TREE
@(ID)
Restituisce la chiave successiva all'ultima letta.
@(FD)
@(ISV)
WKey = variabile di lavoro contenente la chiave.
- Versione DOS e XENIX
@(FSV)
*/
void BTrNext(FilCheck, KKey, IndSr, BError)
FilCtrl *FilCheck; /* identificatore indice */
TKey KKey; /* valore della chiave */
RecNoType *IndSr; /* indice associato */
int *BError; /* codice errore */
{
TKey WKey;
if (FilCheck->CurPag == NoLink)
{
MaxKey(FilCheck->Base[FilCheck->PN].KeyLen, FilCheck->Key);
BTrRead(FilCheck, FilCheck->Key, WKey, IndSr, BError) ;
*BError = BTrEOF;
}
else
{
Repos(FilCheck, BError) ;
if (*BError != NoErr)
{
if (*BError == BTrKeyNotFound)
{
strcpy(KKey,FilCheck->Key);
*IndSr = FilCheck->Ind ;
*BError = NoErr ;
}
return;
}
if (FilCheck->Pos < PathPage.PA.PageHeader.NKey)
{
FilCheck->Pos++;
GetAKey(PathPage, FilCheck->Base[FilCheck->PN].KeyLen, FilCheck->Pos, FilCheck->Key, IndSr);
}
else
{
if (PathPage.PA.PageHeader.Next == NoLink)
{
GetAKey(PathPage, FilCheck->Base[FilCheck->PN].KeyLen, FilCheck->Pos, FilCheck->Key, IndSr);
/*MaxKey(FilCheck->Base[FilCheck->PN].KeyLen, FilCheck->Key);*/
*BError = BTrEOF;
}
else
{
FilCheck->CurPag = PathPage.PA.PageHeader.Next;
if (GetAPage(FilCheck, &PathPage, FilCheck->CurPag, BError) != NoErr) return;
FilCheck->Pos = 1;
GetAKey(PathPage, FilCheck->Base[FilCheck->PN].KeyLen, FilCheck->Pos, FilCheck->Key, IndSr);
}
}
strcpy(KKey,FilCheck->Key);
FilCheck->Ind = *IndSr ;
}
}
/*
@($) BTrPrev B+TREE
@(ID)
Restituisce la chiave successiva all'ultima.
@(FD)
@(ISV)
WKey = variabile di lavoro contenente una chiave.
- Versione DOS e XENIX
@(FSV)
*/
void BTrPrev(FilCheck, KKey, IndSr, BError)
FilCtrl *FilCheck; /* identificatore indice */
TKey KKey; /* valore della chiave (in output) */
RecNoType *IndSr; /* indice associato */
int *BError; /* codice di errore */
{
TKey WKey;
if (FilCheck->CurPag == NoLink)
{
MinKey(FilCheck->Base[FilCheck->PN].KeyLen, FilCheck->Key);
BTrRead(FilCheck, FilCheck->Key, WKey, IndSr, BError) ;
*BError = BTrBOF;
}
else
{
Repos(FilCheck, BError) ;
if ((*BError != NoErr) && (*BError != BTrKeyNotFound))
{
if (*BError == BTrEOF)
{
strcpy(KKey,FilCheck->Key);
*IndSr = FilCheck->Ind ;
*BError = NoErr ;
}
return;
}
*BError = NoErr;
if (FilCheck->Pos > 1)
{
FilCheck->Pos--;
GetAKey(PathPage, FilCheck->Base[FilCheck->PN].KeyLen, FilCheck->Pos, FilCheck->Key, IndSr);
}
else
{
if (PathPage.PA.PageHeader.Prev == NoLink)
{
GetAKey(PathPage, FilCheck->Base[FilCheck->PN].KeyLen, FilCheck->Pos, FilCheck->Key, IndSr);
/*MinKey(FilCheck->Base[FilCheck->PN].KeyLen, FilCheck->Key);*/
*BError = BTrBOF;
}
else
{
FilCheck->CurPag = PathPage.PA.PageHeader.Prev;
if (GetAPage(FilCheck, &PathPage, FilCheck->CurPag, BError) != NoErr) return;
FilCheck->Pos = PathPage.PA.PageHeader.NKey;
GetAKey(PathPage, FilCheck->Base[FilCheck->PN].KeyLen, FilCheck->Pos, FilCheck->Key, IndSr);
}
}
strcpy(KKey, FilCheck->Key);
FilCheck->Ind = *IndSr ;
}
}
/*
@($) Move B+TREE
@(ID)
Sposta a destra od a sinistra un numero di byte "NByt" da una sorgente "Buff1"
ad una destinazione "Buff2".
@(FD)
@(ISV)
w = area di transito.
@(FSV)
*/
void Move(RghOrLft, NByt, BytBeg, BytDest, Buff1, Buff2)
byte RghOrLft; /* destra o sinistra */
int NByt; /* numero di byte da spostare */
int BytBeg; /* num. byte inizio sorgente */
int BytDest; /* num. byte inizio destinazione */
AreaKey Buff1; /* sorgente */
AreaKey Buff2; /* destinazione */
{
AreaKey w;
memcpy(w, &Buff1[BytBeg], NByt);
memcpy(&Buff2[BytDest], w, NByt);
}
/*
@($) ShiftPage B+TREE
@(ID)
Esegue uno spostamento di un certo numero di posizioni (coppie chiave-puntatore)
all'interno della pagina.
@(FD)
@(ISV)
Len = lunghezza di una coppia chiave-puntatore.
Beg = numero di byte dall'inizio della pagina alla chiave "StartK" (esclusa).
Dest = byte al quale si deve postare la coppia chiave-puntatore.
@(FSV)
*/
void ShiftPage(RghOrLft, StartK, NPos, MxKey, KeyLen, Page1)
byte RghOrLft; /* destra o sinistra */
int StartK; /* chiave di partenza */
int NPos; /* numero di posizioni da saltare */
int MxKey; /* numero max chiavi in una pagina */
int KeyLen; /* lunghezza di una chiave */
Page *Page1; /* pagina attiva */
{
register int Len = KeyLen + IndLen;
register int Beg = (StartK - 1) * Len;
register int Dest;
if (RghOrLft == RightDir)
{
Dest = Beg + NPos * Len;
if (Page1->PA.PageHeader.NKey + NPos <= MxKey)
{
Move(RightDir, (Page1->PA.PageHeader.NKey - StartK + 1) * Len, Beg, Dest, Page1->PA.AreaForKey, Page1->PA.AreaForKey);
Page1->PA.PageHeader.NKey += NPos;
}
}
else
{
Dest = Beg - NPos * Len;
if (StartK - NPos > 0)
{
if (StartK <= Page1->PA.PageHeader.NKey)
Move(LeftDir, (Page1->PA.PageHeader.NKey - StartK + 1) * Len, Beg, Dest, Page1->PA.AreaForKey, Page1->PA.AreaForKey);
Page1->PA.PageHeader.NKey -= NPos;
memset(&Page1->PA.AreaForKey[Page1->PA.PageHeader.NKey * Len], ' ', NPos * Len);
}
}
}
/*
@($) ShiftOut B+TREE
@(ID)
Sposta un certo numero di chiavi da una pagina.
@(FD)
@(ISV)
Len = lunghezza coppia chiave-puntatore.
@(FSV)
*/
void ShiftOut(FromK, Numk, ToK, KeyLen, Page1, Page2)
int FromK; /* prima chiave da spostare */
int Numk; /* numero di chiavi da spostare */
int ToK; /* posizione nella pagina destinazione */
int KeyLen;/* lunghezza della chiave */
Page *Page1;/* puntatore alla pagina destinazione */
Page *Page2;/* puntatore alla pagina sorgente */
{
register int Len = KeyLen + IndLen;
if (Page1->PA.PageHeader.TPage == Page2->PA.PageHeader.TPage)
Move(LeftDir, Numk * Len, (FromK - 1) * Len, (ToK - 1) * Len, Page2->PA.AreaForKey, Page1->PA.AreaForKey);
}
/*
@($) FindPos B+TREE
@(ID)
Cerca una chiave all'interno di una pagina.
Restituisce la chiave piu' simile.
@(FD)
@(ISV)
low = numero della chiave.
j = incremento in byte di coppia chiave puntatore.
@(FSV)
*/
int FindPos(ActPage, KKey, KeyLen, KeyOut, IndOut)
Page *ActPage; /* pagina attiva */
TKey KKey; /* valore chiave (input) */
int KeyLen; /* lunghezza della chiave */
TKey KeyOut; /* valore chiave (output) */
RecNoType *IndOut; /* indice associato */
{
register int low = 1, j = 0;
while (strcmp((char *)(ActPage->PA.AreaForKey + j), KKey) < 0)
if (low < ActPage->PA.PageHeader.NKey)
{
low++;
j += (KeyLen + IndLen);
}
else break;
strcpy(KeyOut, (char *)(ActPage->PA.AreaForKey + j));
*IndOut = *((RecNoType *)(ActPage->PA.AreaForKey + j + KeyLen));
return(low);
}
/*
@($) PerformOp B+TREE
@(ID)
Effettua operazioni di Underflow e Overflow sull'indice.
@(FD)
@(ISV)
Pst = variabile di lavoro contenente numeri chiave.
W = contatore.
OldKey = variabile di lavoro contenente il valore di chiavi.
@(FSV)
*/
void PerformOp(RecOp,ActPage,Pg,OvUnFlow,Temp,MxKey,MnKey,KeyLen,BError)
KOp RecOp; /* struttura contenente le operazioni da effettuare */
Page *ActPage; /* pagina attiva */
RecNoType Pg; /* numero pagina */
BOOLEAN *OvUnFlow;/* underflow opp. overflow */
KeyInd *Temp; /* di lavoro, contiene una coppia chiave-puntatore */
int MxKey; /* numero max chiave */
int MnKey; /* numero min chiave */
int KeyLen; /* lunghezza della chiave */
int *BError; /* codice errore */
{
int Pst, W, i;
TKey OldKey;
for (W = 0; W <= 1; W++)
{
if (RecOp[W].FlagOp)
{
RecOp[W].FlagOp = FALSE;
if (RecOp[W].Which == Inser)
{
Pst = 0;
while (Pst < ActPage->PA.PageHeader.NKey )
{
GetAKey(*ActPage, KeyLen, ++Pst, IntKey, &IntIndex);
if (IntIndex == RecOp[W].where) break;
}
if (ActPage->PA.PageHeader.NKey == MxKey)
{
GetAKey(*ActPage, KeyLen, MxKey, IntKey, &IntIndex);
if (strcmp(IntKey, RecOp[W].KeyAndInd.KKey) < 0)
{
strcpy(Temp->KKey, RecOp[W].KeyAndInd.KKey);
Temp->Ind = RecOp[W].KeyAndInd.Ind;
}
else
{
strcpy(Temp->KKey, IntKey);
Temp->Ind = IntIndex;
ActPage->PA.PageHeader.NKey--;
ShiftPage(RightDir, Pst, OnePos, MxKey, KeyLen, ActPage);
PutAKey(RecOp[W].KeyAndInd.KKey, RecOp[W].KeyAndInd.Ind, Pst, KeyLen, ActPage);
}
*OvUnFlow = TRUE;
}
else
{
*OvUnFlow = FALSE;
if (strcmp(IntKey, RecOp[W].KeyAndInd.KKey) < 0)
{
ActPage->PA.PageHeader.NKey++;
PutAKey(RecOp[W].KeyAndInd.KKey, RecOp[W].KeyAndInd.Ind, ActPage->PA.PageHeader.NKey, KeyLen, ActPage);
RecOp[W].FlagOp = TRUE;
RecOp[W].Which = Change;
RecOp[W].KeyAndInd.Ind = Pg;
}
else
{
ShiftPage(RightDir, Pst, OnePos, MxKey, KeyLen, ActPage);
PutAKey(RecOp[W].KeyAndInd.KKey, RecOp[W].KeyAndInd.Ind, Pst, KeyLen, ActPage);
}
}
}
else
if (RecOp[W].Which == Change)
{
Pst = 0;
GetAKey(*ActPage, KeyLen, ++Pst, IntKey, &IntIndex);
while ((IntIndex != RecOp[W].KeyAndInd.Ind) && (Pst < ActPage->PA.PageHeader.NKey))
GetAKey(*ActPage, KeyLen, ++Pst, IntKey, &IntIndex);
if (IntIndex == RecOp[W].KeyAndInd.Ind)
PutAKey(RecOp[W].KeyAndInd.KKey, IntIndex, Pst, KeyLen, ActPage);
*OvUnFlow = FALSE;
if ((IntIndex == RecOp[W].KeyAndInd.Ind) && (Pst == ActPage->PA.PageHeader.NKey))
{
RecOp[W].FlagOp = TRUE;
RecOp[W].Which = Change;
RecOp[W].KeyAndInd.Ind = Pg;
}
}
else
if (RecOp[W].Which == Delet)
{
Pst = 0;
GetAKey(*ActPage, KeyLen, ++Pst, IntKey, &IntIndex);
while ((IntIndex != RecOp[W].KeyAndInd.Ind) && (Pst < ActPage->PA.PageHeader.NKey))
GetAKey(*ActPage, KeyLen, ++Pst, IntKey, &IntIndex);
if (IntIndex == RecOp[W].KeyAndInd.Ind)
{
*OvUnFlow = (ActPage->PA.PageHeader.NKey == MnKey);
ShiftPage(LeftDir, ++Pst, OnePos, MxKey, KeyLen, ActPage);
}
}
if ((!OvUnFlow) && (Pst >= ActPage->PA.PageHeader.NKey))
{
RecOp[W].FlagOp = TRUE;
RecOp[W].Which = Change;
GetAKey(*ActPage, KeyLen, ActPage->PA.PageHeader.NKey, IntKey, &IntIndex);
strcpy(RecOp[W].KeyAndInd.KKey, IntKey);
RecOp[W].KeyAndInd.Ind = Pg;
}
}
}
}
/*
@($) ZrecOp B+TREE
@(ID)
Azzera la struttura delle operazioni da effettuare.
@(FD)
@(ISV)
i = contatore.
@(FSV)
*/
void ZRecOp(R)
KOp R; /* struttura operazioni da azzerare */
{
int i;
for (i = 0; i <= 1; i++)
{
R[i].FlagOp = FALSE;
R[i].Which = Nothing;
R[i].Posit = NoLink;
R[i].where = -1;
MinKey(MaxArray, R[i].KeyAndInd.KKey);
R[i].KeyAndInd.Ind = NoLink;
}
}