sets.c

来自「db.* (pronounced dee-be star) is an adva」· C语言 代码 · 共 656 行 · 第 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"

/* ======================================================================
    Set current member to current member
*/
int INTERNAL_FCN dsetmm(
    int sett,                   /* set table entry number of target member */
    int sets,                   /* set table entry number of source member */
    DB_TASK *task,
    int dbn)                    /* database number */
{
    int cmtype;                 /* current member type */
    int mem, memtot;
    SET_ENTRY *set_ptr;
    int dbopen_sv;

    if (dcmtype(sets, &cmtype, task, dbn) == S_OKAY &&
        nset_check(sett, &sett, &set_ptr, task) == S_OKAY)
    {
        cmtype += task->curr_db_table->rt_offset - RECMARK;
        sets   += task->curr_db_table->st_offset - SETMARK;

        for ( mem = set_ptr->st_members, memtot = mem + set_ptr->st_memtot;
              mem < memtot; ++mem)
        {
            if (task->member_table[mem].mt_record == cmtype)
            {
                dbopen_sv = task->dbopen;
                task->dbopen = 2;                /* setup to allow unlocked read */
                r_smem(&task->curr_mem[sets], sett, task);
                task->dbopen = dbopen_sv;
                break;
            }
        }

        if (mem == memtot)
            dberr(S_INVMEM);
    }

    return (task->db_status);
}


/* ======================================================================
    Set current member to current owner
*/
int INTERNAL_FCN dsetmo(
    int setm,                   /* set table entry number of member */
    int seto,                   /* set table entry number of owner */
    DB_TASK *task,
    int dbn)                    /* database number */
{
    int mem, memtot;
    SET_ENTRY *setm_ptr, *seto_ptr;
    int dbopen_sv;

    if (nset_check(seto, &seto, &seto_ptr, task) == S_OKAY &&
        nset_check(setm, &setm, &setm_ptr, task) == S_OKAY)
    {
        if (null_dba(task->curr_own[seto]))
            dberr(S_NOCO);
        else
        {
            for (mem = setm_ptr->st_members, memtot = mem + setm_ptr->st_memtot;
                 mem < memtot; ++mem)
            {
                if (task->member_table[mem].mt_record == seto_ptr->st_own_rt)
                {
                    dbopen_sv = task->dbopen;
                    task->dbopen = 2;            /* setup to allow unlocked read */
                    r_smem(&task->curr_own[seto], setm, task);
                    task->dbopen = dbopen_sv;
                    break;
                }
            }

            if (mem == memtot)
                dberr(S_INVMEM);
        }
    }

    return (task->db_status);
}


/* ======================================================================
    Set current member to current record
*/
int INTERNAL_FCN dsetmr(
    int set,                    /* set table entry number */
    DB_TASK *task,
    int dbn)                    /* database number */
{
    int crtype;                 /* current record type */
    int mem, memtot;
    SET_ENTRY *set_ptr;
    int dbopen_sv;

    if (!task->curr_rec)
        dberr(S_NOCR);
    else
    {
        if (dcrtype(&crtype, task, dbn) == S_OKAY &&
            nset_check(set, &set, &set_ptr, task) == S_OKAY)
        {
            crtype += DB_REF(rt_offset) - RECMARK;

            for (mem = set_ptr->st_members, memtot = mem + set_ptr->st_memtot;
                 mem < memtot; ++mem)
            {
                if (task->member_table[mem].mt_record != crtype)
                    continue;

                dbopen_sv = task->dbopen;
                task->dbopen = 2;                 /* setup to allow unlocked read */
                r_smem(&task->curr_rec, set, task);
                task->dbopen = dbopen_sv;
                break;
            }

            if (mem == memtot)
                dberr(S_INVMEM);
        }
    }

    return (task->db_status);
}


/* ======================================================================
    Set current owner to current member
*/
int INTERNAL_FCN dsetom(
    int nseto,                  /* set table entry number of owner */
    int nsetm,                  /* set table entry number of member */
    DB_TASK *task,
    int dbn)                    /* database number */
{
    int seto, setm;
    int cmtype;                 /* current record type */
    SET_ENTRY *set_ptr;

    if (dcmtype(nsetm, &cmtype, task, dbn) != S_OKAY ||
        nset_check(nseto, &seto, &set_ptr, task) != S_OKAY)
        return (task->db_status);

    cmtype += NUM2INT(-RECMARK, rt_offset);
    setm = NUM2INT(nsetm - SETMARK, st_offset);

    if (set_ptr->st_own_rt != cmtype)
        return (dberr(S_INVOWN));

    task->curr_own[seto] = task->curr_mem[setm];
    task->curr_mem[seto] = NULL_DBA;

    /* set timestamps */
    if (task->db_tsrecs)
    {
        task->co_time[seto] = task->cm_time[setm];
        task->cm_time[seto] = 0L;
    }

    if (task->db_tssets)
        dutscs(nseto, &task->cs_time[seto], task, dbn);

    return (task->db_status);
}


/* ======================================================================
    Set current owner to current owner
*/
int INTERNAL_FCN dsetoo(
    int nsett,                  /* set table entry number of target owner */
    int nsets,                  /* set table entry number of source owner */
    DB_TASK *task,
    int dbn)                    /* database number */
{
    int sett, sets;
    SET_ENTRY *sett_ptr, *sets_ptr;

    if (nset_check(nsett, &sett, &sett_ptr, task) != S_OKAY ||
        nset_check(nsets, &sets, &sets_ptr, task) != S_OKAY)
        return (task->db_status);

    if (sett_ptr->st_own_rt != sets_ptr->st_own_rt)
        return (dberr(S_INVOWN));

    if (null_dba(task->curr_own[sets]))
        return (dberr(S_NOCO));

    task->curr_own[sett] = task->curr_own[sets];
    task->curr_mem[sett] = NULL_DBA;

    /* set timestamps */
    if (task->db_tsrecs)
    {
        task->co_time[sett] = task->co_time[sets];
        task->cm_time[sett] = 0L;
    }

    if (task->db_tssets)
        dutscs(nsett, &task->cs_time[sett], task, dbn);

    return (task->db_status);
}


/* ======================================================================
    Set current owner to current record
*/
int INTERNAL_FCN dsetor(
    int nset,                   /* set number */
    DB_TASK *task,
    int dbn)                    /* database number */
{
    int set;
    int crtype;                 /* current record type */
    SET_ENTRY *set_ptr;

    if (nset_check(nset, &set, &set_ptr, task) != S_OKAY ||
        dcrtype(&crtype, task, dbn) != S_OKAY)
        return (task->db_status);

    crtype += NUM2INT(-RECMARK, rt_offset);

    if (set_ptr->st_own_rt != crtype)
        return (dberr(S_INVOWN));

    task->curr_own[set] = task->curr_rec;
    task->curr_mem[set] = NULL_DBA;

    /* set timestamps */
    if (task->db_tsrecs)
    {
        task->co_time[set] = task->cr_time;
        task->cm_time[set] = 0L;
    }

    if (task->db_tssets)
        dutscs(nset, &task->cs_time[set], task, dbn);

    return (task->db_status);
}


/* ======================================================================
    Set current record to current member
*/
int INTERNAL_FCN dsetrm(
    int set,                    /* set table entry number */
    DB_TASK *task,
    int dbn)                    /* database number */
{
    SET_ENTRY *set_ptr;

    if (nset_check(set, &set, &set_ptr, task) == S_OKAY)
    {
        if (!task->curr_mem[set])
            dberr(S_NOCM);
        else
        {
            task->curr_rec = task->curr_mem[set];

            /* set timestamp */
            if (task->db_tsrecs)
                task->cr_time = task->cm_time[set];
        }
    }

    return (task->db_status);
}


/* ======================================================================
    Set current record to current owner
*/
int INTERNAL_FCN dsetro(
    int set,                    /* set table entry number */
    DB_TASK *task,
    int dbn)                    /* database number */
{
    SET_ENTRY *set_ptr;

    if (nset_check(set, &set, &set_ptr, task) == S_OKAY)
    {
        if (!task->curr_own[set])
            dberr(S_NOCO);
        else
        {
            task->curr_rec = task->curr_own[set];

            /* set timestamp */
            if (task->db_tsrecs)
                task->cr_time = task->co_time[set];
        }
    }

    return (task->db_status);
}


/* ======================================================================
    Find owner of current record
*/
int INTERNAL_FCN dfindco(int nset, DB_TASK *task, int dbn)
{
    int set;
    int stat;
    MEM_PTR mem;
    SET_ENTRY *set_ptr;

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