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

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.