[moira.git] / server / qvalidate.dc

/*
 *	$Source$
 *	$Author$
 *	$Header$
 *
 *	Copyright (C) 1987 by the Massachusetts Institute of Technology
 *	For copying and distribution information, please see the file
 *	<mit-copyright.h>.
 *
 */

#ifndef lint
static char *rcsid_qsupport_dc = "$Header$";
#endif lint

#include <mit-copyright.h>
#include <unistd.h>
#include "query.h"
#include "mr_server.h"
#include <ctype.h>
EXEC SQL INCLUDE sqlca;
EXEC SQL INCLUDE sqlda;
#include "qrtn.h"

extern char *whoami;
extern int ingres_errno, mr_errcode;

EXEC SQL BEGIN DECLARE SECTION;
extern char stmt_buf[];
EXEC SQL END DECLARE SECTION;

EXEC SQL WHENEVER SQLERROR CALL ingerr;


/* Validation Routines */

validate_row(q, argv, v)
    register struct query *q;
    char *argv[];
    register struct validate *v;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *name;
    char qual[128];
    int rowcount;
    EXEC SQL END DECLARE SECTION;

    /* build where clause */
    build_qual(v->qual, v->argc, argv, qual);

    if (log_flags & LOG_VALID)
	/* tell the logfile what we're doing */
	com_err(whoami, 0, "validating row: %s", qual);

    /* look for the record */
    sprintf(stmt_buf,"SELECT COUNT (*) FROM %s WHERE %s",q->rtable,qual);
    EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
    if(sqlca.sqlcode)
      return(MR_INTERNAL);
    EXEC SQL DECLARE csr126 CURSOR FOR stmt;
    EXEC SQL OPEN csr126;
    EXEC SQL FETCH csr126 USING DESCRIPTOR :SQLDA;
    EXEC SQL CLOSE csr126;
    rowcount = *(int *)SQLDA->sqlvar[0].sqldata;

    if (ingres_errno) return(mr_errcode);
    if (rowcount == 0) return(MR_NO_MATCH);
    if (rowcount > 1) return(MR_NOT_UNIQUE);
    return(MR_EXISTS);
}

validate_fields(q, argv, vo, n)
    struct query *q;
    register char *argv[];
    register struct valobj *vo;
    register int n;
{
    register int status;

    while (--n >= 0) {
	switch (vo->type) {
	case V_NAME:
	    if (log_flags & LOG_VALID)
		com_err(whoami, 0, "validating %s in %s: %s",
		    vo->namefield, vo->table, argv[vo->index]);
	    status = validate_name(argv, vo);
	    break;

	case V_ID:
	    if (log_flags & LOG_VALID)
		com_err(whoami, 0, "validating %s in %s: %s",
		    vo->idfield, vo->table, argv[vo->index]);
	    status = validate_id(q, argv, vo);
	    break;

	case V_DATE:
	    if (log_flags & LOG_VALID)
		com_err(whoami, 0, "validating date: %s", argv[vo->index]);
	    status = validate_date(argv, vo);
	    break;

	case V_TYPE:
	    if (log_flags & LOG_VALID)
		com_err(whoami, 0, "validating %s type: %s",
		    vo->table, argv[vo->index]);
	    status = validate_type(argv, vo);
	    break;

	case V_TYPEDATA:
	    if (log_flags & LOG_VALID)
		com_err(whoami, 0, "validating typed data (%s): %s",
		    argv[vo->index - 1], argv[vo->index]);
	    status = validate_typedata(q, argv, vo);
	    break;

	case V_RENAME:
	    if (log_flags & LOG_VALID)
	        com_err(whoami, 0, "validating rename %s in %s",
			argv[vo->index], vo->table);
	    status = validate_rename(argv, vo);
	    break;

	case V_CHAR:
	    if (log_flags & LOG_VALID)
	      com_err(whoami, 0, "validating chars: %s", argv[vo->index]);
	    status = validate_chars(argv[vo->index]);
	    break;

	case V_SORT:
	    status = MR_EXISTS;
	    break;

	case V_LOCK:
	    status = lock_table(vo);
	    break;

	case V_WILD:
	    status = convert_wildcards(argv[vo->index]);
	    break;

	case V_UPWILD:
	    status = convert_wildcards_uppercase(argv[vo->index]);
	    break;

	}

	if (status != MR_EXISTS) return(status);
	vo++;
    }

    if (ingres_errno) return(mr_errcode);
    return(MR_SUCCESS);
}


/* validate_chars: verify that there are no illegal characters in
 * the string.  Legal characters are printing chars other than
 * ", *, ?, \, [ and ].
 */
static int illegalchars[] = {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^@ - ^O */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^P - ^_ */
    0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* SPACE - / */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* 0 - ? */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* : - O */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, /* P - _ */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ` - o */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* p - ^? */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
};

validate_chars(s)
register char *s;
{
    while (*s)
      if (illegalchars[*s++])
	return(MR_BAD_CHAR);
    return(MR_EXISTS);
}


validate_id(q, argv, vo)
    struct query *q;
    char *argv[];
    register struct valobj *vo;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *name, *tbl, *namefield, *idfield;
    int id, rowcount;
    EXEC SQL END DECLARE SECTION;
    int status;
    register char *c;

    name = argv[vo->index];
    tbl = vo->table;
    namefield = vo->namefield;
    idfield = vo->idfield;

    if ((!strcmp(tbl, "users") && !strcmp(namefield, "login")) ||
	!strcmp(tbl, "machine") ||
	!strcmp(tbl, "subnet") ||
	!strcmp(tbl, "filesys") ||
	!strcmp(tbl, "list") ||
	!strcmp(tbl, "cluster") ||
	!strcmp(tbl, "strings")) {
	if (!strcmp(tbl, "machine") || !strcmp(tbl, "subnet"))
	  for (c = name; *c; c++) if (islower(*c)) *c = toupper(*c);
	status = name_to_id(name, tbl, &id);
	if (status == 0) {
	    *(int *)argv[vo->index] = id;
	    return(MR_EXISTS);
	} else if (status == MR_NO_MATCH && !strcmp(tbl, "strings") &&
		   (q->type == APPEND || q->type == UPDATE)) {
	    id=add_string(name);
	    cache_entry(name, "STRING", id);
	    *(int *)argv[vo->index] = id;
	    return(MR_EXISTS);
	} else if (status == MR_NO_MATCH || status == MR_NOT_UNIQUE)
	  return(vo->error);
	else
	  return(status);
    }

    if (!strcmp(namefield, "uid")) {
	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = %s",idfield,tbl,namefield,name);
    } else {
	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = '%s'",idfield,tbl,namefield,name);
    }
    EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
    if(sqlca.sqlcode)
      return(MR_INTERNAL);
    EXEC SQL DECLARE csr127 CURSOR FOR stmt;
    EXEC SQL OPEN csr127;
    rowcount=0;
    EXEC SQL FETCH csr127 USING DESCRIPTOR :SQLDA;
    if(sqlca.sqlcode == 0) {
	rowcount++;
	EXEC SQL FETCH csr127 USING DESCRIPTOR :SQLDA;
	if(sqlca.sqlcode == 0) rowcount++;
    }
    EXEC SQL CLOSE csr127;
    if (ingres_errno)
      return(mr_errcode);

    if (rowcount != 1) return(vo->error);
    bcopy(SQLDA->sqlvar[0].sqldata,argv[vo->index],sizeof(int));
    return(MR_EXISTS);
}

validate_name(argv, vo)
    char *argv[];
    register struct valobj *vo;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *name, *tbl, *namefield;
    int rowcount;
    EXEC SQL END DECLARE SECTION;
    register char *c;

    name = argv[vo->index];
    tbl = vo->table;
    namefield = vo->namefield;
    if (!strcmp(tbl, "servers") && !strcmp(namefield, "name")) {
	for (c = name; *c; c++)
	  if (islower(*c))
	    *c = toupper(*c);
    }
    sprintf(stmt_buf,"SELECT DISTINCT COUNT(*) FROM %s WHERE %s.%s = '%s'",
	    tbl,tbl,namefield,name);
    EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
    if(sqlca.sqlcode)
      return(MR_INTERNAL);
    EXEC SQL DECLARE csr128 CURSOR FOR stmt;
    EXEC SQL OPEN csr128;
    EXEC SQL FETCH csr128 USING DESCRIPTOR :SQLDA;
    rowcount = *(int *)SQLDA->sqlvar[0].sqldata;
    EXEC SQL CLOSE csr128;

    if (ingres_errno) return(mr_errcode);
    return ((rowcount == 1) ? MR_EXISTS : vo->error);
}

validate_date(argv, vo)
    char *argv[];
    struct valobj *vo;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *idate;
    double dd;
    int errorno;
    EXEC SQL END DECLARE SECTION;

    idate = argv[vo->index];
    EXEC SQL SELECT interval('years',date(:idate)-date('today')) INTO :dd;

    if (sqlca.sqlcode != 0 || dd > 5.0) return(MR_DATE);
    return(MR_EXISTS);
}


validate_rename(argv, vo)
char *argv[];
struct valobj *vo;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *name, *tbl, *namefield, *idfield;
    int id;
    EXEC SQL END DECLARE SECTION;
    int status;
    register char *c;

    c = name = argv[vo->index];
    while (*c)
      if (illegalchars[*c++])
	return(MR_BAD_CHAR);
    tbl = vo->table;
    /* minor kludge to upcasify machine names */
    if (!strcmp(tbl, "machine"))
	for (c = name; *c; c++) if (islower(*c)) *c = toupper(*c);
    namefield = vo->namefield;
    idfield = vo->idfield;
    id = -1;
    if (idfield == 0) {
	if (!strcmp(argv[vo->index], argv[vo->index - 1]))
	  return(MR_EXISTS);
	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = LEFT('%s',SIZE(%s))",
		namefield,tbl,namefield,name,namefield);
	EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
	if(sqlca.sqlcode)
	  return(MR_INTERNAL);
        EXEC SQL DECLARE csr129 CURSOR FOR stmt;
	EXEC SQL OPEN csr129;
        EXEC SQL FETCH csr129 USING DESCRIPTOR :SQLDA;
	if(sqlca.sqlcode == 0) id=1; else id=0;
	EXEC SQL CLOSE csr129;

	if (ingres_errno) return(mr_errcode);
	if (id)
	  return(vo->error);
	else
	  return(MR_EXISTS);
    }
    status = name_to_id(name, tbl, &id);
    if (status == MR_NO_MATCH || id == *(int *)argv[vo->index - 1])
      return(MR_EXISTS);
    else
      return(vo->error);
}


validate_type(argv, vo)
    char *argv[];
    register struct valobj *vo;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *typename;
    char *val;
    int cnt;
    EXEC SQL END DECLARE SECTION;
    register char *c;

    typename = vo->table;
    c = val = argv[vo->index];
    while (*c) {
	if (illegalchars[*c++])
	  return(MR_BAD_CHAR);
    }

    /* uppercase type fields */
    for (c = val; *c; c++) if (islower(*c)) *c = toupper(*c);

    EXEC SQL SELECT COUNT(trans) INTO :cnt FROM alias
      WHERE name = :typename AND type='TYPE' AND trans = :val;
    if (ingres_errno) return(mr_errcode);
    return (cnt ? MR_EXISTS : vo->error);
}

/* validate member or type-specific data field */

validate_typedata(q, argv, vo)
    register struct query *q;
    register char *argv[];
    register struct valobj *vo;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *name;
    char *field_type;
    char data_type[129];
    int id;
    EXEC SQL END DECLARE SECTION;
    int status;
    char *index();
    register char *c;

    /* get named object */
    name = argv[vo->index];

    /* get field type string (known to be at index-1) */
    field_type = argv[vo->index-1];

    /* get corresponding data type associated with field type name */
    EXEC SQL SELECT trans INTO :data_type FROM alias
      WHERE name = :field_type AND type='TYPEDATA';
    if (ingres_errno) return(mr_errcode);
    if (sqlca.sqlerrd[2] != 1) return(MR_TYPE);

    /* now retrieve the record id corresponding to the named object */
    if (index(data_type, ' '))
	*index(data_type, ' ') = 0;
    if (!strcmp(data_type, "user")) {
	/* USER */
	if (index(name, '@'))
	  return(MR_USER);
	status = name_to_id(name, data_type, &id);
	if (status && (status == MR_NO_MATCH || status == MR_NOT_UNIQUE))
	  return(MR_USER);
	if (status) return(status);
    } else if (!strcmp(data_type, "list")) {
	/* LIST */
	status = name_to_id(name, data_type, &id);
	if (status && status == MR_NOT_UNIQUE)
	  return(MR_LIST);
	if (status == MR_NO_MATCH) {
	    /* if idfield is non-zero, then if argv[0] matches the string
	     * that we're trying to resolve, we should get the value of
	     * numvalues.[idfield] for the id.
	     */
	    if (vo->idfield && !strcmp(argv[0], argv[vo->index])) {
		set_next_object_id(q->validate->object_id, q->rtable, 0);
		name = vo->idfield;
		EXEC SQL REPEATED SELECT value INTO :id FROM numvalues
		  WHERE name = :name;
		if (sqlca.sqlerrd[2] != 1) return(MR_LIST);
	    } else
	      return(MR_LIST);
	} else if (status) return(status);
    } else if (!strcmp(data_type, "machine")) {
	/* MACHINE */
	for (c = name; *c; c++) if (islower(*c)) *c = toupper(*c);
	status = name_to_id(name, data_type, &id);
	if (status && (status == MR_NO_MATCH || status == MR_NOT_UNIQUE))
	  return(MR_MACHINE);
	if (status) return(status);
    } else if (!strcmp(data_type, "string")) {
	/* STRING */
	status = name_to_id(name, data_type, &id);
	if (status && status == MR_NOT_UNIQUE)
	  return(MR_STRING);
	if (status == MR_NO_MATCH) {
	    if (q->type != APPEND && q->type != UPDATE) return(MR_STRING);
	    id=add_string(name);
	    cache_entry(name, "STRING", id);
	} else if (status) return(status);
    } else if (!strcmp(data_type, "none")) {
	id = 0;
    } else {
	return(MR_TYPE);
    }

    /* now set value in argv */
    *(int *)argv[vo->index] = id;

    return (MR_EXISTS);
}


/* Lock the table named by the validation object */

lock_table(vo)
struct valobj *vo;
{
    sprintf(stmt_buf,"UPDATE %s SET modtime='now' WHERE %s.%s = 0",
	    vo->table,vo->table,vo->idfield);
    EXEC SQL EXECUTE IMMEDIATE :stmt_buf;
    if (ingres_errno) return(mr_errcode);
    if (sqlca.sqlerrd[2] != 1)
      return(vo->error);
    else
      return(MR_EXISTS);
}


/* Check the database at startup time.  For now this just resets the
 * inprogress flags that the DCM uses.
 */

sanity_check_database()
{
}


/* Dynamic SQL support routines */
MR_SQLDA_T *mr_alloc_SQLDA()
{
    MR_SQLDA_T *it;
    short *null_indicators;
    register int j;

    if((it=(MR_SQLDA_T *)malloc(sizeof(MR_SQLDA_T)))==NULL) {
	com_err(whoami, MR_NO_MEM, "setting up SQLDA");
	exit(1);
    }

    if((null_indicators=(short *)calloc(QMAXARGS,sizeof(short)))==NULL) {
	com_err(whoami, MR_NO_MEM, "setting up SQLDA null indicators");
	exit(1);
    }

    for(j=0; j<QMAXARGS; j++) {
	if((it->sqlvar[j].sqldata=malloc(sizeof(short)+ARGLEN))==NULL) {
	    com_err(whoami, MR_NO_MEM, "setting up SQLDA variables");
	    exit(1);
	}
	it->sqlvar[j].sqllen=ARGLEN;
	it->sqlvar[j].sqlind=null_indicators+j;
	null_indicators[j]=0;
    }
    it->sqln=QMAXARGS;
    return it;
}


/* Use this after FETCH USING DESCRIPTOR one or more
 * result columns may contain NULLs.  This routine is
 * not currently needed, since db/schema creates all
 * columns with a NOT NULL WITH DEFAULT clause.
 *
 * This is currently dead flesh, since no Moira columns
 * allow null values; all use default values.
 */
mr_fix_nulls_in_SQLDA(da)
    MR_SQLDA_T *da;
{
    register IISQLVAR *var;
    register int j;
    int *intp;

    for(j=0, var=da->sqlvar; j<da->sqld; j++, var++) {
	switch(var->sqltype) {
	  case -IISQ_CHA_TYPE:
	    if(*var->sqlind)
	      *var->sqldata='\0';
	    break;
	  case -IISQ_INT_TYPE:
	    if(*var->sqlind) {
		intp=(int *)var->sqldata;
		*intp=0;
	    }
	    break;
	}
    }
}

/* prefetch_value():
 * This routine fetches an appropriate value from the numvalues table.
 * It is a little hack to get around the fact that SQL doesn't let you
 * do something like INSERT INTO table (foo) VALUES (other_table.bar).
 *
 * It is called from the query table as (*v->pre_rtn)(q,Argv,cl) or
 * from within a setup_...() routine with the appropriate arguments.
 *
 * Correct functioning of this routine may depend on the assumption
 * that this query is an APPEND.
 */

prefetch_value(q,argv,cl)
    struct query *q;
    char **argv;
    client *cl;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char *name = q->validate->object_id;
    int value;
    EXEC SQL END DECLARE SECTION;
    int status, limit, argc;

    /* set next object id, limiting it if necessary */
    if(!strcmp(name, "uid") || !strcmp(name, "gid"))
      limit = 1; /* So far as I know, this isn't needed.  Just CMA. */
    else
      limit = 0;
    if((status = set_next_object_id(name, q->rtable, limit)) != MR_SUCCESS)
      return(status);

    /* fetch object id */
    EXEC SQL SELECT value INTO :value FROM numvalues WHERE name=:name;
    if(ingres_errno) return(mr_errcode);
    if(sqlca.sqlerrd[2] != 1) return(MR_INTERNAL);

    argc = q->argc + q->vcnt;   /* end of Argv for APPENDs */
    sprintf(argv[argc],"%d",value);  /** Could save this step by changing tlist from %s to %d **/

    return(MR_SUCCESS);
}

/* prefetch_filesys():
 * Fetches the phys_id from filesys based on the filsys_id in argv[0].
 * Appends the filsys_id and the phys_id to the argv so they can be
 * referenced in an INSERT into a table other than filesys.  Also
 * see comments at prefetch_value().
 *
 * Assumes the existence of a row where filsys_id = argv[0], since a
 * filesys label has already been resolved to a filsys_id.
 */
prefetch_filesys(q,argv,cl)
    struct query *q;
    char **argv;
    client *cl;
{
    EXEC SQL BEGIN DECLARE SECTION;
    int fid,phid;
    EXEC SQL END DECLARE SECTION;
    int argc;

    fid = *(int *)argv[0];
    EXEC SQL SELECT phys_id INTO :phid FROM filesys WHERE filsys_id = :fid;
    if(ingres_errno) return(mr_errcode);

    argc=q->argc+q->vcnt;
    sprintf(argv[argc++],"%d",phid);
    sprintf(argv[argc],"%d",fid);

    return(MR_SUCCESS);
}

/* Convert normal Unix-style wildcards to SQL voodoo */
convert_wildcards(arg)
    char *arg;
{
    static char buffer[ARGLEN];
    register char *s, *d;

    for(d=buffer,s=arg;*s;s++) {
	switch(*s) {
	  case '*': *d++='%'; *d++='%'; break;
	  case '?': *d++='_'; break;
	  case '_':
	  case '[':
	  case ']': *d++='*'; *d++ = *s; break;
	  case '%': *d++='*'; *d++='%'; *d++='%'; break;
	  default: *d++ = *s; break;
	}
    }
    *d='\0';

    /* Copy back into argv */
    strcpy(arg,buffer);

    return(MR_EXISTS);
}

/* This version includes uppercase conversion, for things like gmac.
 * This is necessary because "LIKE" doesn't work with "uppercase()".
 * Including it in a wildcard routine saves making two passes over
 * the argument string.
 */
convert_wildcards_uppercase(arg)
    char *arg;
{
    static char buffer[ARGLEN];
    register char *s, *d;

    for(d=buffer,s=arg;*s;s++) {
	switch(*s) {
	  case '*': *d++='%'; *d++='%'; break;
	  case '?': *d++='_'; break;
	  case '_':
	  case '[':
	  case ']': *d++='*'; *d++ = *s; break;
	  case '%': *d++='*'; *d++='%'; *d++='%'; break;
	  default: *d++=toupper(*s); break;       /* This is the only diff. */
	}
    }
    *d='\0';

    /* Copy back into argv */
    strcpy(arg,buffer);

    return(MR_EXISTS);
}


/* Looks like it's time to build an abstraction barrier, Yogi */
mr_select_any(stmt)
    EXEC SQL BEGIN DECLARE SECTION; 
    char *stmt;
    EXEC SQL END DECLARE SECTION; 
{
    int result=0;

    EXEC SQL PREPARE stmt FROM :stmt;
    EXEC SQL DESCRIBE stmt INTO :SQLDA;
    if(SQLDA->sqld==0)                       /* Not a SELECT */
        return(MR_INTERNAL);        
    EXEC SQL DECLARE csr CURSOR FOR stmt;
    EXEC SQL OPEN csr;
    EXEC SQL FETCH csr USING DESCRIPTOR :SQLDA;
    if(sqlca.sqlcode==0) 
        result=MR_EXISTS;
    else if((sqlca.sqlcode<0) && mr_errcode)
        result=mr_errcode;
    else
        result=0;
    EXEC SQL CLOSE csr;
    return(result);
} 


/*  Adds a string to the string table.  Returns the id number.
 * 
 */
int add_string(name)
    EXEC SQL BEGIN DECLARE SECTION; 
    char *name;
    EXEC SQL END DECLARE SECTION;
{
    EXEC SQL BEGIN DECLARE SECTION;
    char buf[256];
    int id;
    EXEC SQL END DECLARE SECTION; 

    EXEC SQL SELECT value INTO :id FROM numvalues WHERE name = 'strings_id';
    id++;
    EXEC SQL UPDATE numvalues SET value = :id WHERE name = 'strings_id';
    
    /* Use sprintf to get around problem with doubled single quotes */
    sprintf(buf,"INSERT INTO strings (string_id, string) VALUES (%d, '%s')",id,name);
    EXEC SQL EXECUTE IMMEDIATE :buf;
 
    return(id);
}
Commit	Line	Data
73cf66ba	1	/*
	2	* $Source$
	3	* $Author$
	4	* $Header$
	5	*
	6	* Copyright (C) 1987 by the Massachusetts Institute of Technology
	7	* For copying and distribution information, please see the file
	8	* <mit-copyright.h>.
	9	*
	10	*/
	11
	12	#ifndef lint
	13	static char *rcsid_qsupport_dc = "$Header$";
	14	#endif lint
	15
	16	#include <mit-copyright.h>
	17	#include <unistd.h>
	18	#include "query.h"
	19	#include "mr_server.h"
	20	#include <ctype.h>
	21	EXEC SQL INCLUDE sqlca;
	22	EXEC SQL INCLUDE sqlda;
	23	#include "qrtn.h"
	24
	25	extern char *whoami;
	26	extern int ingres_errno, mr_errcode;
	27
	28	EXEC SQL BEGIN DECLARE SECTION;
	29	extern char stmt_buf[];
	30	EXEC SQL END DECLARE SECTION;
	31
	32	EXEC SQL WHENEVER SQLERROR CALL ingerr;
	33
	34
	35	/* Validation Routines */
	36
	37	validate_row(q, argv, v)
	38	register struct query *q;
	39	char *argv[];
	40	register struct validate *v;
	41	{
	42	EXEC SQL BEGIN DECLARE SECTION;
	43	char *name;
	44	char qual[128];
	45	int rowcount;
	46	EXEC SQL END DECLARE SECTION;
	47
	48	/* build where clause */
	49	build_qual(v->qual, v->argc, argv, qual);
	50
	51	if (log_flags & LOG_VALID)
	52	/* tell the logfile what we're doing */
	53	com_err(whoami, 0, "validating row: %s", qual);
	54
	55	/* look for the record */
	56	sprintf(stmt_buf,"SELECT COUNT (*) FROM %s WHERE %s",q->rtable,qual);
	57	EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
	58	if(sqlca.sqlcode)
	59	return(MR_INTERNAL);
	60	EXEC SQL DECLARE csr126 CURSOR FOR stmt;
	61	EXEC SQL OPEN csr126;
	62	EXEC SQL FETCH csr126 USING DESCRIPTOR :SQLDA;
	63	EXEC SQL CLOSE csr126;
	64	rowcount = (int )SQLDA->sqlvar[0].sqldata;
65
66	if (ingres_errno) return(mr_errcode);
67	if (rowcount == 0) return(MR_NO_MATCH);
68	if (rowcount > 1) return(MR_NOT_UNIQUE);
69	return(MR_EXISTS);
70	}
71
72	validate_fields(q, argv, vo, n)
73	struct query *q;
74	register char *argv[];
75	register struct valobj *vo;
76	register int n;
77	{
78	register int status;
79
80	while (--n >= 0) {
81	switch (vo->type) {
82	case V_NAME:
83	if (log_flags & LOG_VALID)
84	com_err(whoami, 0, "validating %s in %s: %s",
85	vo->namefield, vo->table, argv[vo->index]);
86	status = validate_name(argv, vo);
87	break;
88
89	case V_ID:
90	if (log_flags & LOG_VALID)
91	com_err(whoami, 0, "validating %s in %s: %s",
92	vo->idfield, vo->table, argv[vo->index]);
93	status = validate_id(q, argv, vo);
94	break;
95
96	case V_DATE:
97	if (log_flags & LOG_VALID)
98	com_err(whoami, 0, "validating date: %s", argv[vo->index]);
99	status = validate_date(argv, vo);
100	break;
101
102	case V_TYPE:
103	if (log_flags & LOG_VALID)
104	com_err(whoami, 0, "validating %s type: %s",
105	vo->table, argv[vo->index]);
106	status = validate_type(argv, vo);
107	break;
108
109	case V_TYPEDATA:
110	if (log_flags & LOG_VALID)
111	com_err(whoami, 0, "validating typed data (%s): %s",
112	argv[vo->index - 1], argv[vo->index]);
113	status = validate_typedata(q, argv, vo);
114	break;
115
116	case V_RENAME:
117	if (log_flags & LOG_VALID)
118	com_err(whoami, 0, "validating rename %s in %s",
119	argv[vo->index], vo->table);
120	status = validate_rename(argv, vo);
121	break;
122
123	case V_CHAR:
124	if (log_flags & LOG_VALID)
125	com_err(whoami, 0, "validating chars: %s", argv[vo->index]);
126	status = validate_chars(argv[vo->index]);
127	break;
128
129	case V_SORT:
130	status = MR_EXISTS;
131	break;
132
133	case V_LOCK:
134	status = lock_table(vo);
135	break;
136
137	case V_WILD:
138	status = convert_wildcards(argv[vo->index]);
139	break;
140
141	case V_UPWILD:
142	status = convert_wildcards_uppercase(argv[vo->index]);
143	break;
144
145	}
146
147	if (status != MR_EXISTS) return(status);
148	vo++;
149	}
150
151	if (ingres_errno) return(mr_errcode);
152	return(MR_SUCCESS);
153	}
154
155
156	/* validate_chars: verify that there are no illegal characters in
157	* the string. Legal characters are printing chars other than
158	* ", *, ?, \, [ and ].
159	*/
160	static int illegalchars[] = {
161	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^@ - ^O */
162	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^P - ^_ */
163	0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* SPACE - / */
164	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* 0 - ? */
165	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* : - O */
166	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, /* P - _ */
167	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ` - o */
168	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, /* p - ^? */
169	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
170	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
171	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
172	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
173	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
174	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
175	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
176	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
177	};
178
179	validate_chars(s)
180	register char *s;
181	{
182	while (*s)
183	if (illegalchars[*s++])
184	return(MR_BAD_CHAR);
185	return(MR_EXISTS);
186	}
187
188
189	validate_id(q, argv, vo)
190	struct query *q;
191	char *argv[];
192	register struct valobj *vo;
193	{
194	EXEC SQL BEGIN DECLARE SECTION;
195	char name, tbl, namefield, idfield;
196	int id, rowcount;
197	EXEC SQL END DECLARE SECTION;
198	int status;
199	register char *c;
200
201	name = argv[vo->index];
202	tbl = vo->table;
203	namefield = vo->namefield;
204	idfield = vo->idfield;
205
206	if ((!strcmp(tbl, "users") && !strcmp(namefield, "login")) \|\|
207	!strcmp(tbl, "machine") \|\|
208	!strcmp(tbl, "subnet") \|\|
209	!strcmp(tbl, "filesys") \|\|
210	!strcmp(tbl, "list") \|\|
211	!strcmp(tbl, "cluster") \|\|
212	!strcmp(tbl, "strings")) {
213	if (!strcmp(tbl, "machine") \|\| !strcmp(tbl, "subnet"))
214	for (c = name; c; c++) if (islower(c)) c = toupper(c);
215	status = name_to_id(name, tbl, &id);
216	if (status == 0) {
217	(int )argv[vo->index] = id;
218	return(MR_EXISTS);
219	} else if (status == MR_NO_MATCH && !strcmp(tbl, "strings") &&
220	(q->type == APPEND \|\| q->type == UPDATE)) {
221	id=add_string(name);
222	cache_entry(name, "STRING", id);
223	(int )argv[vo->index] = id;
224	return(MR_EXISTS);
225	} else if (status == MR_NO_MATCH \|\| status == MR_NOT_UNIQUE)
226	return(vo->error);
227	else
228	return(status);
229	}
230
231	if (!strcmp(namefield, "uid")) {
232	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = %s",idfield,tbl,namefield,name);
233	} else {
234	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = '%s'",idfield,tbl,namefield,name);
235	}
236	EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
237	if(sqlca.sqlcode)
238	return(MR_INTERNAL);
239	EXEC SQL DECLARE csr127 CURSOR FOR stmt;
240	EXEC SQL OPEN csr127;
241	rowcount=0;
242	EXEC SQL FETCH csr127 USING DESCRIPTOR :SQLDA;
243	if(sqlca.sqlcode == 0) {
244	rowcount++;
245	EXEC SQL FETCH csr127 USING DESCRIPTOR :SQLDA;
246	if(sqlca.sqlcode == 0) rowcount++;
247	}
248	EXEC SQL CLOSE csr127;
249	if (ingres_errno)
250	return(mr_errcode);
251
252	if (rowcount != 1) return(vo->error);
253	bcopy(SQLDA->sqlvar[0].sqldata,argv[vo->index],sizeof(int));
254	return(MR_EXISTS);
255	}
256
257	validate_name(argv, vo)
258	char *argv[];
259	register struct valobj *vo;
260	{
261	EXEC SQL BEGIN DECLARE SECTION;
262	char name, tbl, *namefield;
263	int rowcount;
264	EXEC SQL END DECLARE SECTION;
265	register char *c;
266
267	name = argv[vo->index];
268	tbl = vo->table;
269	namefield = vo->namefield;
270	if (!strcmp(tbl, "servers") && !strcmp(namefield, "name")) {
271	for (c = name; *c; c++)
272	if (islower(*c))
273	c = toupper(c);
274	}
275	sprintf(stmt_buf,"SELECT DISTINCT COUNT(*) FROM %s WHERE %s.%s = '%s'",
276	tbl,tbl,namefield,name);
277	EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
278	if(sqlca.sqlcode)
279	return(MR_INTERNAL);
280	EXEC SQL DECLARE csr128 CURSOR FOR stmt;
281	EXEC SQL OPEN csr128;
282	EXEC SQL FETCH csr128 USING DESCRIPTOR :SQLDA;
283	rowcount = (int )SQLDA->sqlvar[0].sqldata;
284	EXEC SQL CLOSE csr128;
285
286	if (ingres_errno) return(mr_errcode);
287	return ((rowcount == 1) ? MR_EXISTS : vo->error);
288	}
289
290	validate_date(argv, vo)
291	char *argv[];
292	struct valobj *vo;
293	{
294	EXEC SQL BEGIN DECLARE SECTION;
295	char *idate;
296	double dd;
297	int errorno;
298	EXEC SQL END DECLARE SECTION;
299
300	idate = argv[vo->index];
301	EXEC SQL SELECT interval('years',date(:idate)-date('today')) INTO :dd;
302
303	if (sqlca.sqlcode != 0 \|\| dd > 5.0) return(MR_DATE);
304	return(MR_EXISTS);
305	}
306
307
308	validate_rename(argv, vo)
309	char *argv[];
310	struct valobj *vo;
311	{
312	EXEC SQL BEGIN DECLARE SECTION;
313	char name, tbl, namefield, idfield;
314	int id;
315	EXEC SQL END DECLARE SECTION;
316	int status;
317	register char *c;
318
319	c = name = argv[vo->index];
320	while (*c)
321	if (illegalchars[*c++])
322	return(MR_BAD_CHAR);
323	tbl = vo->table;
324	/* minor kludge to upcasify machine names */
325	if (!strcmp(tbl, "machine"))
326	for (c = name; c; c++) if (islower(c)) c = toupper(c);
327	namefield = vo->namefield;
328	idfield = vo->idfield;
329	id = -1;
330	if (idfield == 0) {
331	if (!strcmp(argv[vo->index], argv[vo->index - 1]))
332	return(MR_EXISTS);
333	sprintf(stmt_buf,"SELECT %s FROM %s WHERE %s = LEFT('%s',SIZE(%s))",
334	namefield,tbl,namefield,name,namefield);
335	EXEC SQL PREPARE stmt INTO :SQLDA USING NAMES FROM :stmt_buf;
336	if(sqlca.sqlcode)
337	return(MR_INTERNAL);
338	EXEC SQL DECLARE csr129 CURSOR FOR stmt;
339	EXEC SQL OPEN csr129;
340	EXEC SQL FETCH csr129 USING DESCRIPTOR :SQLDA;
341	if(sqlca.sqlcode == 0) id=1; else id=0;
342	EXEC SQL CLOSE csr129;
343
344	if (ingres_errno) return(mr_errcode);
345	if (id)
346	return(vo->error);
347	else
348	return(MR_EXISTS);
349	}
350	status = name_to_id(name, tbl, &id);
351	if (status == MR_NO_MATCH \|\| id == (int )argv[vo->index - 1])
352	return(MR_EXISTS);
353	else
354	return(vo->error);
355	}
356
357
358	validate_type(argv, vo)
359	char *argv[];
360	register struct valobj *vo;
361	{
362	EXEC SQL BEGIN DECLARE SECTION;
363	char *typename;
364	char *val;
365	int cnt;
366	EXEC SQL END DECLARE SECTION;
367	register char *c;
368
369	typename = vo->table;
370	c = val = argv[vo->index];
371	while (*c) {
372	if (illegalchars[*c++])
373	return(MR_BAD_CHAR);
374	}
375
376	/* uppercase type fields */
377	for (c = val; c; c++) if (islower(c)) c = toupper(c);
378
379	EXEC SQL SELECT COUNT(trans) INTO :cnt FROM alias
380	WHERE name = :typename AND type='TYPE' AND trans = :val;
381	if (ingres_errno) return(mr_errcode);
382	return (cnt ? MR_EXISTS : vo->error);
383	}
384
385	/* validate member or type-specific data field */
386
387	validate_typedata(q, argv, vo)
388	register struct query *q;
389	register char *argv[];
390	register struct valobj *vo;
391	{
392	EXEC SQL BEGIN DECLARE SECTION;
393	char *name;
394	char *field_type;
395	char data_type[129];
396	int id;
397	EXEC SQL END DECLARE SECTION;
398	int status;
399	char *index();
400	register char *c;
401
402	/* get named object */
403	name = argv[vo->index];
404
405	/* get field type string (known to be at index-1) */
406	field_type = argv[vo->index-1];
407
408	/* get corresponding data type associated with field type name */
409	EXEC SQL SELECT trans INTO :data_type FROM alias
410	WHERE name = :field_type AND type='TYPEDATA';
411	if (ingres_errno) return(mr_errcode);
412	if (sqlca.sqlerrd[2] != 1) return(MR_TYPE);
413
414	/* now retrieve the record id corresponding to the named object */
415	if (index(data_type, ' '))
416	*index(data_type, ' ') = 0;
417	if (!strcmp(data_type, "user")) {
418	/* USER */
419	if (index(name, '@'))
420	return(MR_USER);
421	status = name_to_id(name, data_type, &id);
422	if (status && (status == MR_NO_MATCH \|\| status == MR_NOT_UNIQUE))
423	return(MR_USER);
424	if (status) return(status);
425	} else if (!strcmp(data_type, "list")) {
426	/* LIST */
427	status = name_to_id(name, data_type, &id);
428	if (status && status == MR_NOT_UNIQUE)
429	return(MR_LIST);
430	if (status == MR_NO_MATCH) {
431	/* if idfield is non-zero, then if argv[0] matches the string
432	* that we're trying to resolve, we should get the value of
433	* numvalues.[idfield] for the id.
434	*/
435	if (vo->idfield && !strcmp(argv[0], argv[vo->index])) {
436	set_next_object_id(q->validate->object_id, q->rtable, 0);
437	name = vo->idfield;
438	EXEC SQL REPEATED SELECT value INTO :id FROM numvalues
439	WHERE name = :name;
440	if (sqlca.sqlerrd[2] != 1) return(MR_LIST);
441	} else
442	return(MR_LIST);
443	} else if (status) return(status);
444	} else if (!strcmp(data_type, "machine")) {
445	/* MACHINE */
446	for (c = name; c; c++) if (islower(c)) c = toupper(c);
447	status = name_to_id(name, data_type, &id);
448	if (status && (status == MR_NO_MATCH \|\| status == MR_NOT_UNIQUE))
449	return(MR_MACHINE);
450	if (status) return(status);
451	} else if (!strcmp(data_type, "string")) {
452	/* STRING */
453	status = name_to_id(name, data_type, &id);
454	if (status && status == MR_NOT_UNIQUE)
455	return(MR_STRING);
456	if (status == MR_NO_MATCH) {
457	if (q->type != APPEND && q->type != UPDATE) return(MR_STRING);
458	id=add_string(name);
459	cache_entry(name, "STRING", id);
460	} else if (status) return(status);
461	} else if (!strcmp(data_type, "none")) {
462	id = 0;
463	} else {
464	return(MR_TYPE);
465	}
466
467	/* now set value in argv */
468	(int )argv[vo->index] = id;
469
470	return (MR_EXISTS);
471	}
472
473
474	/* Lock the table named by the validation object */
475
476	lock_table(vo)
477	struct valobj *vo;
478	{
479	sprintf(stmt_buf,"UPDATE %s SET modtime='now' WHERE %s.%s = 0",
480	vo->table,vo->table,vo->idfield);
481	EXEC SQL EXECUTE IMMEDIATE :stmt_buf;
482	if (ingres_errno) return(mr_errcode);
483	if (sqlca.sqlerrd[2] != 1)
484	return(vo->error);
485	else
486	return(MR_EXISTS);
487	}
488
489
490	/* Check the database at startup time. For now this just resets the
491	* inprogress flags that the DCM uses.
492	*/
493
494	sanity_check_database()
495	{
496	}
497
498
499	/* Dynamic SQL support routines */
500	MR_SQLDA_T *mr_alloc_SQLDA()
501	{
502	MR_SQLDA_T *it;
503	short *null_indicators;
504	register int j;
505
506	if((it=(MR_SQLDA_T *)malloc(sizeof(MR_SQLDA_T)))==NULL) {
507	com_err(whoami, MR_NO_MEM, "setting up SQLDA");
508	exit(1);
509	}
510
511	if((null_indicators=(short *)calloc(QMAXARGS,sizeof(short)))==NULL) {
512	com_err(whoami, MR_NO_MEM, "setting up SQLDA null indicators");
513	exit(1);
514	}
515
516	for(j=0; j<QMAXARGS; j++) {
517	if((it->sqlvar[j].sqldata=malloc(sizeof(short)+ARGLEN))==NULL) {
518	com_err(whoami, MR_NO_MEM, "setting up SQLDA variables");
519	exit(1);
520	}
521	it->sqlvar[j].sqllen=ARGLEN;
522	it->sqlvar[j].sqlind=null_indicators+j;
523	null_indicators[j]=0;
524	}
525	it->sqln=QMAXARGS;
526	return it;
527	}
528
529
530	/* Use this after FETCH USING DESCRIPTOR one or more
531	* result columns may contain NULLs. This routine is
532	* not currently needed, since db/schema creates all
533	* columns with a NOT NULL WITH DEFAULT clause.
534	*
535	* This is currently dead flesh, since no Moira columns
536	* allow null values; all use default values.
537	*/
538	mr_fix_nulls_in_SQLDA(da)
539	MR_SQLDA_T *da;
540	{
541	register IISQLVAR *var;
542	register int j;
543	int *intp;
544
545	for(j=0, var=da->sqlvar; j<da->sqld; j++, var++) {
546	switch(var->sqltype) {
547	case -IISQ_CHA_TYPE:
548	if(*var->sqlind)
549	*var->sqldata='\0';
550	break;
551	case -IISQ_INT_TYPE:
552	if(*var->sqlind) {
553	intp=(int *)var->sqldata;
554	*intp=0;
555	}
556	break;
557	}
558	}
559	}
560
561	/* prefetch_value():
562	* This routine fetches an appropriate value from the numvalues table.
563	* It is a little hack to get around the fact that SQL doesn't let you
564	* do something like INSERT INTO table (foo) VALUES (other_table.bar).
565	*
566	* It is called from the query table as (*v->pre_rtn)(q,Argv,cl) or
567	* from within a setup_...() routine with the appropriate arguments.
568	*
569	* Correct functioning of this routine may depend on the assumption
570	* that this query is an APPEND.
571	*/
572
573	prefetch_value(q,argv,cl)
574	struct query *q;
575	char **argv;
576	client *cl;
577	{
578	EXEC SQL BEGIN DECLARE SECTION;
579	char *name = q->validate->object_id;
580	int value;
581	EXEC SQL END DECLARE SECTION;
582	int status, limit, argc;
583
584	/* set next object id, limiting it if necessary */
585	if(!strcmp(name, "uid") \|\| !strcmp(name, "gid"))
586	limit = 1; /* So far as I know, this isn't needed. Just CMA. */
587	else
588	limit = 0;
589	if((status = set_next_object_id(name, q->rtable, limit)) != MR_SUCCESS)
590	return(status);
591
592	/* fetch object id */
593	EXEC SQL SELECT value INTO :value FROM numvalues WHERE name=:name;
594	if(ingres_errno) return(mr_errcode);
595	if(sqlca.sqlerrd[2] != 1) return(MR_INTERNAL);
596
597	argc = q->argc + q->vcnt; /* end of Argv for APPENDs */
598	sprintf(argv[argc],"%d",value); / Could save this step by changing tlist from %s to %d /
599
600	return(MR_SUCCESS);
601	}
602
603	/* prefetch_filesys():
604	* Fetches the phys_id from filesys based on the filsys_id in argv[0].
605	* Appends the filsys_id and the phys_id to the argv so they can be
606	* referenced in an INSERT into a table other than filesys. Also
607	* see comments at prefetch_value().
608	*
609	* Assumes the existence of a row where filsys_id = argv[0], since a
610	* filesys label has already been resolved to a filsys_id.
611	*/
612	prefetch_filesys(q,argv,cl)
613	struct query *q;
614	char **argv;
615	client *cl;
616	{
617	EXEC SQL BEGIN DECLARE SECTION;
618	int fid,phid;
619	EXEC SQL END DECLARE SECTION;
620	int argc;
621
622	fid = (int )argv[0];
623	EXEC SQL SELECT phys_id INTO :phid FROM filesys WHERE filsys_id = :fid;
624	if(ingres_errno) return(mr_errcode);
625
626	argc=q->argc+q->vcnt;
627	sprintf(argv[argc++],"%d",phid);
628	sprintf(argv[argc],"%d",fid);
629
630	return(MR_SUCCESS);
631	}
632
633	/* Convert normal Unix-style wildcards to SQL voodoo */
634	convert_wildcards(arg)
635	char *arg;
636	{
637	static char buffer[ARGLEN];
638	register char s, d;
639
640	for(d=buffer,s=arg;*s;s++) {
641	switch(*s) {
642	case '': d++='%'; *d++='%'; break;
643	case '?': *d++='_'; break;
644	case '_':
645	case '[':
646	case ']': d++=''; d++ = s; break;
647	case '%': d++=''; d++='%'; d++='%'; break;
648	default: d++ = s; break;
649	}
650	}
651	*d='\0';
652
653	/* Copy back into argv */
654	strcpy(arg,buffer);
655
656	return(MR_EXISTS);
657	}
658
659	/* This version includes uppercase conversion, for things like gmac.
660	* This is necessary because "LIKE" doesn't work with "uppercase()".
661	* Including it in a wildcard routine saves making two passes over
662	* the argument string.
663	*/
664	convert_wildcards_uppercase(arg)
665	char *arg;
666	{
667	static char buffer[ARGLEN];
668	register char s, d;
669
670	for(d=buffer,s=arg;*s;s++) {
671	switch(*s) {
672	case '': d++='%'; *d++='%'; break;
673	case '?': *d++='_'; break;
674	case '_':
675	case '[':
676	case ']': d++=''; d++ = s; break;
677	case '%': d++=''; d++='%'; d++='%'; break;
678	default: d++=toupper(s); break; /* This is the only diff. */
679	}
680	}
681	*d='\0';
682
683	/* Copy back into argv */
684	strcpy(arg,buffer);
685
686	return(MR_EXISTS);
687	}
688
689
690	/* Looks like it's time to build an abstraction barrier, Yogi */
691	mr_select_any(stmt)
692	EXEC SQL BEGIN DECLARE SECTION;
693	char *stmt;
694	EXEC SQL END DECLARE SECTION;
695	{
696	int result=0;
697
698	EXEC SQL PREPARE stmt FROM :stmt;
699	EXEC SQL DESCRIBE stmt INTO :SQLDA;
700	if(SQLDA->sqld==0) /* Not a SELECT */
701	return(MR_INTERNAL);
702	EXEC SQL DECLARE csr CURSOR FOR stmt;
703	EXEC SQL OPEN csr;
704	EXEC SQL FETCH csr USING DESCRIPTOR :SQLDA;
705	if(sqlca.sqlcode==0)
706	result=MR_EXISTS;
707	else if((sqlca.sqlcode<0) && mr_errcode)
708	result=mr_errcode;
709	else
710	result=0;
711	EXEC SQL CLOSE csr;
712	return(result);
713	}
714
715
716
717	/* Adds a string to the string table. Returns the id number.
718	*
719	*/
720	int add_string(name)
721	EXEC SQL BEGIN DECLARE SECTION;
722	char *name;
723	EXEC SQL END DECLARE SECTION;
724	{
725	EXEC SQL BEGIN DECLARE SECTION;
726	char buf[256];
727	int id;
728	EXEC SQL END DECLARE SECTION;
729
730	EXEC SQL SELECT value INTO :id FROM numvalues WHERE name = 'strings_id';
731	id++;
732	EXEC SQL UPDATE numvalues SET value = :id WHERE name = 'strings_id';
733
734	/* Use sprintf to get around problem with doubled single quotes */
735	sprintf(buf,"INSERT INTO strings (string_id, string) VALUES (%d, '%s')",id,name);
736	EXEC SQL EXECUTE IMMEDIATE :buf;
737
738	return(id);
739	}
740