Return to seq_atts.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ingres / source / dbu

Annotation of 43BSD/ingres/source/dbu/seq_atts.c, revision 1.1

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <access.h>
        !             3: # include      <sccs.h>
        !             4: 
        !             5: SCCSID(@(#)seq_atts.c  8.1     12/31/84)
        !             6: 
        !             7: /*
        !             8: ** Seq_attributes - get all attributes of a relation in their correct order.
        !             9: **
        !            10: **     Seq_attributes() can be called when it is desired to get all
        !            11: **     attribute tuples for a relation. They are guaranteed to be in
        !            12: **     the same order as they were created in; that is "attid" order.
        !            13: **
        !            14: **     The calling convention is:
        !            15: **
        !            16: **             seq_init(Attribute_descriptor, Descriptor_for_relation)
        !            17: **
        !            18: **             while (seq_attribute(Att_desc, Des_for_rel, Tuple)
        !            19: **             {
        !            20: **             }
        !            21: **
        !            22: **     The first parameter is an OPEN descriptor for the attribute
        !            23: **     relation. The second parameter is a descriptor for the relation.
        !            24: **     It must have the relation-relation tuple (ie openr mode -1).
        !            25: **     The third parameter is a place to put the attribute. Its
        !            26: **     dimension must be at least sizeof (attribute structure).
        !            27: **
        !            28: **     Seq_attribute attempts to optimize the retrieval of the
        !            29: **     attributes. It assumes initially that the are physically
        !            30: **     stored sequentially. If so it will retrieve them in the
        !            31: **     minimum possible number of accesses.
        !            32: **
        !            33: **     If it finds one tuple out of sequence then all future
        !            34: **     scans will start from that first out of sequence tuple.
        !            35: */
        !            36: 
        !            37: struct tup_id  Seq_tdl, Seq_tdh, Seq_tdf;
        !            38: int            Seq_seqmode, Seq_next;
        !            39: 
        !            40: 
        !            41: 
        !            42: seq_init(a, r)
        !            43: register DESC  *a;
        !            44: register DESC  *r;
        !            45: {
        !            46:        register int            i;
        !            47:        struct attribute        attkey;
        !            48: 
        !            49:        clearkeys(a);
        !            50:        setkey(a, &attkey, r->reldum.relid, ATTRELID);
        !            51:        setkey(a, &attkey, r->reldum.relowner, ATTOWNER);
        !            52:        if (i = find(a, EXACTKEY, &Seq_tdl, &Seq_tdh, &attkey))
        !            53:                syserr("seq_init:find:%d", i);
        !            54: 
        !            55:        Seq_seqmode = TRUE;
        !            56:        Seq_next = 1;
        !            57: }
        !            58: 
        !            59: 
        !            60: seq_attributes(a, r, atup)
        !            61: register DESC                  *a;
        !            62: register DESC                  *r;
        !            63: register struct attribute      *atup;
        !            64: {
        !            65:        int     i, nxttup;
        !            66: 
        !            67:        if (Seq_next > r->reldum.relatts)
        !            68:                return (0);     /* no more attributes */
        !            69: 
        !            70:        if (!Seq_seqmode)
        !            71:        {
        !            72:                /* attributes not stored sequencially, start from first attribute */
        !            73:                bmove(&Seq_tdf, &Seq_tdl, sizeof (Seq_tdl));
        !            74:                nxttup = FALSE;
        !            75:        }
        !            76:        else
        !            77:                nxttup = TRUE;
        !            78: 
        !            79:        while ((i = get(a, &Seq_tdl, &Seq_tdh, atup, nxttup)) == 0)
        !            80:        {
        !            81: 
        !            82:                nxttup = TRUE;
        !            83:                /* make sure this is a tuple for the right relation */
        !            84:                if (kcompare(a, atup, r))
        !            85:                        continue;
        !            86: 
        !            87:                /* is this the attribute we want? */
        !            88:                if (atup->attid != Seq_next)
        !            89:                {
        !            90:                        if (Seq_seqmode)
        !            91:                        {
        !            92:                                /*
        !            93:                                ** Turn off seq mode. Save the tid of
        !            94:                                ** the current tuple. It will be the
        !            95:                                ** starting point for the next call
        !            96:                                ** to seq_attribute
        !            97:                                */
        !            98:                                bmove(&Seq_tdl, &Seq_tdf, sizeof (Seq_tdf));
        !            99:                                Seq_seqmode = FALSE;
        !           100:                        }
        !           101: 
        !           102:                        continue;
        !           103:                }
        !           104: 
        !           105:                /* got current attribute. increment to next attribute */
        !           106:                Seq_next++;
        !           107:                return (1);
        !           108:        }
        !           109: 
        !           110:        /* fell out of loop. either bad get return or missing attribute */
        !           111:        syserr("seq_att:bad or missing %d,%d", i, Seq_next);
        !           112: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.