util.c

uClinux下用的数据库

/*
** Copyright (c) 1995-2001  Hughes Technologies Pty Ltd.  All rights
** reserved.  
**
** Terms under which this software may be used or copied are
** provided in the  specific license associated with this product.
**
** Hughes Technologies disclaims all warranties with regard to this 
** software, including all implied warranties of merchantability and 
** fitness, in no event shall Hughes Technologies be liable for any 
** special, indirect or consequential damages or any damages whatsoever 
** resulting from loss of use, data or profits, whether in an action of 
** contract, negligence or other tortious action, arising out of or in 
** connection with the use or performance of this software.
**
**
** $Id: util.c,v 1.19 2002/12/05 04:23:26 bambi Exp $
**
*/

/*
** Module	: main : util
** Purpose	: 
** Exports	: 
** Depends Upon	: 
*/



/**************************************************************************
** STANDARD INCLUDES
**************************************************************************/

#include <common/config.h>

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#ifdef HAVE_UNISTD_H
#  include <unistd.h>
#endif
#ifdef HAVE_STRING_H
#  include <string.h>
#endif
#ifdef HAVE_STRINGS_H
#  include <strings.h>
#endif


/**************************************************************************
** MODULE SPECIFIC INCLUDES
**************************************************************************/

#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>

#ifdef HAVE_DIRENT_H
#    include <dirent.h>   
#endif

#ifdef HAVE_SYS_DIR_H
#  include <sys/dir.h>
#endif

#include <common/msql_defs.h>
#include <common/debug/debug.h>
#include <msqld/index/index.h>
#include <msqld/includes/errmsg.h>
#include <msqld/includes/msqld.h>
#include <msqld/main/main.h>
#include <msqld/main/yaccer.h>
#include <msqld/main/version.h>
#include <msqld/main/table.h>
#include <msqld/main/util.h>
#include <msqld/main/sysvar.h>
#include <msqld/main/memory.h>
#include <msqld/cra/cra.h>
#include <common/types/types.h>
#include <libmsql/msql.h>


/**************************************************************************
** GLOBAL VARIABLES
**************************************************************************/

char	errMsg[MAX_ERR_MSG];


/**************************************************************************
** PRIVATE ROUTINES
**************************************************************************/


static char *escapeExport(buf)
        char    *buf;
{
        char    *cp1,
                *cp2;
        static  char newBuf[1024];

        cp1 = buf;
        cp2 = newBuf;
        while(*cp1)
        {
                if (*cp1 == '\\' || *cp1 == ',')
                {
                        *cp2 = '\\';
                        cp2++;
                }
                *cp2 = *cp1;
                cp1++;
                cp2++;
        }
        *cp2 = 0;
        return(newBuf);
}


static void _formatData(packet,fields, export)
        char    *packet;
        mField_t *fields;
        int     export;
{
        char    outBuf[100],
                realFmt[10],
                *cp;
        u_char  *outData = NULL;
        mField_t *curField;
	u_char	int8Val;
	u_short	int16Val;

        debugTrace(TRACE_IN,"formatPacket()");
        *packet = 0;
        cp = packet;
        curField = fields;
        while(curField)
        {
                if (!curField->value->nullVal)
                {
                        switch(curField->type)
                        {
                                case INT_TYPE:
                                case INT8_TYPE:
                                case INT16_TYPE:
                                        snprintf(outBuf,sizeof(outBuf),"%d",
                                            curField->value->val.intVal);
                                        outData = (u_char *)outBuf;
                                        break;
                                case UINT_TYPE:
                                        snprintf(outBuf,sizeof(outBuf),"%u",
                                            curField->value->val.intVal);
                                        outData = (u_char *)outBuf;
                                        break;
                                case UINT8_TYPE:
					int8Val = curField->value->val.intVal;
                                        snprintf(outBuf,sizeof(outBuf),"%u",
                                            (u_int)int8Val);
                                        outData = (u_char *)outBuf;
                                        break;
                                case UINT16_TYPE:
					int16Val = curField->value->val.intVal;
                                        snprintf(outBuf,sizeof(outBuf),"%u",
                                            (u_int)int16Val);
                                        outData = (u_char *)outBuf;
                                        break;
#ifdef HUGE_T
                                case INT64_TYPE:
                                        snprintf(outBuf,sizeof(outBuf),"%qd",
                                            curField->value->val.int64Val);
                                        outData = (u_char *)outBuf;
                                        break;
                                case UINT64_TYPE:
                                        snprintf(outBuf,sizeof(outBuf),"%qu",
                                            curField->value->val.int64Val);
                                        outData = (u_char *)outBuf;
                                        break;
#endif
                                case IPV4_TYPE:
                                        typePrintIPv4(outBuf,sizeof(outBuf),
                                                curField->value->val.intVal);
                                        outData = (u_char *)outBuf;
                                        break;
                                case DATE_TYPE:
                                        typePrintDate(outBuf,sizeof(outBuf),
                                                curField->value->val.intVal);
                                        outData = (u_char *)outBuf;
                                        break;
                                case TIME_TYPE:
                                        typePrintTime(outBuf,sizeof(outBuf),
                                                curField->value->val.intVal);
                                        outData = (u_char *)outBuf;
                                        break;
                                case MONEY_TYPE:
                                        typePrintMoney(outBuf,sizeof(outBuf),
                                                curField->value->val.intVal);
                                        outData = (u_char *)outBuf;
                                        break;
                                case CIDR4_TYPE:
                                        typePrintCIDR4(outBuf,sizeof(outBuf),
                                                curField->value->val.byteVal);
                                        outData = (u_char *)outBuf;
                                        break;
                                case CHAR_TYPE:
                                case TEXT_TYPE:
                                        outData = curField->value->val.charVal;
                                        break;
                                case REAL_TYPE:
                                        snprintf(realFmt,sizeof(realFmt),
                                                "%%.%df",
                                                curField->value->precision);
                                        snprintf(outBuf,sizeof(outBuf),
                                                realFmt,
                                                curField->value->val.realVal);
                                        outData = (u_char *)outBuf;
                                        break;
				default:
					fprintf(stderr,"Unknown data type %d\n",
						curField->type);
                        }

                        if (export == 0)
                        {
                                /* inline sprintf dodge */
                                register int loop = 100000,
                                                start=0,
						vlen =strlen(outData),
						v;
				v = vlen;
                                while(loop) {
                                        if (v / loop > 0 || start) {
                                                *cp++=(v / loop) + '0';
                                                v = v % loop;
                                                start=1;
                                        }
                                        loop /= 10;
                                }
                                *cp++ = ':';
                                *cp = 0;
                                strcat(cp, (char *)outData);
                               /* cp = cp + strlen(cp); */
                                cp = cp + vlen;
                        }
                        else
                        {
                                if (curField != fields)
                                        strcat(packet,",");
                                outData = escapeExport(outData);
                                strcat(packet,(char *)outData);
                        }
                }
                else
                {
                        strcat(cp,"-2:");
                        cp += 3;
                }
                curField = curField->next;
        }
        strcat(packet,"\n");
        debugTrace(TRACE_OUT,"formatPacket()");
}



/**************************************************************************
** PUBLIC ROUTINES
**************************************************************************/



void utilQualifyFields(query)
	mQuery_t	*query;
{
	mField_t	*curField,
			*oldField;

	debugTrace(TRACE_IN,"utilQualifyFields()");
	curField = query->fieldHead;
	while(curField)
	{
		if (curField->function)
		{
			oldField = curField;
			curField = curField->function->paramHead;
			while(curField)
			{
				if (*(curField->table) == 0)
				{
					strcpy(curField->table,
						query->tableHead->name);
				}
				curField=curField->next;
			}
			curField = oldField->next;
			continue;
		}
		if (*(curField->table) == 0)
		{
			(void)strcpy(curField->table,query->tableHead->name);
		}
		curField=curField->next;
	}
	debugTrace(TRACE_OUT,"utilQualifyFields()");
}


void utilQualifyConds(query)
	mQuery_t	*query;
{
	mCond_t		*curCond;
	mQuery_t	tmpQuery;

	debugTrace(TRACE_IN,"utilQualifyConds()");
	curCond = query->condHead;
	while(curCond)
	{
		if (curCond->subCond)
		{
			bzero(&tmpQuery, sizeof(tmpQuery));
			tmpQuery.tableHead = query->tableHead;
			tmpQuery.condHead = curCond->subCond;
			utilQualifyConds(&tmpQuery);
			curCond = curCond->next;
			continue;
		}
		if(*(curCond->table) == 0)
		{
			(void)strcpy(curCond->table,query->tableHead->name);
		}
		curCond=curCond->next;
	}
	debugTrace(TRACE_OUT,"utilQualifyConds()");
}



void utilQualifyOrder(query)
	mQuery_t	*query;
{
	mOrder_t	*curOrder;

	debugTrace(TRACE_IN,"utilQualifyOrder()");
	curOrder = query->orderHead;
	while(curOrder)
	{
		if(*(curOrder->table) == 0)
		{
			(void)strcpy(curOrder->table,query->tableHead->name);
		}
		curOrder=curOrder->next;
	}
	debugTrace(TRACE_OUT,"utilQualifyOrder()");
}




int utilSetFieldInfo(cacheEntry, fields)
	cache_t		*cacheEntry;
	mField_t	*fields;
{
	mField_t	*curField,
			*fieldDef,
			*curParam;
	int		curOffset,
			count,
			res;

	debugTrace(TRACE_IN,"utilSetFieldsInfo()");
	curField = fields;
	curOffset = count = 0;
	while(curField)
	{
	    if (curField->literalParamFlag)
	    {
		curField = curField->next;
		continue;
	    }
	    if (curField->function)
	    {
		if (cacheEntry->result == 1)
		{
			curField = curField->next;	
			continue;
		}
		if(utilSetFieldInfo(cacheEntry,curField->function->paramHead)<0)
		{
			debugTrace(TRACE_OUT,"utilSetFieldInfo()");
			return(-1);
		}

		if (curField->type != CHAR_TYPE)
		{
			curField->dataLength = typeFieldSize(curField->type);
		}
		else
		{
			curParam = curField->function->paramHead;
			while(curParam)
			{
				if (curParam->length > curField->dataLength)
					curField->dataLength=curParam->length;
				curParam = curParam->next;
			}
			curField->dataLength *= 2;
		}
		curField->length = curField->dataLength;
		curField->offset = curOffset;
		curField->fieldID = count;
		curField->overflow = NO_POS;
		curField->functResultFlag = 1;
		curOffset+=curField->dataLength+1;
		curField = curField->next;	
		continue;
	    }
	    if (*curField->name == '_' && ! cacheEntry->result)
	    {
		if ((res = sysvarCheckVariable(cacheEntry,curField)) < 0)
		{
			if (res == -2)
				return(-1);
		
			snprintf(errMsg, MAX_ERR_MSG, SYSVAR_ERROR, 
				curField->name);
			msqlDebug1(MOD_ERR,SYSVAR_ERROR, curField->name);
			return(-1);
		}
	    	curField->sysvar = 1;
		curField = curField->next;
		continue;
	    }
	    curField->sysvar = 0;
	    fieldDef = cacheEntry->def;
	    while(fieldDef)
	    {
		if( *(curField->name) != *(fieldDef->name) ||
		    (curField->function == NULL && 
			*(curField->table) != *(fieldDef->table)))
		{
			curOffset+=fieldDef->dataLength+1;/* +1 for null flag */
			fieldDef = fieldDef->next;
			count++;
			continue;
		}
		if(strcmp(curField->name,fieldDef->name) != 0 ||
		    (curField->function == NULL && 
		   	strcmp(curField->table,fieldDef->table) != 0))
		{
			curOffset+=fieldDef->dataLength+1;/* +1 for null flag */
			fieldDef = fieldDef->next;
			count++;
			continue;
		}

		curField->type = fieldDef->type;
		curField->length = fieldDef->length;
		curField->dataLength = fieldDef->dataLength;
		curField->flags = fieldDef->flags;
		curField->entry = fieldDef->entry;
		curField->offset = curOffset;
		curField->fieldID = count;
		curField->overflow = NO_POS;
		curOffset+=curField->dataLength+1;
		break;
	    }
	    curField = curField->next;
	}
	debugTrace(TRACE_OUT,"utilSetFieldInfo()");
	return(0);
}





int utilSetupFields(cacheEntry,flist, fields)
	cache_t		*cacheEntry;
	int		*flist;
	mField_t	*fields;
{
	mField_t	*curField,
			*fieldDef;
	int		numFields,
			*curFL,
			curOffset,
			count,
			res;

	debugTrace(TRACE_IN,"utilSetupFields()");
	numFields = 0;
	curField = fields;
	curFL = flist;
	while(curField)
	{
		numFields++;
		if (numFields < MAX_FIELDS)
			*curFL++ = -1;
		curField=curField->next;
	}
	if (numFields > MAX_FIELDS)
	{
		snprintf(errMsg,MAX_ERR_MSG,FIELD_COUNT_ERROR);
		msqlDebug0(MOD_ERR,"Too many fileds in query\n");
		debugTrace(TRACE_OUT,"utilSetupFields()");
		return(-1);
	}
	*curFL = -1;


	/*
	** If this is a result table then the field list will already
	** have the specific offsets we need (including the offsets of
	** unusual fields like function results etc).  Just scan the
	** field list and use those values
	**
	** NOTE: This code breaks the creation of tmp tables as the
	** offsets are incorrect (i.e. they can reflect the original
	** offset from the original table not the result offset of the
	** tmp table
	**
	if (cacheEntry->result)
	{
		curField = fields;
		curFL = flist;
		while(curField)
		{
			*curFL = curField->offset;
			curFL++;
			curField = curField->next;
		}
		return(0);
	}
	*/
	

	/*
	** OK, this is not a simple result table so we have to do all
	** to hard work
	*/

	curField = fields;
	curFL = flist;
	while(curField)
	{
	    curOffset = count = 0;
	    if (curField->literalParamFlag)
	    {
		curField = curField->next;
		continue;
	    }

	    if (curField->functResultFlag || curField->function)
	    {
		/*
		** Don't mess with the parameter offset setting if we
		** are being called for a result table.  We only set
		** parameter offsets for source tables!
		*/
		if (! cacheEntry->result)
		{
			utilSetupFields(cacheEntry,curField->function->flist, 
				curField->function->paramHead);
		}
		*curFL++ = curOffset;
		curOffset+=curField->dataLength+1;
		curField = curField->next;	
		continue;
	    }

	    if (*curField->name == '_' && ! cacheEntry->result)
	    {
		if ((res = sysvarCheckVariable(cacheEntry,curField)) < 0)
		{
			if (res == -2)
				return(-1);
		
			snprintf(errMsg, MAX_ERR_MSG, SYSVAR_ERROR, 
				curField->name);
			msqlDebug1(MOD_ERR,SYSVAR_ERROR, curField->name);
			return(-1);
		}
	    	curField->sysvar = 1;
		curField = curField->next;
		continue;
	    }
	    curField->sysvar = 0;
	    fieldDef = cacheEntry->def;
	    while(fieldDef)
	    {
		if( *(curField->name) != *(fieldDef->name) ||
		    (curField->function == NULL && 
			*(curField->table) != *(fieldDef->table)))
		{
			curOffset+=fieldDef->dataLength+1;/* +1 for null flag */
			fieldDef = fieldDef->next;
			count++;
			continue;
		}
		if(strcmp(curField->name,fieldDef->name) != 0 ||
		    (curField->function == NULL && 
		   	strcmp(curField->table,fieldDef->table) != 0))
		{
			curOffset+=fieldDef->dataLength+1;/* +1 for null flag */
			fieldDef = fieldDef->next;
			count++;
			continue;
		}

		curField->type = fieldDef->type;
		curField->length = fieldDef->length;
		curField->dataLength = fieldDef->dataLength;
		curField->flags = fieldDef->flags;
		curField->entry = fieldDef->entry;