head	1.10;
access;
symbols
	release_4_2:1.10
	aix_ok:1.10
	Version_2_1:1.6
	Version_2:1.4;
locks; strict;
comment	@ * @;


1.10
date	93.09.27.04.54.15;	author aoki;	state Exp;
branches;
next	1.9;

1.9
date	93.01.16.03.14.59;	author aoki;	state Exp;
branches;
next	1.8;

1.8
date	91.11.11.22.59.28;	author hong;	state Exp;
branches;
next	1.7;

1.7
date	91.08.18.02.08.36;	author caetta;	state Exp;
branches;
next	1.6;

1.6
date	90.08.18.14.16.29;	author cimarron;	state Exp;
branches;
next	1.5;

1.5
date	90.08.14.16.20.30;	author cimarron;	state Exp;
branches;
next	1.4;

1.4
date	90.03.31.19.01.31;	author cimarron;	state Version_2;
branches;
next	1.3;

1.3
date	89.10.12.14.52.13;	author hirohama;	state Exp;
branches;
next	1.2;

1.2
date	89.10.11.15.19.32;	author hirohama;	state Exp;
branches;
next	1.1;

1.1
date	89.10.09.18.36.24;	author hirohama;	state Exp;
branches;
next	;


desc
@@


1.10
log
@changed Assert(false) -> Assert(0)
(aix compiler doesn't like !enum)
@
text
@/* ----------------------------------------------------------------
 *   FILE
 *	parsev.c
 *	
 *   DESCRIPTION
 *	Parser validity checking code.
 *
 *   INTERFACE ROUTINES
 *	ValidateParse
 *
 *   NOTES
 *	Not sure why this is in the tcop directory
 *
 *   IDENTIFICATION
 *	$Header: /data/01/postgres/src/backend/tcop/RCS/parsev.c,v 1.9 1993/01/16 03:14:59 aoki Exp $
 * ----------------------------------------------------------------
 */

#include "tmp/postgres.h"

RcsId("$Header: /data/01/postgres/src/backend/tcop/RCS/parsev.c,v 1.9 1993/01/16 03:14:59 aoki Exp $");

/* ----------------
 *	FILE INCLUDE ORDER GUIDELINES
 *
 *	1) tcopdebug.h
 *	2) various support files ("everything else")
 *	3) node files
 *	4) catalog/ files
 *	5) execdefs.h and execmisc.h, if necessary.
 *	6) extern files come last.
 * ----------------
 */
#include "tcop/tcopdebug.h"

#include "parse.h"
#include "utils/log.h"

#include "nodes/pg_lisp.h"

/* ----------------
 *	ValidateParsedQuery
 * ----------------
 */
static void
ValidateParsedQuery(parse)
    List	parse;
{
    AssertArg(consp(parse) && !lispIntegerp(CAR(parse)));

    /*
     * XXX code here
     */
}

/* ----------------
 *	ValidateUtility
 * ----------------
 */
static void
ValidateUtility(command, args)
	int		command;	/* "tag" */
	LispValue	args;
{
	switch (command) {
		/*
		 * transactions
		 */
	case BEGIN_TRANS:
	case END_TRANS:
	case ABORT_TRANS:
		AssertArg(null(args));
		break;

		/*
		 * portal manipulation
		 */
	case CLOSE:
		AssertArg(consp(args));
		AssertArg(null(CDR(args)));
		AssertArg(null(CAR(args)) || lispStringp(CAR(args)));
		break;
	case FETCH:
		AssertArg(consp(args));
		AssertArg(consp(CDR(args)));
		AssertArg(lispAtomp(CADR(args)));
		AssertArg(CAtom(CADR(args)) == FORWARD || CAtom(CADR(args)) == BACKWARD);
		AssertArg(consp(CDR(CDR(args))));
		AssertArg(lispIntegerp(CADDR(args)) || lispAtomp(CADDR(args)));
		AssertArg(null(CDR(CDR(CDR(args)))));

		if (!null(CAR(args))) {
			AssertArg(lispStringp(CAR(args)));
		}
		if (lispAtomp(CADDR(args))) {
			AssertArg(CAtom(CADDR(args)) == ALL);
		}
		break;
	case MOVE:
		/*
		 * XXX code here
		 */
		break;

		/*
		 * relation and attribute manipulation
		 */
	case CREATE:
	{
		List	l;
		List	schema;
		

		AssertArg(length(args) >= 2);
		AssertArg(lispStringp(CAR(args)));
		/*
		 * validate parameters
		 */
		l = CADR(args);
		AssertArg(listp(l) && length(l) == 4);
		if (!lispNullp(CAR(l))) {
			AssertArg(lispIntegerp(CAR(CAR(l))));
			AssertArg(CInteger(CAR(CAR(l))) == KEY);
			/*
			 * XXX validate KEY here
			 */
		}
		l = CDR(l);
		if (!lispNullp(CAR(l))) {
			List	inheritList;

			AssertArg(lispIntegerp(CAR(CAR(l))));
			AssertArg(CInteger(CAR(CAR(l))) == INHERITS);

			inheritList = CDR(CAR(l));
			/* duplicates? */
		}
		l = CDR(l);
		if (!lispNullp(CAR(l))) {
			AssertArg(lispIntegerp(CAR(CAR(l))));
			AssertArg(CInteger(CAR(CAR(l))) == INDEXABLE);
			/*
			 * XXX validate INDEXABLE here
			 */
		}
		l = CDR(l);
		if (!lispNullp(CAR(l))) {
			AssertArg(lispIntegerp(CAR(CAR(l))));
			AssertArg(CInteger(CAR(CAR(l))) == ARCHIVE);
			/*
			 * XXX validate ARCHIVE here
			 */
		}

		/*
		 * validate schema
		 */
		schema = CDR(CDR(args));
		AssertArg(listp(schema));
		foreach (l, schema) {
			AssertArg(listp(CAR(l)));
			AssertArg(listp(CDR(CAR(l))));
			AssertArg(lispStringp(CAR(CAR(l))));
			AssertArg(lispStringp(CADR(CAR(l))));
		}
	}
		break;

	case DESTROY:
		AssertArg(consp(args));
	{
		LispValue relationName;
		foreach (relationName, args) {
			AssertArg(lispStringp(CAR(relationName)));
		}
	}
		break;

	case PURGE:
	{
		List	tags;

		AssertArg(listp(args));
		AssertArg(length(args) == 2);

		tags = CADR(args);
		switch (length(tags)) {
		case 0:
			break;
		case 1:
			AssertArg(lispIntegerp(CAR(CAR(tags))));
			AssertArg(lispStringp(CADR(CAR(tags))));

			AssertArg(CInteger(CAR(CAR(tags))) == BEFORE || CInteger(CAR(CAR(tags))) == AFTER);
			break;
		case 2:
			AssertArg(lispIntegerp(CAR(CAR(tags))));
			AssertArg(CInteger(CAR(CAR(tags))) == BEFORE);
			AssertArg(lispStringp(CADR(CAR(tags))));
			AssertArg(lispIntegerp(CAR(CADR(tags))));
			AssertArg(CInteger(CAR(CADR(tags))) == AFTER);
			AssertArg(lispStringp(CADR(CADR(tags))));
			break;
		default:
			AssertArg(0);
		}
	}
		break;

	case COPY:
	{
		AssertArg(length(args) >= 3);
		AssertArg(length(CAR(args)) == 3);
		AssertArg(lispStringp(CAAR(args)));

		if (!null(CADR(CAR(args)))) {
			AssertArg(lispIntegerp(CADR(CAR(args))));
			AssertArg(CInteger(CADR(CAR(args))) == BINARY);
		}
		if (!null(CADDR(CAR(args)))) {
			AssertArg(lispIntegerp(CADDR(CAR(args))));
			AssertArg(CInteger(CADDR(CAR(args))) == NONULLS);
		}
		/*
		 * discard '("relname" [BINARY] [NONULLS])
		 */
		args = CDR(args);

		AssertArg(length(CAR(args)) == 2);
		AssertArg(lispAtomp(CAAR(args)));
		AssertArg(lispStringp(CADR(CAR(args))));
		AssertArg(CAtom(CAAR(args)) == FROM || CAtom(CAAR(args)) == TO);
		/*
		 * discard '(FROM/TO "filename")
		 */
		args = CDR(args);

		AssertArg(length(CAR(args)) >= 1);
		AssertArg(lispAtomp(CAAR(args)));
		AssertArg(CAtom(CAAR(args)) == USING);

		if (!null(CDR(CAR(args)))) {
			AssertArg(length(CAR(args)) == 2);
			AssertArg(lispStringp(CADR(CAR(args))));
		}
		/*
		 * discard '(USING ["mapName"])
		 */
		args = CDR(args);

		/*
		 * XXX Check the format of args (the domain list) here
		 */
	}
		break;

	case ADD_ATTR:
	{
		List	element;

		AssertArg(length(args) >= 2);
		AssertArg(lispStringp(CAR(args)));

		foreach (element, CDR(args)) {
			AssertArg(consp(CAR(element)));
			AssertArg(lispStringp(CAR(CAR(element))));
			AssertArg(lispStringp(CADR(CAR(element))));
			AssertArg(null(CDR(CDR(CAR(element)))));
		}
	}
		break;

		/*
		 * schema
		 */
	case RENAME:
	{
		int	len;

		len = length(args);

		AssertArg(len == 3 || len == 4);
		AssertArg(lispStringp(CAR(args)));
		AssertArg(lispStringp(CADR(args)));
		AssertArg(lispStringp(CADDR(args)));
		if (len == 3) {
			NameIsEqual((Name)CString(CAR(args)), (Name)"RELATION");
		} else {
			NameIsEqual((Name)CString(CAR(args)),(Name)"ATTRIBUTE");
			AssertArg(lispStringp(CADDR(CDR(args))));
		}
	}
		break;

		/*
		 * object creation
		 */
	case DEFINE:
		/*
		 * Index is an integer; Type, etc. are atoms?!?
		 */
		AssertArg(atom(CAR(args)) || integerp(CAR(args)));

		switch(LISPVALUE_INTEGER(CAR(args))) {
		case INDEX:	/* XXX no support for ARCHIVE indices, yet */
			args = CDR(args);	/* skip "INDEX" token */

			AssertArg(listp(args));
			AssertArg(lispStringp(CAR(args)));
			AssertArg(listp(CDR(args)));
			AssertArg(lispStringp(CADR(args)));
			AssertArg(listp(CDR(CDR(args))));
			AssertArg(lispStringp(CADDR(args)));
			AssertArg(listp(CDR(CDR(CDR(args)))));
			AssertArg(listp(CDR(CDR(CDR(CDR(args))))));
			break;
		case OPERATOR:
			args = CDR(args);	/* skip "OPERATOR" token */

			AssertArg(listp(args));
			AssertArg(lispStringp(CAR(args)));
			AssertArg(listp(CDR(args)));
			break;
		case FUNCTION:
			args = CDR(args);	/* skip "FUNCTION" token */

			AssertArg(listp(args));
			AssertArg(lispStringp(CAR(args)));
			AssertArg(listp(CDR(args)));
			break;
		case AGGREGATE:
			args = CDR(args);

			AssertArg(listp(args));
			AssertArg(lispStringp(CAR(args)));
			AssertArg(listp(CDR(args)));
			break;
		case RULE:
			AssertArg(listp(args));
			AssertArg(lispStringp(CADR(args)));
			AssertArg(listp(CADDR(args)));
			break;

		case P_TYPE:
			args = CDR(args);	/* skip "TYPE" token */

			AssertArg(listp(args));
			AssertArg(lispStringp(CAR(args)));
			AssertArg(listp(CDR(args)));
			break;
		default:
			AssertArg(0);
			break;
		}
		break;

		/*
		 * object destruction
		 */
	case REMOVE:
		AssertArg(consp(args));

		switch(CInteger(CAR(args))) {
		case FUNCTION:
		case AGGREGATE:
		case INDEX:
		case RULE:
		case P_TYPE:
			AssertArg(length(args) == 2);
			AssertArg(lispStringp(CADR(args)));
			break;
		case OPERATOR:
		{
			int	argCount;

			AssertArg(consp(CADR(args)));
			AssertArg(null(CDR(CDR(args))));

			args = CADR(args);
			argCount = length(args);

			AssertArg(lispStringp(CAR(args)));
			AssertArg(2 <= argCount && argCount <= 3);
			AssertArg(lispStringp(CADR(args)));
			if (argCount == 3) {
				AssertArg(lispStringp(CADR(CDR(args))));
			}
		}
			break;
		default:
			AssertArg(0);
		}
		break;
			
		/* default */
	default:
		break;
	}
}

/* ----------------
 *	ValidateParse
 * ----------------
 */
void
ValidateParse(parse)
	List	parse;
{
	AssertArg(consp(parse));

	if (!lispIntegerp(CAR(parse))) {
		ValidateParsedQuery(parse);
	} else {
		ValidateUtility(CInteger(CAR(parse)), CDR(parse));
	}
}
@


1.9
log
@removed references to utils/fmgr.h and parser/parse.h
@
text
@d15 1
a15 1
 *	$Header: /home2/aoki/postgres/src/backend/tcop/RCS/parsev.c,v 1.8 1991/11/11 22:59:28 hong Exp aoki $
d21 1
a21 1
 RcsId("$Header: /home2/aoki/postgres/src/backend/tcop/RCS/parsev.c,v 1.8 1991/11/11 22:59:28 hong Exp aoki $");
d205 1
a205 1
			AssertArg(false);
d352 1
a352 1
			AssertArg(false);
d391 1
a391 1
			AssertArg(false);
@


1.8
log
@for prototyping
@
text
@d15 1
a15 1
 *	$Header: RCS/parsev.c,v 1.7 91/08/18 02:08:36 caetta Exp $
d21 1
a21 1
 RcsId("$Header: RCS/parsev.c,v 1.7 91/08/18 02:08:36 caetta Exp $");
d36 1
a36 1
#include "parser/parse.h"
@


1.7
log
@aggregate token integration
@
text
@d15 1
a15 1
 *	$Header: RCS/parsev.c,v 1.6 90/08/18 14:16:29 cimarron Exp $
d21 1
a21 1
 RcsId("$Header: RCS/parsev.c,v 1.6 90/08/18 14:16:29 cimarron Exp $");
d45 1
a45 1
void
d60 1
a60 1
void
d287 1
a287 1
			NameIsEqual(CString(CAR(args)), "RELATION");	/*XXX*/
d289 1
a289 1
			NameIsEqual(CString(CAR(args)), "ATTRIBUTE");	/*XXX*/
@


1.6
log
@rearranged #includes to eliminate tcop/tcop.h and executor/executor.h
@
text
@d15 1
a15 1
 *	$Header: RCS/parsev.c,v 1.5 90/08/14 16:20:30 cimarron Exp Locker: cimarron $
d21 1
a21 1
 RcsId("$Header$");
d331 7
d365 1
@


1.5
log
@added pathnames to header includes
@
text
@d9 1
d15 1
a15 1
 *	$Header: RCS/parsev.c,v 1.4 90/03/31 19:01:31 cimarron Version_2 Locker: cimarron $
d19 1
a19 1
#include "tcop/tcop.h"
d21 1
a21 1
 RcsId("$Header: RCS/parsev.c,v 1.4 90/03/31 19:01:31 cimarron Version_2 Locker: cimarron $");
d24 8
a31 1
 *	ValidateParse
d34 1
a34 5
void
ValidateParse(parse)
	List	parse;
{
	AssertArg(consp(parse));
d36 2
a37 6
	if (!lispIntegerp(CAR(parse))) {
		ValidateParsedQuery(parse);
	} else {
		ValidateUtility(CInteger(CAR(parse)), CDR(parse));
	}
}
d39 6
d47 1
a47 1
	List	parse;
d49 1
a49 1
	AssertArg(consp(parse) && !lispIntegerp(CAR(parse)));
d51 3
a53 3
	/*
	 * XXX code here
	 */
d56 4
d390 17
@


1.4
log
@modified header files.
@
text
@d14 1
a14 1
 *	$Header$
d18 3
a20 2
#include "tcop.h"
 RcsId("$Header$");
@


1.3
log
@added validation for CREATE
@
text
@d1 5
a5 2
/*     
 * parsev.c --
d7 9
d18 2
a19 1
#include "c.h"
d21 4
a24 9
RcsId("$Header: RCS/parsev.c,v 1.2 89/10/11 15:19:32 hirohama Exp Locker: hirohama $");

#include "log.h"		/* error logging */
#include "name.h"		/* for NameIsEqual */
#include "parse.h"		/* y.tab.h, created by yacc'ing gram.y */
#include "pg_lisp.h"		/* lisp-compat package */

#include "command.h"	/* for ValidateUtility */

@


1.2
log
@added validation of ADD
@
text
@d8 1
a8 1
RcsId("$Header: RCS/parsev.c,v 1.1 89/10/09 18:36:24 hirohama Exp Locker: hirohama $");
d90 7
d98 1
a98 1
		 * XXX code here
d100 48
@


1.1
log
@Initial revision
@
text
@d8 1
a8 1
RcsId("$Header$");
a182 1
#if 0
d184 13
a196 8
#ifndef	PERFECTPARSER
		AssertArg(consp(args) && lispStringp(CAR(args)));
		AssertArg(consp(CDR(args)) && lispStringp(CADR(args)));
		AssertArg(null(CDR(CDR(args))));
#endif
		addattribute(CString(CAR(args)),
		relation_add_attribute (CAR (args),	/* relation name */
			CDR (args));
d198 1
a198 1
#endif
@