util.c

uClinux下用的数据库

		curField->offset = curOffset;
		curField->fieldID = count;
		curField->overflow = NO_POS;
		*curFL = curOffset;
		if (!curField->value)
			break;
		if (!curField->value->nullVal)
		{
			if (curField->length < curField->value->dataLen &&
			    curField->type == CHAR_TYPE)
			{
				snprintf(errMsg, MAX_ERR_MSG,
					VALUE_SIZE_ERROR, curField->name);
				msqlDebug1(MOD_ERR, VALUE_SIZE_ERROR,
					curField->name);
				return(-1);
			}
			res = typeValidConditionTarget(curField->type,
				curField->value);
			if (res == -1)
			{
				snprintf(errMsg, MAX_ERR_MSG, TYPE_ERROR,
					curField->name);
				msqlDebug1(MOD_ERR, TYPE_ERROR, curField->name);
				return(-1);
			}
			if (res == -2)
			{
				/* Error msg already set */
				return(-1);
			}
		}
		break;
	    }
	    if(!fieldDef)  /* Bad entry */
	    {
		if (curField->table)
		{
		    snprintf(errMsg,MAX_ERR_MSG, BAD_FIELD_ERROR, 
			curField->table, curField->name);
		    msqlDebug2(MOD_ERR,"Unknown field \"%s.%s\"\n",
				curField->table,curField->name);
		    debugTrace(TRACE_OUT,"utilSetupFields()");
		    return(-1);
		}
		else
		{
		    snprintf(errMsg,MAX_ERR_MSG, BAD_FIELD_2_ERROR,
			curField->name);
		    msqlDebug1(MOD_ERR,"Unknown field \"%s\"\n",curField->name);
		    debugTrace(TRACE_OUT,"utilSetupFields()");
		    return(-1);
		}
	    }
	    curFL++;
	    curField = curField->next;
	}
	debugTrace(TRACE_OUT,"utilSetupFields()");
	return(0);
}




int utilSetCondValueType(curCond, value)
	mCond_t	*curCond;
	mVal_t	*value;
{
	int	res;

	if (value->nullVal)
	{
		return(0);
	}
	if (value->type == IDENT_TYPE)
	{
		return(0);
	}

	/*
	** Setup the cond value.  Scan to internal form if needed
	*/
	res = typeValidConditionTarget(curCond->type, value);
	if (res == -1)
	{
		snprintf(errMsg,MAX_ERR_MSG,BAD_TYPE_ERROR, curCond->name);
		msqlDebug1(MOD_ERR,"Bad type for comparison of '%s'",
                                curCond->name);
		return(-1);
	}
	if (res == -2)
	{
		/* Error msg already set */
		return(-1);
	}
	return(0);
}



/****************************************************************************
** 	_utilSetupConds
**
**	Purpose	: Determine the byte offset into a row for conditional
**		  data.
**	Args	: Condition list (field location) array,
**		  List of fileds used in conditionals
**	Returns	: -1 on error
**	Notes	: As per utilSetupFields.
*/

int utilSetupConds(cacheEntry,conds)
	cache_t	*cacheEntry;
	mCond_t	*conds;
{
	mCond_t		*curCond;
	mField_t	*fieldDef;
	int		numConds,
			*curFL,
			curOffset,
			fieldID,
			res;

	debugTrace(TRACE_IN,"utilSetupConds()");
	numConds = 0;
	curCond = conds;
	curFL = NULL;
	if (conds)
	{
		if (conds->clist)
		{
			curFL = conds->clist;
		}
	}
	while(curCond)
	{
		if (curCond->subCond)
		{
			curCond = curCond->next;
			continue;
		}
		numConds++;
		if (numConds < MAX_FIELDS)
			*curFL++ = -1;
		curCond=curCond->next;
	}
	if (numConds > MAX_FIELDS)
	{
		snprintf(errMsg,MAX_ERR_MSG,COND_COUNT_ERROR);
		msqlDebug0(MOD_ERR,"Too many fields in condition\n");
		debugTrace(TRACE_OUT,"utilSetupConds()");
		return(-1);
	}
	if (curFL)
		*curFL = -1;
	
	curCond = conds;
	curFL = conds->clist;
	while(curCond)
	{
		if (curCond->subCond)
		{
			if (utilSetupConds(cacheEntry, curCond->subCond)<0)
			{
				return(-1);	
			}
			curCond = curCond->next;
			continue;
		}
            	if (*curCond->name == '_')
            	{
			if ((res = sysvarCheckCondition(curCond)) < 0)
			{
				if (res == -2)
					return(-1);
                        	snprintf(errMsg, MAX_ERR_MSG, SYSVAR_ERROR, 
					curCond->name);
                        	msqlDebug1(MOD_ERR,SYSVAR_ERROR, curCond->name);
				return(-1);
			}
			curCond->sysvar = 1;
			curCond->fieldID = -2;
			curCond = curCond->next;
			continue;
		}
		curCond->sysvar = 0;
		fieldDef = cacheEntry->def;
		curOffset = 0;
		fieldID = 0;
		while(fieldDef)
		{
			if( *(curCond->name) != *(fieldDef->name) ||
			    *(curCond->table) != *(fieldDef->table))
			{
				/* +1 for null flag */
				curOffset += fieldDef->dataLength+1; 
				fieldDef = fieldDef->next;
				fieldID ++;
				continue;
			}
			
			if(strcmp(curCond->name,fieldDef->name) != 0 ||
			   strcmp(curCond->table,fieldDef->table) != 0)
			{
				/* +1 for null flag */
				curOffset += fieldDef->dataLength+1; 
				fieldDef = fieldDef->next;
				fieldID ++;
				continue;
			}

			curCond->type = fieldDef->type;
			curCond->length = fieldDef->length;
			curCond->fieldID = fieldID;
		
			if (utilSetCondValueType(curCond, curCond->value) < 0)
				return(-1);
			if (curCond->op == BETWEEN_OP)
			{
				if (utilSetCondValueType(curCond, 
					curCond->maxValue) < 0)
				{
					return(-1);
				}
			}
			*curFL = curOffset;
			break;
		}
		if (!fieldDef)
		{
			snprintf(errMsg, MAX_ERR_MSG, BAD_FIELD_2_ERROR, 
				curCond->name);
			msqlDebug1(MOD_ERR,
				"Unknown field in where clause \"%s\"\n",
				curCond->name);
			debugTrace(TRACE_OUT,"utilSetupConds()");
			return(-1);
		}
		curFL++;
		curCond->fieldID = fieldID;
		curCond->type = fieldDef->type;
		curCond = curCond->next;
	}
	debugTrace(TRACE_OUT,"utilSetupConds()");
	return(0);
}



/****************************************************************************
** 	_utilSetupOrder
**
**	Purpose	: Determine the byte offset into a row for order
**		  data.
**	Args	: Order list (field location) array,
**		  List of fileds used in order
**	Returns	: -1 on error
**	Notes	: As per utilSetupFields.
*/

int utilSetupOrder(cacheEntry,olist, order)
	cache_t	*cacheEntry;
	int	*olist;
	mOrder_t	*order;
{
	mOrder_t	*curOrder;
	mField_t	*fieldDef;
	int		numOrder,
			*curFL,
			curOffset;

	debugTrace(TRACE_IN,"utilSetupOrder()");
	numOrder = 0;
	curOrder = order;
	curFL = olist;
	while(curOrder)
	{
		numOrder++;
		if (numOrder < MAX_FIELDS)
			*curFL++ = -1;
		curOrder=curOrder->next;
	}
	if (numOrder > MAX_FIELDS)
	{
		snprintf(errMsg,MAX_ERR_MSG,ORDER_COUNT_ERROR);
		msqlDebug0(MOD_ERR,"Too many fields in order specification\n");
		debugTrace(TRACE_OUT,"utilSetupOrder()");
		return(-1);
	}
	*curFL = -1;
	
	curOrder = order;
	curFL = olist;
	while(curOrder)
	{
		fieldDef = cacheEntry->def;
		curOffset = 0;
		while(fieldDef)
		{
			if( *(curOrder->name) != *(fieldDef->name) ||
			    *(curOrder->table) != *(fieldDef->table))
			{
				/* +1 for null flag */
				curOffset += fieldDef->dataLength+1; 
				fieldDef = fieldDef->next;
				continue;
			}
		
			if(strcmp(curOrder->name,fieldDef->name) != 0 ||
			   strcmp(curOrder->table,fieldDef->table) != 0)
			{
				/* +1 for null flag */
				curOffset += fieldDef->dataLength+1; 
				fieldDef = fieldDef->next;
				continue;
			}

			curOrder->type = fieldDef->type;
			curOrder->length = fieldDef->length;
			curOrder->entry = fieldDef->entry;
			*curFL = curOffset;
			break;
		}
		if (!fieldDef)
		{
			snprintf(errMsg, MAX_ERR_MSG,
				cacheEntry->result==0?
				BAD_FIELD_2_ERROR:BAD_ORD_FIELD_2_ERROR,
				curOrder->name);
			msqlDebug1(MOD_ERR,
				"Unknown field in order clause \"%s\"\n",
				curOrder->name);
			debugTrace(TRACE_OUT,"utilSetupOrder()");
			return(-1);
		}
		curFL++;
		curOrder = curOrder->next;
	}
	debugTrace(TRACE_OUT,"utilSetupOrder()");
	return(0);
}






/****************************************************************************
** 	_dupFieldList
**
**	Purpose	: 
**	Args	: 
**	Returns	: 
**	Notes	: 
*/

mField_t *utilDupFieldList(cacheEntry)
	cache_t	*cacheEntry;
{
	mField_t	*fieldDef,
		*prevField,
		*newField,
		*head;


	/*
	** Scan the field list
	*/

	debugTrace(TRACE_IN,"dupFieldList()");
	prevField = head = NULL;
	fieldDef = cacheEntry->def;
	while(fieldDef)
	{
		newField = memMallocField();
		strcpy(newField->name,fieldDef->name);
		strcpy(newField->table,fieldDef->table);
		if (fieldDef->function)
		{
			newField->function = (mFinfo_t*)malloc(
				sizeof(mFinfo_t));
			bcopy(fieldDef->function,newField->function,
				sizeof(mFinfo_t));
		}
		newField->value = NULL;
		newField->type = fieldDef->type;
		newField->sysvar = fieldDef->sysvar;
		newField->length = fieldDef->length;
		newField->dataLength = fieldDef->dataLength;
		newField->offset = fieldDef->offset;
		newField->null = fieldDef->null;
		newField->flags = fieldDef->flags;
		newField->fieldID = fieldDef->fieldID;
		newField->overflow = NO_POS;
		newField->entry = fieldDef->entry;
		newField->function = fieldDef->function;
		newField->functResultFlag = 0;
		newField->next = NULL;
		if (!prevField)
		{
			head = newField;
		}
		else
			prevField->next = newField;
		prevField = newField;
		fieldDef = fieldDef->next;
	}
	debugTrace(TRACE_OUT,"dupFieldList()");
	return(head);
}



/****************************************************************************
** 	_expandWildCards
**
**	Purpose	: Handle "*" in a select clause
**	Args	: 
**	Returns	: 
**	Notes	: This just drops the entire table into the field list
**		  when it finds a "*"
*/

mField_t *utilExpandFieldWildCards(cacheEntry,fields)
	cache_t	*cacheEntry;
	mField_t	*fields;
{
	mField_t	*curField,
			*fieldDef,
			*prevField,
			*newField,
			*tmpField,
			*head;


	/*
	** Scan the field list
	*/

	debugTrace(TRACE_IN,"expandWildcard()");
	head = curField = fields;
	prevField = NULL;
	while(curField)
	{
		if (strcmp(curField->name,"*") == 0)
		{
			/*
			** Setup a new entry for each field
			*/
			fieldDef = cacheEntry->def;
			while(fieldDef)
			{
				newField = memMallocField();
				strcpy(newField->name,fieldDef->name);
				strcpy(newField->table,fieldDef->table);
				if (fieldDef->function)
				{
					newField->function = (mFinfo_t*)malloc(
						sizeof(mFinfo_t));
					bcopy(fieldDef->function,
						newField->function,
						sizeof(mFinfo_t));
				}
				else
				{
					newField->function = NULL;
				}
				newField->value = NULL;
				newField->type = fieldDef->type;
				newField->sysvar = fieldDef->sysvar;
				newField->length = fieldDef->length;
				newField->dataLength = fieldDef->dataLength;
				newField->offset = fieldDef->offset;
				newField->null = fieldDef->null;
				newField->flags = fieldDef->flags;
				newField->fieldID = fieldDef->fieldID;
				newField->entry = fieldDef->entry;
				newField->overflow = NO_POS;
				newField->literalParamFlag = 0;
				newField->functResultFlag = 0;
				if (!prevField)
				{
					head = newField;
				}
				else
					prevField->next = newField;
				newField->next = curField->next;
				prevField = newField;
				fieldDef = fieldDef->next;
			}

			/*
			** Blow away the wildcard entry
			*/
			if (curField->type == CHAR_TYPE || 
			    curField->type == TEXT_TYPE)
			{
				if(curField->value->val.charVal)
				{
					free(curField->value->val.charVal);
					curField->value->val.charVal = NULL;
				}
			}
			tmpField = curField;
			curField = curField->next;
			if(tmpField)
				memFreeField(tmpField);
		}
		else
		{
			prevField = curField;
			curField = curField->next;
		}
	}
	debugTrace(TRACE_OUT,"expandWildcard()");
	return(head);
}



void utilExpandTableFields(server,table, query)
	msqld		*server;
	char    	*table;
	mQuery_t	*query;
{
	cache_t 	*cacheEntry;
	char		tableName[NAME_LEN];

	debugTrace(TRACE_IN,"expandTableFields()");
	strcpy(tableName,table);
	if((cacheEntry=tableLoadDefinition(server,tableName,NULL,query->curDB)))
	{
		query->fieldHead = utilExpandFieldWildCards(cacheEntry,
			query->fieldHead);
	}
	debugTrace(TRACE_OUT,"expandTableFields()");
}





int utilCheckDB(server, db)
	msqld	*server;
	char	*db;
{
	char	path[MSQL_PATH_LEN];
	struct	stat buf;

	debugTrace(TRACE_IN,"msqlInit()");
	(void)snprintf(path, MSQL_PATH_LEN, "%s/%s",server->config.dbDir,db);
	if (stat(path,&buf) < 0)
	{
		snprintf(errMsg, MAX_ERR_MSG, BAD_DB_ERROR,db);
		msqlDebug1(MOD_ERR,"Unknown database \"%s\"\n",db);
		debugTrace(TRACE_OUT,"msqlInit()");
		return(-1);
	}
	debugTrace(TRACE_OUT,"msqlInit()");
	return(0);
}





void utilFormatPacket(packet,fields)
        char    *packet;
        mField_t *fields;
{
        _formatData(packet,fields,0);
}

void utilFormatExport(packet,fields)
        char    *packet;
        mField_t *fields;
{
        _formatData(packet,fields,1);
}





row_t *utilDupRow(entry,row, new)
	cache_t	*entry;
	row_t 	*row,
		*new;
{
	if (!new)
	{
		new = (row_t *)malloc(sizeof(row_t));
		new->buf = (u_char *)malloc(entry->rowLen+2 + HEADER_SIZE);
	}
	bcopy(row->buf,new->buf,entry->rowLen + HEADER_SIZE);
	new->header = (hdr_t *)new->buf;
	new->data = new->buf + HEADER_SIZE;
	return(new);
}


void utilFreeRow(row)
	row_t	*row;
{
	if(row->buf)
	{
		free(row->buf);
		row->buf = NULL;
	}
	if(row)
		free(row);
}