process.c

uClinux下用的数据库

		strcpy(errMsg,"Can't create index copy file");
		debugTrace(TRACE_OUT,"processDropIndex()");
		return(-1);
	}

	/*
	** Copy the definitions over, skipping the dropped index
	*/
	found = 0;
	while( read(in, &tmp, sizeof(tmp)) == sizeof(tmp))
	{
		if (strcmp(tmp.name, query->indexDef.name) != 0)
		{
			write(out, &tmp, sizeof(tmp));
		}
		else
		{
			found = 1;
		}
	}
	
	/*
	** Did we find it?  
	*/
	close(in);
	close(out);
	if (!found)
	{
		snprintf(errMsg,MAX_ERR_MSG, "Unknown index '%s' for '%s'",
			query->indexDef.name, query->indexDef.table);
		unlink(tmpPath);
		debugTrace(TRACE_OUT,"processDropIndex()");
		return(-1);
	}

	/*
	** Yup.  Do the rest of the job.
	*/
	unlink(defPath);
	rename(tmpPath,defPath);
	snprintf(tmpPath,MSQL_PATH_LEN,"%s/%s/%s.idx-%s", server->config.dbDir,
		query->curDB, query->indexDef.table, query->indexDef.name);
	unlink(tmpPath);

        /*
        ** Invalidate the cache entry so that we reload it
        */

	cacheInvalidateEntry(entry);

	if (! internal)
	{
		if (server->config.hasBroker)
		{
			brokerChildSendFlush(query->curDB, 
				query->indexDef.table);
		}
		netOK(query->clientSock);
	}
	debugTrace(TRACE_OUT,"processDropIndex()");
	return(0);
}



int processDelete(server, query)
	msqld		*server;
	mQuery_t	*query;
{
	int		flist[MAX_FIELDS],
			*curOff,
			rowLen,
			res,
			count,
			haveText;
	u_int		rowNum,
			pos;
	row_t		row;
	mField_t	*fields,
			*curField;
	cache_t		*cacheEntry;
	mCand_t		*candidate;


	debugTrace(TRACE_IN,"processDelete()");
	if((cacheEntry = tableLoadDefinition(server,query->tableHead->name,NULL,
		query->curDB)) == NULL)
	{
		debugTrace(TRACE_OUT,"processDelete()");
		return(-1);
	}

	/*
	** Find the offsets of the given condition
	*/
	utilQualifyConds(query);
	if (utilSetupConds(cacheEntry, query->condHead) < 0)
	{
		debugTrace(TRACE_OUT,"processDelete()");
		return(-1);
	}

	if (tableInitTable(cacheEntry,FULL_REMAP) < 0)
	{
		debugTrace(TRACE_OUT,"processDelete()");
		return(-1);
	}


	fields = utilDupFieldList(cacheEntry);
	if (utilSetupFields(cacheEntry,flist, fields) < 0)
	{
		_freeFieldList(fields);
		debugTrace(TRACE_OUT,"processDelete()");
		return(-1);
	}

	
	lockGetFileLock(server,cacheEntry->dataFD,MSQL_WR_LOCK);

	rowLen = cacheEntry->rowLen;
	count = 0;
	candidate = craSetupCandidate(cacheEntry, query, KEEP_IDENT);
	if (!candidate)
	{
		lockGetFileLock(server,cacheEntry->dataFD,MSQL_UNLOCK);
		_freeFieldList(fields);
		debugTrace(TRACE_OUT,"processDelete");
		return(-1);
	}

	haveText = -1;
	rowNum = craGetCandidate(cacheEntry,candidate);
	while(rowNum != NO_POS)
	{
		if (tableReadRow(cacheEntry,&row,rowNum) < 0)
		{
			break;
		}
		if (!row.header->active)
		{
			rowNum = craGetCandidate(cacheEntry,candidate);
			continue;
		}
		res = compareMatchRow(cacheEntry,&row,query->condHead,query);
		if (res < 0)
		{
			lockGetFileLock(server,cacheEntry->dataFD,MSQL_UNLOCK);
			_freeFieldList(fields);
			craFreeCandidate(candidate);
			debugTrace(TRACE_OUT,"processDelete()");
			return(res);
		}
		if (res == 1)
		{
			/*
			** Flag the row as inactive
			*/
			row.header->active = 0;
			count++;
			cacheEntry->sblk->activeRows--;

			/*
			** Blow away any varChar overflow buffers
			** allocated to this row.  If haveText == 0
			** then don't bother trying.  haveText should
			** be set after the first scan.
			*/
			if (haveText != 0)
			{
				curField = cacheEntry->def;
				curOff = flist;
				haveText = 0;
				while(curField)
				{
					if (curField->type != TEXT_TYPE)
					{
						curField = curField->next;
						curOff++;
						continue;
					}
					haveText = 1;
					if (* (row.data + *curOff) == 1)
					{
						bcopy(row.data + *curOff + 1 + 
						sizeof(int),&pos,sizeof(u_int));
						varcharDelete(cacheEntry, pos);
					}
					curField = curField->next;
					curOff++;
				}
			}

			/*
			** Blow away any index entries
			*/
			tableExtractValues(cacheEntry,&row,fields,flist,query);
			indexDeleteIndices(cacheEntry,fields,rowNum);
			tablePushBlankPos(cacheEntry, query->curDB,
				query->tableHead->name, rowNum);

			/*
			** Have to reset this.  If it's an index based
			** lookup then the delete may have shuffled a 
			** a dup up the chain.  A getnext would skip the
			** correct entry.
			*/
			craResetCandidate(candidate, 1);
		}
		rowNum = craGetCandidate(cacheEntry,candidate);
	}
	lockGetFileLock(server,cacheEntry->dataFD,MSQL_UNLOCK);
	snprintf(packet,PKT_LEN,"%d:\n",count);
	netWritePacket(query->clientSock);
	debugTrace(TRACE_OUT,"processDelete()");
	craFreeCandidate(candidate);
	_freeFieldList(fields);
	return(0);
}




int processInsert(server, query)
	msqld		*server;
	mQuery_t	*query;
{
	int		flist[MAX_FIELDS],
			fullFlist[MAX_FIELDS],
			rowLen,
			res,
			count,
			curValueOffset;
	u_int		rowNum;
	row_t		*row;
	mField_t	*curField,
			*curField2;
	cache_t		*cacheEntry;
	mValList_t	*curValue;


	debugTrace(TRACE_IN,"processInsert()");
	if((cacheEntry = tableLoadDefinition(server,query->tableHead->name,NULL,
		query->curDB)) == NULL)
	{
		debugTrace(TRACE_OUT,"processInsert()");
		return(-1);
	}

	/*
	** Find the offsets of the given fields
	*/
	utilQualifyFields(query);
	if (utilSetupFields(cacheEntry,flist,query->fieldHead) < 0)
	{
		debugTrace(TRACE_OUT,"processInsert()");
		return(-1);
	}
	if (utilSetupFields(cacheEntry,fullFlist,cacheEntry->def) < 0)
	{
		debugTrace(TRACE_OUT,"processInsert()");
		return(-1);
	}

	/*
	** Ensure that no field is listed more than once
	*/
	curField = query->fieldHead;
	while(curField)
	{
		curField2 = curField;
		while(curField2)
		{
			if (curField2 == curField)
			{
				curField2 = curField2->next;
				continue;
			}
			if (strcmp(curField->name,curField2->name) == 0 &&
			    strcmp(curField->table,curField2->table) == 0)
			{
				snprintf(errMsg,MAX_ERR_MSG,NON_UNIQ_ERROR, 
					curField->name);
				msqlDebug1(MOD_ERR,"Field '%s' not unique",
					curField->name);
				debugTrace(TRACE_OUT,"processInsert()");
				return(-1);
			}
			curField2 = curField2->next;
		}
		curField = curField->next;
	}


	if (tableInitTable(cacheEntry,KEY_REMAP) < 0)
	{
		lockGetFileLock(server,cacheEntry->dataFD,MSQL_UNLOCK);
		debugTrace(TRACE_OUT,"processInsert()");
		return(-1);
	}

	/*
	** Create a blank row
	*/
	rowLen = cacheEntry->rowLen;
	row = &(cacheEntry->row);

	/*
	** Work through the sets of insert values
	*/
	count = 0;
	curValue = query->insertValHead;
	while(curValue)
	{
		
		curValueOffset = -1;
		curField = query->fieldHead;
		while(curField)
		{
			if (curValue == NULL || 
				curValue->offset <= curValueOffset)
			{
				snprintf(errMsg,MAX_ERR_MSG,
					"Missing value for field '%s'",
					curField->name);
				msqlDebug1(MOD_ERR,
					"Missing value for field '%s'",
					curField->name);
				debugTrace(TRACE_OUT,"processInsert()");
				return(-1);
			}
			curField->value = curValue->value;

			/*
			** Check for a NULL value
			*/
			if ((curField->flags & NOT_NULL_FLAG) &&
				curField->value->nullVal == 1)
			{
				snprintf(errMsg,MAX_ERR_MSG,BAD_NULL_ERROR, 
					curField->name);
				msqlDebug1(MOD_ERR,
					"Field \"%s\" cannot be null\n",
					curField->name);
				debugTrace(TRACE_OUT,"processInsert()");
				return(-1);
			}

			/*
			** Check the field and value types
			*/
			res = 0;
			if (curField->value->nullVal == 0)
			{
                        	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);
                        }


			curField = curField->next;
			curValue = curValue->next;
		}
		

		/*
		** Find a place to put this row
		*/

		lockGetFileLock(server,cacheEntry->dataFD,MSQL_WR_LOCK);
		rowNum = tablePopBlankPos(cacheEntry,query->curDB,
			query->tableHead->name);


		/*
		** Check for a unique primary key if we have one.
		*/
		res=indexCheckIndices(cacheEntry,query->fieldHead,NULL,NO_POS);
		if (res < 0)
		{
			lockGetFileLock(server,cacheEntry->dataFD,MSQL_UNLOCK);
			debugTrace(TRACE_OUT,"processInsert()");
			return(-1);
		}
		if (res == 0)
		{
			lockGetFileLock(server,cacheEntry->dataFD,MSQL_UNLOCK);
			strcpy(errMsg,KEY_UNIQ_ERROR);
			msqlDebug0(MOD_ERR,
				"Non unique value for unique index\n");
			debugTrace(TRACE_OUT,"processInsert()");
			return(-1);
		}

		/*
		** Fill in the given fields and dump it to the table file
		*/

		bzero(row->data,rowLen);
		if (tableFillRow(cacheEntry,row,query->fieldHead,flist) < 0)
		{
			lockGetFileLock(server,cacheEntry->dataFD,MSQL_UNLOCK);
			debugTrace(TRACE_OUT,"processInsert()");
			return(-1);
		}

		if (_checkNullFields(cacheEntry,row,fullFlist) < 0)
		{
			lockGetFileLock(server,cacheEntry->dataFD,MSQL_UNLOCK);
			debugTrace(TRACE_OUT,"processInsert()");
			return(-1);
		}

		if (indexCheckAllForNullFields(cacheEntry,row,fullFlist) < 0)
		{
			lockGetFileLock(server,cacheEntry->dataFD,MSQL_UNLOCK);
			debugTrace(TRACE_OUT,"processInsert()");
			return(-1);
		}
		indexInsertIndices(cacheEntry, query->fieldHead, rowNum);
		if(tableWriteRow(cacheEntry,NULL,rowNum, query) < 0)
		{
			lockGetFileLock(server,cacheEntry->dataFD,MSQL_UNLOCK);
			snprintf(errMsg,MAX_ERR_MSG,WRITE_ERROR, 
				(char*)strerror(errno));
			msqlDebug0(MOD_ERR,"Error on data write\n");
			debugTrace(TRACE_OUT,"processInsert()");
			return(-1);
		}
		cacheEntry->sblk->activeRows++;
		lockGetFileLock(server,cacheEntry->dataFD,MSQL_UNLOCK);	
		count++;
	}

	snprintf(packet,PKT_LEN,"%d:\n",count);
	netWritePacket(query->clientSock);
	debugTrace(TRACE_OUT,"processInsert()");
	return(0);
}



int processUpdate(server, query)
	msqld		*server;
	mQuery_t	*query;
{
	int		flist[MAX_FIELDS],
			fullFlist[MAX_FIELDS],
			rowLen,
			res,
			count,
			updated;
	u_int		rowNum;
	row_t		row;
	cache_t		*cacheEntry;
	mCand_t		*candidate;
	

	debugTrace(TRACE_IN,"processUpdate()");
	if((cacheEntry = tableLoadDefinition(server,query->tableHead->name,NULL,
		query->curDB)) == NULL)
	{
		debugTrace(TRACE_OUT,"processUpdate()");
		return(-1);
	}

	/*
	** Find the offsets of the given fields and condition
	*/
	utilQualifyFields(query);
	utilQualifyConds(query);
	if (utilSetupFields(cacheEntry,flist,query->fieldHead) < 0)
	{
		debugTrace(TRACE_OUT,"processUpdate()");
		return(-1);
	}
	if (utilSetupFields(cacheEntry,fullFlist,cacheEntry->def) < 0)
	{
		debugTrace(TRACE_OUT,"processUpdate()");
		return(-1);
	}
	if (utilSetupConds(cacheEntry,query->condHead) < 0)
	{
		debugTrace(TRACE_OUT,"processUpdate()");
		return(-1);
	}

	rowLen = cacheEntry->rowLen;

	if (tableInitTable(cacheEntry,FULL_REMAP) < 0)
	{
		debugTrace(TRACE_OUT,"processUpdate()");
		return(-1);
	}

	lockGetFileLock(server,cacheEntry->dataFD,MSQL_WR_LOCK);
	count = 0;
	candidate = craSetupCandidate(cacheEntry, query, KEEP_IDENT);
	if (!candidate)
	{
		lockGetFileLock(server,cacheEntry->dataFD, MSQL_UNLOCK);
		return(-1);
	}
	rowNum = craGetCandidate(cacheEntry, candidate);
	while(rowNum != NO_POS)
	{
		if (tableReadRow(cacheEntry,&row,rowNum) < 0)
		{
			lockGetFileLock(server,cacheEntry->dataFD,MSQL_UNLOCK);
			return(-1);
		}
		if (!row.header->active)
		{
			rowNum = craGetCandidate(cacheEntry, candidate);
			continue;
		}
		res = compareMatchRow(cacheEntry,&row,query->condHead,query);
		if (res < 0)
		{
			lockGetFileLock(server,cacheEntry->dataFD,MSQL_UNLOCK);
			craFreeCandidate(candidate);