currency.c

来自「db.* (pronounced dee-be star) is an adva」· C语言 代码 · 共 827 行 · 第 1/2 页

/***************************************************************************
 *                                                                         *
 * db.*                                                                    *
 * open source database kernel                                             *
 *                                                                         *
 * Copyright (c) 2000 Centura Software Corporation. All rights reserved.   *
 *                                                                         *
 * Use of this software, whether in source code format, or in executable,  *
 * binary object code form, is governed by the CENTURA OPEN SOURCE LICENSE *
 * which is fully described in the LICENSE.TXT file, included within this  *
 * distribution of source code files.                                      * 
 *                                                                         *
 **************************************************************************/

#include "db.star.h"

/* ======================================================================
    Test timestamp status of current member
*/
int INTERNAL_FCN dcmstat(int set, DB_TASK *task, int dbn)
{
    DB_ULONG cts, dbuts;
    DB_ULONG cmts;

    if (dctscm(set, &cts, task, dbn) == S_OKAY)
    {
        if (cts)
        {
            cmts = task->cm_time[NUM2INT(set - SETMARK, st_offset)];
            if (cts > cmts)
                task->db_status = S_DELETED;
            else
            {
                dutscm(set, &dbuts, task, dbn);
                if (dbuts > cmts)
                    task->db_status = S_UPDATED;
            }
        }
        else
            dberr(S_TIMESTAMP);
    }
    return (task->db_status);
}


/* ======================================================================
    Get current member type
*/
int INTERNAL_FCN dcmtype(int set, int *cmtype, DB_TASK *task, int dbn)
{
    char *mrec;
    short crt;
    SET_ENTRY *set_ptr;
    int dbopen_sv;

    if (nset_check(set, &set, (SET_ENTRY **) &set_ptr, task) == S_OKAY)
    {
        if (!task->curr_mem[set])
            dberr(S_NOCM);
        else
        {
            /* set up to allow unlocked read */
            dbopen_sv = task->dbopen;
            task->dbopen = 2;

            /* Read current member */
            if (dio_read(task->curr_mem[set], (char **) &mrec,
                         NOPGHOLD, task) == S_OKAY)
            {
                /* Fetch record type from record header */
                memcpy(&crt, mrec, sizeof(short));
                if (dio_release(task->curr_mem[set], NOPGFREE, task) == S_OKAY)
                {
                    crt &= ~RLBMASK;                 /* mask off rlb */
                    *cmtype = (int) crt + RECMARK;
                }
            }

            task->dbopen = dbopen_sv;
        }
    }

    return (task->db_status);
}


/* ======================================================================
    Test timestamp status of current owner
*/
int INTERNAL_FCN dcostat(int set, DB_TASK *task, int dbn)
{
    DB_ULONG cts, dbuts;
    DB_ULONG cots;

    if (dctsco(set, &cts, task, dbn) == S_OKAY)
    {
        if (cts)
        {
            cots = task->co_time[NUM2INT(set - SETMARK, st_offset)];
            if (cts > cots)
                task->db_status = S_DELETED;
            else
            {
                dutsco(set, &dbuts, task, dbn);
                if (dbuts > cots)
                    task->db_status = S_UPDATED;
            }
        }
        else
            dberr(S_TIMESTAMP);
    }

    return (task->db_status);
}


/* ======================================================================
    Get current owner type
*/
int INTERNAL_FCN dcotype(int set, int *cotype, DB_TASK *task, int dbn)
{
    char *orec;
    short crt;
    int dbopen_sv;
    SET_ENTRY *set_ptr;

    if (nset_check(set, &set, (SET_ENTRY **) &set_ptr, task) == S_OKAY)
    {
        if (!task->curr_own[set])
            dberr(S_NOCO);
        else
        {
            /* set up to allow unlocked read */
            dbopen_sv = task->dbopen;
            task->dbopen = 2;

            /* Read current owner */
            if (dio_read(task->curr_own[set], (char **) &orec,
                         NOPGHOLD, task) == S_OKAY)
            {
                /* Fetch record type from record header */
                memcpy(&crt, orec, sizeof(short));
                if (dio_release(task->curr_own[set], NOPGFREE, task) == S_OKAY)
                {
                    crt &= ~RLBMASK;                 /* mask off rlb */
                    *cotype = (int) crt + RECMARK;
                }
            }

            task->dbopen = dbopen_sv;
        }
    }

    return (task->db_status);
}


/* ======================================================================
    Get current record
*/
int INTERNAL_FCN dcrget(DB_ADDR *dba, DB_TASK *task, int dbn)
{
    if ((*dba = task->curr_rec) == NULL_DBA)
        task->db_status = S_NOCR;

    return (task->db_status);
}


/* ======================================================================
    Read data from field  of current record
*/
int INTERNAL_FCN dcrread(
    long field,             /* Field constant */
    void *data,             /* Data area to contain field contents */
    DB_TASK *task,
    int dbn)
{
    int fld, rec, stat;
    int dbopen_sv;
    RECORD_ENTRY *rec_ptr;
    FIELD_ENTRY *fld_ptr;

    if (nfld_check(field, &rec, &fld, &rec_ptr, &fld_ptr, task) != S_OKAY)
        return (task->db_status);

    /* Make sure we have a current record */
    if (!task->curr_rec)
        return (dberr(S_NOCR));

    if (check_dba(task->curr_rec, task) != S_OKAY)
        return (task->db_status);

    /* set up to allow unlocked read */
    dbopen_sv = task->dbopen;
    task->dbopen = 2;

    /* Read current record */
    dio_read(task->curr_rec, (char **) &task->crloc, NOPGHOLD, task);
    task->dbopen = dbopen_sv;
    if (task->db_status != S_OKAY)
        return (task->db_status);

    /* Get data from record */
    stat = r_gfld(fld_ptr, task->crloc, data, task);

    if (dio_release(task->curr_rec, NOPGFREE, task) != S_OKAY)
        return (task->db_status);

    /* set timestamp */
    if (task->db_tsrecs && (stat == S_OKAY))
        dutscr(&task->cr_time, task, dbn);

    return stat;
}


/* ======================================================================
    Set current record
*/
int INTERNAL_FCN dcrset(DB_ADDR *dba, DB_TASK *task, int dbn)
{
    short crt;
    int dbopen_sv;

    if (dba == NULL || *dba == NULL_DBA)
    {
        task->curr_rec = NULL_DBA;
        return (task->db_status);
    }

    if (check_dba(*dba, task) != S_OKAY)
        return (task->db_status);

    task->curr_rec = *dba;
    /* check to make sure the record is not deleted */
    dbopen_sv = task->dbopen;
    task->dbopen = 2;                         /* setup to allow unlocked read */
    dio_read(*dba, (char **) &task->crloc, NOPGHOLD, task);
    task->dbopen = dbopen_sv;
    if (task->db_status != S_OKAY)
        return (task->db_status);

    memcpy(&crt, task->crloc, sizeof(short));
    if (dio_release(*dba, NOPGFREE, task) != S_OKAY)
        return (task->db_status);

    /* non-negative record type means not deleted */
    if (crt < 0)
    {
        /* the record is deleted */
        task->curr_rec = NULL_DBA;
        return (task->db_status = S_DELETED);
    }

    return (task->db_status);
}


/* ======================================================================
    Test timestamp status of current record
*/
int INTERNAL_FCN dcrstat(DB_TASK *task, int dbn)
{
    DB_ULONG cts, dbuts;

    if (dctscr(&cts, task, dbn) == S_OKAY)
    {
        if (cts)
        {
            dutscr(&dbuts, task, dbn);
            if (cts > task->cr_time)
                task->db_status = S_DELETED;
            else if (dbuts > task->cr_time)
                task->db_status = S_UPDATED;
        }
        else
            dberr(S_TIMESTAMP);
    }

    return (task->db_status);
}


/* ======================================================================
    Get current record type
*/
int INTERNAL_FCN dcrtype(int *crtype, DB_TASK *task, int dbn)
{
    short crt;
    int dbopen_sv;

    if (!task->curr_rec)
        dberr(S_NOCR);
    else
    {
        dbopen_sv = task->dbopen; /* set up to allow unlocked read */
        task->dbopen = 2;

        /* Read current record */
        if (dio_read(task->curr_rec, (char **) &task->crloc, NOPGHOLD, task) == S_OKAY)
        {
            /* Fetch record type from record header */
            memcpy(&crt, task->crloc, sizeof(short));

            if (dio_release(task->curr_rec, NOPGFREE, task) == S_OKAY)
            {
                if (crt < 0)
                {
                    /* Current record is deleted */
                    task->curr_rec = NULL_DBA;
                    task->dbopen = dbopen_sv;
                    return (task->db_status = S_DELETED);
                }
                crt &= ~RLBMASK;                 /* mask off rlb */
                *crtype = (int) crt + RECMARK;
            }
        }
        task->dbopen = dbopen_sv;
    }

    return (task->db_status);
}


/* ======================================================================
    Write data to a field  in the current record
*/
int INTERNAL_FCN dcrwrite(
    long     field,          /* field constant */
    void    *data,           /* data area to contain field contents */
    DB_TASK *task,
    int      dbn)            /* database number */
{
    DB_ULONG timestamp;
    int rec, fld;
    RECORD_ENTRY *rec_ptr;
    FIELD_ENTRY *fld_ptr;

    if (nfld_check(field, &rec, (int *) &fld,
            (RECORD_ENTRY **) &rec_ptr,
            (FIELD_ENTRY **) &fld_ptr, task) != S_OKAY)
    {
        return (task->db_status);
    }

    /* compound keys cannot be updated directly */
    if (fld_ptr->fd_type == COMKEY)
        return (dberr(S_ISCOMKEY));

    /* field used in compound keys cannot be updated directly */
    if (fld_ptr->fd_flags & COMKEYED)
        return (dberr(S_COMKEY));

    /* Make sure we have a current record */
    if (!task->curr_rec)
    {
        return (dberr(S_NOCR));
    }
    else if (check_dba(task->curr_rec, task) != S_OKAY)
    {
        return (task->db_status);
    }

    /* Read current record */
    if (dio_read(task->curr_rec, (char **) &task->crloc, PGHOLD, task) != S_OKAY)
        return (task->db_status);

    /* check out the field */
    if (r_chkfld((short)fld, fld_ptr, task->crloc, data, task) != S_OKAY)
    {
        dio_release(task->curr_rec, PGFREE, task);
        return (task->db_status);
    }

    /* put data into record and return */
    if (r_pfld((short)fld, fld_ptr, task->crloc, data, &task->curr_rec, task) != S_OKAY)
    {
        dio_release(task->curr_rec, PGFREE, task);
        return (task->db_status);
    }

    /* check for timestamp */
    if (rec_ptr->rt_flags & TIMESTAMPED)
    {
        timestamp = dio_pzgetts(rec_ptr->rt_file, task);
        memcpy(task->crloc + RECUPTIME, &timestamp, sizeof(long));
    }

    dio_write(task->curr_rec, PGFREE, task);

    if ((task->db_status == S_OKAY) && (rec_ptr->rt_flags & TIMESTAMPED))
        task->cr_time = timestamp;

    return (task->db_status);
}


/* ======================================================================
    Get current set member
*/
int INTERNAL_FCN dcsmget(
    int      set,          /* Set table entry */
    DB_ADDR *dba,          /* db address of record to become current */
    DB_TASK *task,
    int      dbn)          /* database number */
{
    SET_ENTRY *set_ptr;

    if (nset_check(set, &set, &set_ptr, task) != S_OKAY)
        return (task->db_status);

    if ((*dba = task->curr_mem[set]) == NULL_DBA)
        task->db_status = S_NOCM;