isrewrite.c File Reference

#include "isinternal.h"

Include dependency graph for isrewrite.c:

Go to the source code of this file.

Functions
static int	irowupdate (const int ihandle, char *pcrow, off_t trownumber)
int	isrewrite (const int ihandle, char *pcrow)
int	isrewcurr (const int ihandle, char *pcrow)
int	isrewrec (const int ihandle, const long long trownumber, char *pcrow)

Function Documentation

static int irowupdate ( const int  ihandle, char *  pcrow, off_t  trownumber  )

static

Definition at line 25 of file isrewrite.c.

References VBKEY::ckey, VBKEY::iisdummy, DICTINFO::inkeys, iserrno, ivbkeydelete(), ivbkeyinsert(), ivbkeyload(), ivbkeylocaterow(), ivbkeysearch(), NULL, DICTINFO::ppcrowbuffer, VBTREE::pskeycurr, DICTINFO::pskeycurr, DICTINFO::pskeydesc, VBKEY::psnext, VBKEY::psparent, psvbfile, VBKEY::tdupnumber, VBKEY::trownode, and vvbmakekey().

Referenced by isrewcurr(), isrewrec(), and isrewrite().

{
    struct VBKEY    *pskey;
    struct DICTINFO *psvbptr;
    struct keydesc  *pskeyptr;
    off_t       tdupnumber = 0;
    int     ikeynumber, iresult;
    unsigned char   ckeyvalue[VB_MAX_KEYLEN];

    psvbptr = psvbfile[ihandle];
    /*
     * Step 1:
     *      For each index that's changing, confirm that the NEW value
     *      doesn't conflict with an existing ISNODUPS flag.
     */
    for (ikeynumber = 0; ikeynumber < psvbptr->inkeys; ikeynumber++) {
        pskeyptr = psvbptr->pskeydesc[ikeynumber];
        if (pskeyptr->k_nparts == 0) {
            continue;
        }
        if (pskeyptr->k_flags & ISDUPS) {
            continue;
        }
        vvbmakekey (pskeyptr, pcrow, ckeyvalue);
        iresult = ivbkeysearch (ihandle, ISGTEQ, ikeynumber, 0, ckeyvalue, (off_t)0);
        if (iresult != 1
            || trownumber == psvbptr->pskeycurr[ikeynumber]->trownode
            || psvbptr->pskeycurr[ikeynumber]->iisdummy) {
            continue;
        }
        iserrno = EDUPL;
        return -1;
    }

    /*
     * Step 2:
     *      Check each index for existance of trownumber
     *      This 'preload' additionally helps determine which indexes change
     */
    for (ikeynumber = 0; ikeynumber < psvbptr->inkeys; ikeynumber++) {
        pskeyptr = psvbptr->pskeydesc[ikeynumber];
        if (pskeyptr->k_nparts == 0) {
            continue;
        }
        if (ivbkeylocaterow (ihandle, ikeynumber, trownumber)) {
            iserrno = EBADFILE;
            return -1;
        }
    }

    /*
     * Step 3:
     *      Perform the actual deletion / insertion with each index
     *      But *ONLY* for those indexes that have actually CHANGED!
     */
    for (ikeynumber = 0; ikeynumber < psvbptr->inkeys; ikeynumber++) {
        pskeyptr = psvbptr->pskeydesc[ikeynumber];
        if (pskeyptr->k_nparts == 0) {
            continue;
        }
        /* pcrow is the UPDATED key! */
        vvbmakekey (pskeyptr, pcrow, ckeyvalue);
        if (!memcmp (ckeyvalue, psvbptr->pskeycurr[ikeynumber]->ckey,
                (size_t)pskeyptr->k_len)) {
            continue;
        }
        /* If NEW key is DIFFERENT than CURRENT, remove CURRENT */
        iresult = ivbkeydelete (ihandle, ikeynumber);
        if (iresult) {
            /* An error occured.  Let's put back what we removed! */
            while (ikeynumber >= 0) {
/* BUG - We need to do SOMETHING sane here? Dunno WHAT */
                ivbkeyinsert (ihandle, NULL, ikeynumber, ckeyvalue,
                          trownumber, tdupnumber, NULL);
                ikeynumber--;
                vvbmakekey (pskeyptr,
                        psvbptr->ppcrowbuffer, ckeyvalue);
            }
            iserrno = EBADFILE;
            return -1;
        }
        iresult = ivbkeysearch (ihandle, ISGREAT, ikeynumber, 0, ckeyvalue, (off_t)0);
        tdupnumber = 0;
        if (iresult >= 0) {
            iresult = ivbkeyload (ihandle, ikeynumber, ISPREV, 1, &pskey);
            if (!iresult) {
                if (pskeyptr->k_flags & ISDUPS
                    && !memcmp (pskey->ckey, ckeyvalue,
                        (size_t)pskeyptr->k_len)) {
                    tdupnumber = pskey->tdupnumber + 1;
                }
                psvbptr->pskeycurr[ikeynumber] =
                    psvbptr->pskeycurr[ikeynumber]->psnext;
                psvbptr->pskeycurr[ikeynumber]->psparent->pskeycurr =
                    psvbptr->pskeycurr[ikeynumber];
            }
            iresult = ivbkeysearch (ihandle, ISGTEQ, ikeynumber, 0, ckeyvalue,
                      tdupnumber);
            iresult = ivbkeyinsert (ihandle, NULL, ikeynumber, ckeyvalue,
                      trownumber, tdupnumber, NULL);
        }
        if (iresult) {
            /* An error occured.  Let's remove what we added */
            while (ikeynumber >= 0) {
/* BUG - This is WRONG, we should re-establish what we had before! */
                /* ivbkeydelete (ihandle, ikeynumber); */
                ikeynumber--;
            }
            return iresult;
        }
    }

    iserrno = 0;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int isrewcurr	(	const int	ihandle,
		char *	pcrow
	)

Definition at line 235 of file isrewrite.c.

References DICTINFO::iisdictlocked, DICTINFO::imaxrowlength, DICTINFO::iminrowlength, DICTINFO::iopenmode, irowupdate(), iserrno, isreclen, isrecnum, ivbdatalock(), ivbdataread(), ivbdatawrite(), ivbenter(), ivbexit(), ivbtransupdate(), DICTINFO::ppcrowbuffer, psvbfile, DICTINFO::trownumber, and VBWRLOCK.

Referenced by indexed_rewrite().

{
    struct DICTINFO *psvbptr;
    int     ideleted, inewreclen, ioldreclen = 0, iresult = 0;

    if (ivbenter (ihandle, 1, 0)) {
        return -1;
    }

    psvbptr = psvbfile[ihandle];
    if ((psvbptr->iopenmode & ISVARLEN) && (isreclen > psvbptr->imaxrowlength
        || isreclen < psvbptr->iminrowlength)) {
        iserrno = EBADARG;
        return -1;
    }

    inewreclen = isreclen;
    if (psvbptr->trownumber > 0) {
        if (psvbptr->iopenmode & ISTRANS) {
            iserrno = ivbdatalock (ihandle, VBWRLOCK, psvbptr->trownumber);
            if (iserrno) {
                iresult = -1;
                goto isrewcurr_exit;
            }
        }
        iserrno = ivbdataread (ihandle, psvbptr->ppcrowbuffer, &ideleted,
                 psvbptr->trownumber);
        if (!iserrno && ideleted) {
            iserrno = ENOREC;
        } else {
            ioldreclen = isreclen;
        }
        if (iserrno) {
            iresult = -1;
        }
        if (!iresult) {
            iresult = irowupdate (ihandle, pcrow, psvbptr->trownumber);
        }
        if (!iresult) {
            isrecnum = psvbptr->trownumber;
            isreclen = inewreclen;
            iresult = ivbdatawrite (ihandle, pcrow, 0, (off_t)isrecnum);
        }
        if (!iresult) {
            if (psvbptr->iopenmode & ISVARLEN) {
                iresult =
                    ivbtransupdate (ihandle, psvbptr->trownumber,
                            ioldreclen, inewreclen, pcrow);
            } else {
                iresult =
                    ivbtransupdate (ihandle, psvbptr->trownumber,
                            psvbptr->iminrowlength,
                            psvbptr->iminrowlength, pcrow);
            }
        }
    }
isrewcurr_exit:
    psvbptr->iisdictlocked |= 0x02;
    iresult |= ivbexit (ihandle);
    return iresult;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int isrewrec	(	const int	ihandle,
		const long long	trownumber,
		char *	pcrow
	)

Definition at line 298 of file isrewrite.c.

References DICTINFO::iisdictlocked, DICTINFO::imaxrowlength, DICTINFO::iminrowlength, DICTINFO::iopenmode, irowupdate(), iserrno, isreclen, isrecnum, ivbdatalock(), ivbdataread(), ivbdatawrite(), ivbenter(), ivbexit(), ivbtransupdate(), DICTINFO::ppcrowbuffer, psvbfile, DICTINFO::trownumber, and VBWRLOCK.

Referenced by ircvupdate(), and ivbrollmeback().

{
    struct DICTINFO *psvbptr;
    int     ideleted, inewreclen, ioldreclen = 0, iresult = 0;

    if (ivbenter (ihandle, 1, 0)) {
        return -1;
    }

    psvbptr = psvbfile[ihandle];
    if ((psvbptr->iopenmode & ISVARLEN) && (isreclen > psvbptr->imaxrowlength
        || isreclen < psvbptr->iminrowlength)) {
        iserrno = EBADARG;
        return -1;
    }

    inewreclen = isreclen;
    if (trownumber < 1) {
        iresult = -1;
        iserrno = ENOREC;
    } else {
        if (psvbptr->iopenmode & ISTRANS) {
            iserrno = ivbdatalock (ihandle, VBWRLOCK, trownumber);
            if (iserrno) {
                iresult = -1;
                goto isrewrec_exit;
            }
        }
        iserrno = ivbdataread (ihandle, psvbptr->ppcrowbuffer, &ideleted,
                 trownumber);
        if (!iserrno && ideleted) {
            iserrno = ENOREC;
        }
        if (iserrno) {
            iresult = -1;
        } else {
            ioldreclen = isreclen;
        }
        if (!iresult) {
            iresult = irowupdate (ihandle, pcrow, trownumber);
        }
        if (!iresult) {
            isrecnum = trownumber;
            isreclen = inewreclen;
            iresult = ivbdatawrite (ihandle, pcrow, 0, (off_t)isrecnum);
        }
        if (!iresult) {
            if (psvbptr->iopenmode & ISVARLEN) {
                iresult = ivbtransupdate (ihandle, trownumber,
                        ioldreclen, inewreclen,
                        pcrow);
            } else {
                iresult = ivbtransupdate (ihandle, trownumber,
                        psvbptr->iminrowlength,
                        psvbptr->iminrowlength, pcrow);
            }
        }
    }
isrewrec_exit:
    if (!iresult) {
        psvbptr->iisdictlocked |= 0x02;
    }
    iresult |= ivbexit (ihandle);
    return iresult;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int isrewrite	(	const int	ihandle,
		char *	pcrow
	)

Definition at line 144 of file isrewrite.c.

References DICTINFO::iisdictlocked, DICTINFO::imaxrowlength, DICTINFO::iminrowlength, DICTINFO::iopenmode, irowupdate(), iserrno, isreclen, isrecnum, ivbdatalock(), ivbdataread(), ivbdatawrite(), ivbenter(), ivbexit(), ivbkeysearch(), ivbtransupdate(), DICTINFO::ppcrowbuffer, DICTINFO::pskeycurr, DICTINFO::pskeydesc, psvbfile, VBKEY::trownode, DICTINFO::trownumber, VBWRLOCK, and vvbmakekey().

Referenced by indexed_rewrite().

{
    struct DICTINFO *psvbptr;
    off_t       trownumber;
    int     ideleted, inewreclen, ioldreclen = 0, iresult = 0;
    unsigned char   ckeyvalue[VB_MAX_KEYLEN];

    if (ivbenter (ihandle, 1, 0)) {
        return -1;
    }
    psvbptr = psvbfile[ihandle];
    if ((psvbptr->iopenmode & ISVARLEN) && (isreclen > psvbptr->imaxrowlength
        || isreclen < psvbptr->iminrowlength)) {
        iserrno = EBADARG;
        return -1;
    }

    inewreclen = isreclen;
    if (psvbptr->pskeydesc[0]->k_flags & ISDUPS) {
        iresult = -1;
        iserrno = ENOREC;
    } else {
        vvbmakekey (psvbptr->pskeydesc[0], pcrow, ckeyvalue);
        iresult = ivbkeysearch (ihandle, ISEQUAL, 0, 0, ckeyvalue, (off_t)0);
        switch (iresult) {
        case 1: /* Exact match */
            iresult = 0;
            psvbptr->iisdictlocked |= 0x02;
            trownumber = psvbptr->pskeycurr[0]->trownode;
            if (psvbptr->iopenmode & ISTRANS) {
                iserrno = ivbdatalock (ihandle, VBWRLOCK, trownumber);
                if (iserrno) {
                    iresult = -1;
                    goto isrewrite_exit;
                }
            }
            iserrno = ivbdataread (ihandle, psvbptr->ppcrowbuffer,
                     &ideleted, trownumber);
            if (!iserrno && ideleted) {
                iserrno = ENOREC;
            }
            if (iserrno) {
                iresult = -1;
            } else {
                ioldreclen = isreclen;
            }

            if (!iresult) {
                iresult = irowupdate (ihandle, pcrow, trownumber);
            }
            if (!iresult) {
                isrecnum = trownumber;
                isreclen = inewreclen;
                iresult =
                    ivbdatawrite (ihandle, pcrow, 0, (off_t)isrecnum);
            }
            if (!iresult) {
                if (psvbptr->iopenmode & ISVARLEN) {
                    iresult =
                        ivbtransupdate (ihandle, trownumber, ioldreclen,
                                inewreclen, pcrow);
                } else {
                    iresult =
                        ivbtransupdate (ihandle, trownumber,
                                psvbptr->iminrowlength,
                                psvbptr->iminrowlength,
                                pcrow);
                }
            }
            break;

        case 0: /* LESS than */
        case 2: /* GREATER than */
        case 3: /* EMPTY file */
            iserrno = ENOREC;
            iresult = -1;
            break;

        default:
            iserrno = EBADFILE;
            iresult = -1;
            break;
        }
    }

isrewrite_exit:
    iresult |= ivbexit (ihandle);
    return iresult;
}

Here is the call graph for this function:

Here is the caller graph for this function: