ING_DB
This commit is contained in:
Oliver Lehmann
parent
71b63a8731
commit
30af3311d4
|
|
@ -0,0 +1,361 @@
|
|||
# include <stdio.h>
|
||||
# include "gen.h"
|
||||
# include "../h/dbs.h"
|
||||
# include "../h/aux.h"
|
||||
# include "../h/symbol.h"
|
||||
# include "../h/tree.h"
|
||||
# include "../h/pipes.h"
|
||||
# include "ovqp.h"
|
||||
# include "strategy.h"
|
||||
|
||||
|
||||
/*
|
||||
** Exactkey checks to see if the relation described
|
||||
** by "ap" can be used in a hashed scan.
|
||||
** All the key domains of the relation must
|
||||
** have simple clauses of equality associated
|
||||
** with them in the qualification.
|
||||
**
|
||||
** Returns 0 if the relation can't be used.
|
||||
**
|
||||
** Returns > 0 if it can.
|
||||
*/
|
||||
|
||||
exactkey(ap, key)
|
||||
struct accessparam *ap;
|
||||
struct key *key;
|
||||
{
|
||||
register struct accessparam *a;
|
||||
register struct key *k;
|
||||
register struct simp *s;
|
||||
int d;
|
||||
int i;
|
||||
int j;
|
||||
|
||||
# ifdef xOTR1
|
||||
AAtTfp(25, -1, "EXACTKEY\n");
|
||||
# endif
|
||||
|
||||
a = ap;
|
||||
k = key;
|
||||
i = 0;
|
||||
if (a->mode == EXACTKEY)
|
||||
{
|
||||
|
||||
for (i = 0; d = a->keydno[i]; i++)
|
||||
{
|
||||
|
||||
s = Simp;
|
||||
for (j = 0; j < Nsimp; j++)
|
||||
{
|
||||
if (s->relop == (int) opEQ && s->att == d)
|
||||
{
|
||||
k->keysym = s->konst;
|
||||
k->dnumber = (a->sec_index == TRUE) ? i+1 : d;
|
||||
k++;
|
||||
# ifdef xOTR1
|
||||
if (AAtTfp(25, 1, "exact key on dom %d\tvalue=", d))
|
||||
prsym(s->konst);
|
||||
# endif
|
||||
break;
|
||||
}
|
||||
s++;
|
||||
}
|
||||
if (j == Nsimp)
|
||||
{
|
||||
i = 0; /* failure. at lease one key isn't used */
|
||||
break;
|
||||
}
|
||||
}
|
||||
k->dnumber = 0; /* mark end of list */
|
||||
}
|
||||
# ifdef xOTR1
|
||||
AAtTfp(25, 9, "EXACTKEY: rets %d\n", i);
|
||||
# endif
|
||||
return (i);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Range key checks if the relation described by
|
||||
** "ap" is ISAM and there are simple clauses
|
||||
** on the first key and any additional keys.
|
||||
**
|
||||
** Rangekey accumulates both high and low keys,
|
||||
** which are not necessary the same. If it
|
||||
** every finds a high or a low key on the first
|
||||
** domain of the relation then success=TRUE.
|
||||
**
|
||||
** Returns 1 if Rangekey ok
|
||||
** 0 if Rangekey is not ok
|
||||
** -1 if Rangekey ok and all clauses are equality clauses
|
||||
*/
|
||||
|
||||
rangekey(ap, l, h)
|
||||
struct accessparam *ap;
|
||||
struct key *l;
|
||||
struct key *h;
|
||||
{
|
||||
register struct key *low;
|
||||
register struct key *high;
|
||||
register struct simp *s;
|
||||
struct accessparam *a;
|
||||
int sec_indx;
|
||||
int d;
|
||||
int i;
|
||||
int rel;
|
||||
int success;
|
||||
int ns;
|
||||
int lowkey;
|
||||
int allexact;
|
||||
|
||||
# ifdef xOTR1
|
||||
AAtTfp(25, 5, "RANGEKEY\n");
|
||||
# endif
|
||||
|
||||
a = ap;
|
||||
sec_indx = a->sec_index == TRUE;
|
||||
low = l;
|
||||
high = h;
|
||||
allexact = -1; /* assume all clauses equality clauses */
|
||||
s = Simp;
|
||||
success = FALSE;
|
||||
if (a->mode == LRANGEKEY)
|
||||
{
|
||||
|
||||
for (ns = 0; ns < Nsimp; ns++)
|
||||
{
|
||||
rel = s->relop;
|
||||
for (i = 0; d = a->keydno[i]; i++)
|
||||
{
|
||||
if (d == s->att)
|
||||
{
|
||||
/* this is either a high range value or low range value */
|
||||
lowkey = (rel == (int) opGTGE);
|
||||
if (lowkey || rel == (int) opEQ)
|
||||
{
|
||||
/* low range key */
|
||||
# ifdef xOTR1
|
||||
AAtTfp(25, 6, "low key on dom %d\t", d);
|
||||
# endif
|
||||
low->keysym = s->konst;
|
||||
low->dnumber = sec_indx ? i+1 : d;
|
||||
low++;
|
||||
}
|
||||
if (!lowkey || rel == (int) opEQ)
|
||||
{
|
||||
/* high range key */
|
||||
# ifdef xOTR1
|
||||
AAtTfp(25, 6, "high key on dom %d\t", d);
|
||||
# endif
|
||||
high->keysym = s->konst;
|
||||
high->dnumber = sec_indx ? i+1 : d;
|
||||
high++;
|
||||
}
|
||||
# ifdef xOTR1
|
||||
if (AAtTf(25, 6))
|
||||
prsym(s->konst);
|
||||
# endif
|
||||
if (i == 0)
|
||||
success = TRUE;
|
||||
if (rel != (int) opEQ)
|
||||
allexact = 1; /* at least one inequality */
|
||||
break;
|
||||
}
|
||||
}
|
||||
s++; /* try next simple clause */
|
||||
}
|
||||
}
|
||||
|
||||
high->dnumber = 0; /* mark end of list */
|
||||
low->dnumber = 0; /* mask end of list */
|
||||
|
||||
/* if success then return whether all clauses were equality */
|
||||
if (success)
|
||||
success = allexact;
|
||||
|
||||
# ifdef xOTR1
|
||||
AAtTfp(25, 5, "RANGEKEY: rets %d\n", success);
|
||||
# endif
|
||||
return (success);
|
||||
}
|
||||
|
||||
|
||||
setallkey(relkey, keytuple)
|
||||
struct key *relkey;
|
||||
char *keytuple;
|
||||
|
||||
/*
|
||||
** Setallkey takes a key struct, decodes it and
|
||||
** calls setkey with each value.
|
||||
**
|
||||
** Called from strategy().
|
||||
**
|
||||
** returns 0 if ok.
|
||||
** returns -1 in the special case of a deblanked hashkey
|
||||
** being bigger than the corresponding domain.
|
||||
*/
|
||||
{
|
||||
register struct key *k;
|
||||
register SYMBOL *sy;
|
||||
register int dnum;
|
||||
SYMBOL **s;
|
||||
char *p;
|
||||
char temp[MAXFIELD + 1];
|
||||
int l;
|
||||
|
||||
AAam_clearkeys(Scanr);
|
||||
k = relkey;
|
||||
while (dnum = k->dnumber)
|
||||
{
|
||||
s = &k->keysym;
|
||||
sy = (SYMBOL *) Stack;
|
||||
getsymbol(sy, &s); /* copy symbol to stack. caution:getsym changes the value of s. */
|
||||
rcvt(sy, Scanr->relfrmt[dnum], Scanr->relfrml[dnum]); /* convert key to correct type */
|
||||
p = (char *) (sy->value);
|
||||
|
||||
if (sy->type == CHAR)
|
||||
{
|
||||
/*
|
||||
** The length of a character key must
|
||||
** be made equal to the domain length.
|
||||
** The key is copied to a temp place
|
||||
** and a null byte is inserted at the
|
||||
** end. In addition, if the key without
|
||||
** blanks is longer than the domain and
|
||||
** this is an exactkey, then the query
|
||||
** is false.
|
||||
*/
|
||||
p = temp;
|
||||
l = cmove(sy, p); /* copy symbol to temp removing blanks & nulls */
|
||||
# ifdef xOTR1
|
||||
AAtTfp(26, 9, "length is %d\n", l);
|
||||
# endif
|
||||
if (Fmode == EXACTKEY && l > ctou(Scanr->relfrml[dnum]))
|
||||
/* key too large. qualification is false */
|
||||
return (-1);
|
||||
}
|
||||
if (sy->type == INT && sy->len == sizeof (char))
|
||||
{
|
||||
*temp = ((I2TYPE *) p)->i2type;
|
||||
p = temp;
|
||||
}
|
||||
AAam_setkey(Scanr, keytuple, p, dnum); /* set the key */
|
||||
k++;
|
||||
}
|
||||
# ifdef xOTR1
|
||||
if (AAtTf(26, 8))
|
||||
AAprkey(Scanr, keytuple);
|
||||
# endif
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
||||
cmove(sym, dest)
|
||||
struct stacksym *sym;
|
||||
char *dest;
|
||||
|
||||
/*
|
||||
** Cmove copies a char symbol into "dest".
|
||||
** It stops when the length is reached or
|
||||
** when a null byte is found.
|
||||
**
|
||||
** returns the number of non-blank chars
|
||||
** in the string.
|
||||
*/
|
||||
{
|
||||
register char *d;
|
||||
register char *s;
|
||||
register int l;
|
||||
int blank;
|
||||
|
||||
s = (char *) ((SYMBOL *) sym)->value;
|
||||
s = ((STRINGP *) s)->stringp; /* s points to the char string */
|
||||
d = dest;
|
||||
blank = 0;
|
||||
|
||||
for (l = (ctou(((SYMBOL *) sym)->len)); l--; s++)
|
||||
{
|
||||
*d++ = *s;
|
||||
if (*s == ' ')
|
||||
blank++;
|
||||
if (*s == '\0')
|
||||
{
|
||||
d--;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
*d = '\0';
|
||||
return ((d - dest) - blank); /* return length of string */
|
||||
}
|
||||
|
||||
indexcheck()
|
||||
|
||||
/*
|
||||
** Indexcheck is called by scan() to check whether
|
||||
** a secondary index tuple satisfies the simple
|
||||
** clauses under which it was scanned.
|
||||
**
|
||||
** Returns 1 if the tuple is ok,
|
||||
** 0 otherwise.
|
||||
*/
|
||||
{
|
||||
register int i;
|
||||
|
||||
if (Fmode == EXACTKEY)
|
||||
i = keycheck(Lkey_struct, Keyl, 0); /* check for equality */
|
||||
else
|
||||
{
|
||||
i = keycheck(Lkey_struct, Keyl, 1); /* check for >= */
|
||||
/* If the lowkey passed, check the highkey also */
|
||||
if (i)
|
||||
i = keycheck(Hkey_struct, Keyh, -1); /* check for <= */
|
||||
}
|
||||
# ifdef xOTR1
|
||||
AAtTfp(26, 10, "INDEXCHECK: rets %d\n", i);
|
||||
# endif
|
||||
return (i);
|
||||
}
|
||||
|
||||
keycheck(keys, keytuple, mode)
|
||||
struct key *keys;
|
||||
char *keytuple;
|
||||
int mode;
|
||||
|
||||
/*
|
||||
** Keycheck compares Intup with keytuple
|
||||
** according to the domains specified in the
|
||||
** "keys" struct.
|
||||
**
|
||||
** mode is either >0, =0, <0 depending on
|
||||
** whether check is for Intup >= keytuple,
|
||||
** Intup == keytuple, Intup <= keytuple respectively
|
||||
**
|
||||
** returns TRUE or FALSE accordingly.
|
||||
*/
|
||||
{
|
||||
register struct key *k;
|
||||
register char *kp;
|
||||
register int dnum;
|
||||
register int offset;
|
||||
register int i;
|
||||
register int success;
|
||||
|
||||
kp = keytuple;
|
||||
success = TRUE;
|
||||
|
||||
for (k = keys; dnum = k->dnumber; k++)
|
||||
{
|
||||
|
||||
offset = Scanr->reloff[dnum];
|
||||
if (i = AAicompare(&Intup[offset], &kp[offset], Scanr->relfrmt[dnum], ctou(Scanr->relfrml[dnum])))
|
||||
{
|
||||
if (i < 0 && mode < 0 || i > 0 && mode > 0)
|
||||
continue;
|
||||
success = FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return (success);
|
||||
}
|
||||
Loading…
Reference in New Issue