parse.c

来自「uClinux下用的数据库」· C语言 代码 · 共 1,425 行 · 第 1/2 页

	{
		(void)strncpy(new->table,table,NAME_LEN - 1);
	}
	(void)strncpy(new->name,name,NAME_LEN - 1);
	if (notNull)
	{
		new->flags |= NOT_NULL_FLAG;
	}
	if (type > 0)
	{
		switch(typeBaseType(type))
		{
			case INT8_TYPE:
			case UINT8_TYPE:
				new->type = type;
				new->dataLength = new->length = 1;
				break;

			case INT16_TYPE:
			case UINT16_TYPE:
				new->type = type;
				new->dataLength = new->length = 2;
				break;

			case INT_TYPE:
			case UINT_TYPE:
				new->type = type;
				new->dataLength = new->length = 4;
				break;

#ifdef HUGE_T	
			case INT64_TYPE:
			case UINT64_TYPE:
				new->type = type;
				new->dataLength = new->length = sizeof(HUGE_T);
				break;
#endif
	
			case CHAR_TYPE:
				new->type = CHAR_TYPE;
				new->dataLength = new->length = atoi(length);
				break;
	
			case REAL_TYPE:
				new->type = REAL_TYPE;
				new->length = sizeof(double);
				new->dataLength = new->length + 1;
				break;
	
			case TEXT_TYPE:
				new->type = TEXT_TYPE;
				new->length = atoi(length);
				new->dataLength = new->length + VC_HEAD_SIZE;
				break;

			case BYTE_TYPE:
				new->type = type;
				new->dataLength = new->length = 
					typeFieldSize(type);
				break;

			default:
				new->type = 0;
				new->dataLength = new->length = 0;
				break;
		}
	}
	else
	{
		new->type = 0;
		new->dataLength = new->length = 0;
	}
	new->overflow = NO_POS;
	if (!query->fieldHead)
	{
		query->fieldHead = query->fieldTail = new;
	}
	else
	{
		query->fieldTail->next = new;
		query->fieldTail = new;
	}
	memFreeIdent(ident);
	query->fieldCount++;
	if (query->fieldCount > MAX_FIELDS)
	{
		netError(query->clientSock, TABLE_WIDTH_ERROR, MAX_FIELDS);
		msqlDebug1(MOD_ERR,"Too many fields in table (%d Max)\n",
                        MAX_FIELDS);
		debugTrace(TRACE_OUT,"parseAddField()");
		return(-1);
	}
	debugTrace(TRACE_OUT,"parseAddField()");
	return(0);
}


int parseAddFunction(name, query)
	char		*name;
	mQuery_t	*query;
{
	mField_t	*new;

	debugTrace(TRACE_IN,"ParseAddFunction()");

	/*
	** Create the new field definition
	*/

	new = memMallocField();
	new->overflow = NO_POS;

	new->function = (mFinfo_t *)malloc(sizeof(mFinfo_t));
	bzero(new->function, sizeof(mFinfo_t));
	(void)strncpy(new->function->name,name,NAME_LEN - 1);
	new->function->sequence = query->functSeq++;
	if (!query->fieldHead)
	{
		query->fieldHead = query->fieldTail = new;
	}
	else
	{
		query->fieldTail->next = new;
		query->fieldTail = new;
	}
	query->fieldCount++;

	debugTrace(TRACE_OUT,"parseAddFunction()");
	return(0);
}


int parseAddFunctParam(param, query)
	mIdent_t	*param;
	mQuery_t	*query;
{
	mField_t	*new,
			*funct;
	char		*name,
			*table;


	debugTrace(TRACE_IN,"ParseAddFunctParam()");
	
	funct = query->fieldTail;

        if (*(param->seg2))
        {       
                name = param->seg2;
                table = param->seg1;
        }
        else
        {
                name = param->seg1;
                table = NULL;
        }
	new = memMallocField();
	if (table)
	{
		(void)strncpy(new->table,table,NAME_LEN - 1);
	}
	(void)strncpy(new->name,name,NAME_LEN - 1);
	new->overflow = NO_POS;
	if (!funct->function->paramHead)
	{
		funct->function->paramHead = 
			funct->function->paramTail = new;
	}
	else
	{
		funct->function->paramTail->next = new;
		funct->function->paramTail = new;
	}
	memFreeIdent(param);
	debugTrace(TRACE_OUT,"ParseAddFunctParam()");
	return(0);
}



int parseAddFunctLiteral(value, query)
	mVal_t		*value;
	mQuery_t	*query;
{
	mField_t	*new,
			*funct;

	debugTrace(TRACE_IN,"ParseAddFunctLiteral()");
	
	funct = query->fieldTail;

	new = memMallocField();
	if (!funct->function->paramHead)
	{
		funct->function->paramHead = funct->function->paramTail = new;
	}
	else
	{
		funct->function->paramTail->next = new;
		funct->function->paramTail = new;
	}

	new->value = value;
	new->literalParamFlag = 1;
	debugTrace(TRACE_OUT,"ParseAddFunctLiteral()");
	return(0);
}



void parseSetFunctOutputName(name, query)
	char		*name;
	mQuery_t	*query;
{
	mField_t	*funct;
	char		*cp;

	debugTrace(TRACE_IN,"ParseSetFunctOutputName()");

	/*
	** The name is a text literal from the parser so we
	** have to dodge the quotes
	*/
	funct = query->fieldTail;
	cp = name + strlen(name) - 1;
	*cp = 0;
	strncpy(funct->function->outputName, name + 1, NAME_LEN);
}



void parseSetRowLimit(value, query)
	mVal_t		*value;
	mQuery_t	*query;
{
	query->rowLimit = value->val.intVal;
}



void parseSetRowOffset(value, query)
	mVal_t		*value;
	mQuery_t	*query;
{
	query->rowOffset = value->val.intVal;
}



void parseSetTargetTable(value, query)
	char		*value;
	mQuery_t	*query;
{
	if (value)
		query->targetTable = value;
	else
		query->targetTable = NULL;
}


void parseAddFieldValue(value, query)
	mVal_t		*value;
	mQuery_t	*query;
{
	register 	mField_t *fieldVal;
	u_char		*buf;

	debugTrace(TRACE_IN,"parseAddFieldValue()");
	if (!query->lastField)
	{
		query->lastField = fieldVal = query->fieldHead;
	}
	else
	{	
		fieldVal = query->lastField->next;
		query->lastField = query->lastField->next;
	}
	if (fieldVal)
	{
		if (fieldVal->type == CHAR_TYPE && value->nullVal == 0) 
		{
			/*
			** Just in case we have a 10 char string in
			** a 10 char space (i.e. no room for the null
			** termination) remalloc this field and ensure
			** there's room for a null
			*/
			buf = (u_char *)malloc(fieldVal->length+1);
			if (value->val.charVal)
			{
				strncpy(buf,value->val.charVal,
					fieldVal->length);
				free(value->val.charVal);
			}
			else
			{
				*buf = 0;
			}
			value->val.charVal = buf;
		}
		fieldVal->value = value;
	}
	debugTrace(TRACE_OUT,"parseAddFieldValue()");
}


void parseAddInsertValue(value, query)
	mVal_t		*value;
	mQuery_t	*query;
{
	mValList_t 	*new;

	debugTrace(TRACE_IN,"parseAddInsertValue()");
	new = memMallocValList();
	new->value = value;
	new->next = NULL;
	new->offset = insertOffset++;
	if (query->insertValTail)
	{
		query->insertValTail->next = new;
	}
	else
	{
		query->insertValHead = new;
	}
	query->insertValTail = new;
	debugTrace(TRACE_OUT,"parseAddInsertValue()");
}



void parsePushCondition(query)
	mQuery_t	*query;
{
	cstk_t	*new;

	new = (cstk_t *)malloc(sizeof(cstk_t));
	new->next = condStack;
	new->head = query->condHead;
	new->tail = query->condTail;
	condStack = new;
	query->condHead = query->condTail = NULL;
}


void parsePopCondition(query)
	mQuery_t	*query;
{
	cstk_t	*tmp;

	tmp = condStack;
	condStack = condStack->next;
	query->condHead = tmp->head;
	query->condTail = tmp->tail;
	free(tmp);
}


void parseAddSubCond(bool, query)
	int		bool;
	mQuery_t	*query;
{
	mCond_t		*new = NULL;

	debugTrace(TRACE_IN,"parseAddSubCond()");

	/*
	** If there's only one cond in the sub-cond then we can
	** pull it up to the level above.  A lot of benchmark app's
	** use single entry sub-conds (as do badly written SQL queries)
	*/
	if (query->condHead->next == NULL)
	{
		new = query->condHead;
		parsePopCondition(query);
		new->next = NULL;
		new->bool = bool;
	}
	else
	{
		/*
		** Nope, it's a valid sub-cond.  Set it up
		*/
		new = memMallocCondition();
		new->op = 0;
		new->bool = bool;
		new->value = NULL;
		new->next = NULL;
		new->subCond = query->condHead;
		parsePopCondition(query);
	}

	if (!query->condHead)
	{
		query->condHead = query->condTail = new;
	}
	else
	{
		query->condTail->next = new;
		query->condTail = new;
	}
	debugTrace(TRACE_OUT,"parseAddSubCond()");
}


/****************************************************************************
**      _msqlAddBetween
**
**      Purpose :
**      Args    :
**      Returns : Nothing
**      Notes   : the BOOL field is only provided if this is not the first
**                element of a where_clause.
*/      

void parseAddBetween(ident,minVal,maxVal,bool,query)
        mIdent_t 	*ident;
        mVal_t   	*minVal,
                	*maxVal;
        int     	bool;
	mQuery_t	*query;
{
        register 	mCond_t *new;   
        char    	*name,
                	*table;

        debugTrace(TRACE_IN,"parseAddBetween()");

        if (*(ident->seg2))
        {       
                name = ident->seg2;
                table = ident->seg1;
        }
        else
        {
                name = ident->seg1;
                table = NULL;
        }

        new = memMallocCondition();
        (void)strcpy(new->name,name);
        if (table)
        {
                (void)strcpy(new->table,table);
        }

        new->op = BETWEEN_OP;
        new->bool = bool;
        new->value = minVal;
        new->maxValue = maxVal;
        new->subCond = NULL;
        new->next = NULL;

        if (!query->condHead)
        {
                query->condHead = query->condTail = new;
        }
        else
        {
                query->condTail->next = new;
                query->condTail = new;
        }
        memFreeIdent(ident);
        debugTrace(TRACE_OUT,"parseAddBetween()");
}


/****************************************************************************
** 	_msqlAddCond  -  add a conditional spec to the list
**
**	Purpose	: Store part of a "where_clause" for later use
**	Args	: field name, test op, value, bool (ie. AND | OR)
**	Returns	: Nothing
**	Notes	: the BOOL field is only provided if this is not the first
**		  element of a where_clause.
*/

int parseAddCondition(ident,op,value,bool,query)
	mIdent_t	*ident;
	int		op;
	mVal_t		*value;
	int		bool;
	mQuery_t	*query;
{
	mCond_t		*new;
	char		*name,
			*table;

	debugTrace(TRACE_IN,"parseAddCondition()");
	if (value == NULL)
		abort();

	query->numConds++;
	if (query->numConds > MAX_FIELDS)
	{
		memFreeIdent(ident);
		netError(query->clientSock, "Too many conditions in query");
		debugTrace(TRACE_OUT,"parseAddCondition()");
		return(-1);
	}

	if (*(ident->seg2))
	{
		name = ident->seg2;
		table = ident->seg1;
	}
	else
	{
		name = ident->seg1;
		table = NULL;
	}

	new = memMallocCondition();
	(void)strcpy(new->name,name);
	if (table)
	{
		(void)strcpy(new->table,table);
	}
	
	new->op = op;
	new->bool = bool;
	new->value = value;
	new->subCond = NULL;
	new->next = NULL;

	if (!query->condHead)
	{
		query->condHead = query->condTail = new;
	}
	else
	{
		query->condTail->next = new;
		query->condTail = new;
	}
	memFreeIdent(ident);
	debugTrace(TRACE_OUT,"parseAddCond()");
	return(0);
}



/****************************************************************************
** 	_msqlAddOrder  -  add an order definition to the list
**
**	Purpose	: Store part of an "order_clause"
**	Args	: field name, order direction (ie. ASC or DESC)
**	Returns	: Nothing
**	Notes	: 
*/

void parseAddOrder(ident,dir, query)
	mIdent_t	*ident;
	int		dir;
	mQuery_t	*query;
{
	register 	mOrder_t *new;

	debugTrace(TRACE_IN,"parseAddOrder()");

	new = memMallocOrder();
	new->dir = dir;
	if (*ident->seg1)
	{
		(void)strcpy(new->table,ident->seg1);
	}
	(void)strcpy(new->name,ident->seg2);
	if (!query->orderHead)
	{
		query->orderHead = query->orderTail = new;
	}
	else
	{
		query->orderTail->next = new;
		query->orderTail = new;
	}
	memFreeIdent(ident);
	debugTrace(TRACE_OUT,"parseAddOrder()");
}




int parseAddTable(name,alias,query)
	char	*name,
		*alias;
	mQuery_t *query;
{
	register mTable_t	*new;
	char			*badName = NULL;

	debugTrace(TRACE_IN,"parseAddTable()");

	if (strlen(name) > NAME_LEN)
		badName = name;
	if (alias && strlen(alias) > NAME_LEN)
		badName = alias;

	if (badName)
	{	
		netError(query->clientSock,
			"Identifier name '%s' too long\n",badName);
		debugTrace(TRACE_OUT,"parseAddTable()");
		return(-1);
	}
	new = memMallocTable();

	if (alias)
	{
		(void)strcpy(new->name,alias);
		(void)strcpy(new->cname,name);
	}
	else
	{
		(void)strcpy(new->name,name);
		*(new->cname) = 0;
	}
	if (!query->tableHead)
	{
		query->tableHead = query->tableTail = new;
	}
	else
	{
		query->tableTail->next = new;
		query->tableTail = new;
	}
	debugTrace(TRACE_OUT,"parseAddTable()");
	return(0);
}



int parseAddIndex(name, table, uniq, type, query)
	char	*name,
		*table;
	int	uniq,
		type;
	mQuery_t *query;
{
	char	*badName = NULL;

	debugTrace(TRACE_IN,"parseAddIndex()");
	if ((int)strlen(name) > NAME_LEN)
		badName = name;
	if ((int)strlen(table) > NAME_LEN)
		badName = table;

	if (badName)
	{	
		netError(query->clientSock,
			"Identifier name '%s' too long\n",badName);
		debugTrace(TRACE_OUT,"parseAddIndex()");
		return(-1);
	}
	strncpy(query->indexDef.name,name,NAME_LEN);
	strncpy(query->indexDef.table,table,NAME_LEN);
	query->indexDef.unique = uniq;
	query->indexDef.idxType = type;
	debugTrace(TRACE_OUT,"parseAddIndex()");
	return(0);
}


void parseSetInsertOffset(value)
	int	value;
{
	insertOffset = value;
}




#ifdef NOT_DEF
static void parseQueryOverrunError(txt, query)
	char		*txt;
	mQuery_t	*query;
{

	debugTrace(TRACE_IN,"parseQueryOverrunError()");
	netError(query->clientSock,
		"Syntax error.  Bad text after query. '%s'\n",txt);
	debugTrace(TRACE_OUT,"parseQueryOverrunError()");
}
#endif


mQuery_t *parseQuery(server, inBuf, sock, user, db)
	msqld		*server;
	char		*inBuf;
	int		sock;
	char		*user,
			*db;
{
	mQuery_t	*query;
	extern mQuery_t *curQuery; /* from lexer.c */

	debugTrace(TRACE_IN,"parseQuery()");
	query = memMallocQuery();
	query->clientSock = sock;
	query->curUser = user;
	query->curDB = db;
	yyInitScanner(inBuf);
	curQuery = query;
	curQuery->queryText = inBuf;
	if (yyparse() != 0)
	{
		debugTrace(TRACE_OUT,"parseQuery()");
		return(NULL);
	}
	debugTrace(TRACE_OUT,"parseQuery()");
	return(query);
}