process.c

uClinux下用的数据库

			}
		}
	}
	netEndOfList(sock);
	debugTrace(TRACE_OUT,"msqlListFields()");
}


int processCreateTable(server, query)
	msqld		*server;
	mQuery_t	*query;
{
	char		*table;
	char		datPath[255],
			oflPath[255];
	int		fd;
	sblk_t 		sblock;
	u_int		freeList;


	debugTrace(TRACE_IN,"processCreateTable()");

	table = query->tableHead->name;

	/*
	** Write the catalog entry
	*/
	if (tableCreateDefinition(server, table,query) < 0)
	{
		debugTrace(TRACE_OUT,"processCreateTable()");
		return(-1);
	}
		
	/*
	** Create an empty table
	*/
	
	snprintf(datPath,MSQL_PATH_LEN, "%s/%s/%s.dat", server->config.dbDir,
		query->curDB, table);
	fd = open(datPath,O_CREAT | O_WRONLY , 0600);
	if (fd < 0)
	{
		unlink(datPath);
		snprintf(errMsg, MAX_ERR_MSG,DATA_FILE_ERROR,table, 
			(char*)strerror(errno));
		msqlDebug1(MOD_ERR,"Error creating table file for \"%s\"\n",
			table);
		debugTrace(TRACE_OUT,"processCreateTable()");
		return(-1);
	}
	sblock.version = DB_VERSION;
	sblock.numRows = sblock.activeRows = 0;
	sblock.freeList = NO_POS;
	sblock.sequence.step = sblock.sequence.value = 0;
	if (write(fd,&sblock,SBLK_SIZE) < SBLK_SIZE)
	{
		close(fd);
		unlink(datPath);
		snprintf(errMsg, MAX_ERR_MSG, DATA_FILE_ERROR,table, 
			(char*)strerror(errno));
		msqlDebug1(MOD_ERR,"Error creating table file for \"%s\"\n",
			table);
		debugTrace(TRACE_OUT,"processCreateTable()");
		return(-1);
	}
	close(fd);


	/*
	** NOTE : The index def file file doesn't need to
	** 	  be created here as it is a 0 length file.  It
	**	  is now created using the open when the table is
	**	  first loaded into the table cache
	** 
	** Create an empty overflow file
	*/
	snprintf(oflPath,MSQL_PATH_LEN,"%s/%s/%s.ofl", server->config.dbDir,
		query->curDB, table);
	fd = open(oflPath,O_CREAT | O_WRONLY , 0600);
	if (fd < 0)
	{
		unlink(datPath);
		snprintf(errMsg,MAX_ERR_MSG,DATA_FILE_ERROR,table, 
			(char*)strerror(errno));
		msqlDebug1(MOD_ERR,"Error creating table file for \"%s\"\n",
			table);
		debugTrace(TRACE_OUT,"processCreateTable()");
		return(-1);
	}
	freeList = NO_POS;
	if (write(fd,&freeList,sizeof(u_int)) < sizeof(u_int))
	{
		close(fd);
		unlink(datPath);
		snprintf(errMsg,MAX_ERR_MSG,DATA_FILE_ERROR,table, 
			(char*)strerror(errno));
		msqlDebug1(MOD_ERR,"Error creating table file for \"%s\"\n",
			table);
		debugTrace(TRACE_OUT,"processCreateTable()");
		return(-1);
	}
	close(fd);

	netOK(query->clientSock);
	debugTrace(TRACE_OUT,"processCreateTable()");
	return(0);
}



int processCreateIndex(server, query)
	msqld		*server;
	mQuery_t	*query;
{
	char		defPath[255],
			idxPath[255],
			*indexName,
			*tableName,
			*dbName;
	mField_t	*curField,
			*indexField;
	int		fd,
			fieldLoc,
			fieldCount,
			length,
			existingData;
	cache_t		*entry;
	mIndex_t	tmp;

	debugTrace(TRACE_IN,"processCreateIndex()");

	/*
	** Ensure the index name doesn't clash with a field
	*/
	tableName = query->indexDef.table;
	indexName = query->indexDef.name;
	dbName = query->curDB;
	if ((entry = tableLoadDefinition(server,tableName,NULL,dbName)) == NULL)
	{
		debugTrace(TRACE_OUT,"processCreateIndex()");
		return(-1);
	}

	existingData = (entry->sblk->activeRows > 0)?1:0;
	length = 0;
	curField = entry->def;
	while(curField)
	{
		if ( *(curField->name) != *(indexName))
		{
			curField = curField->next;
			continue;
		}
		if (strcmp(curField->name,indexName) != 0)
		{
			curField = curField->next;
			continue;
		}

		strcpy(errMsg,"Bad index name");
		debugTrace(TRACE_OUT,"processCreateIndex()");
		return(-1);
	}

	/*
	** Can't clash with another index either
	*/
	snprintf(defPath,MSQL_PATH_LEN,"%s/%s/%s.idx",server->config.dbDir,
		dbName, tableName);
	snprintf(idxPath,MSQL_PATH_LEN,"%s/%s/%s.idx-%s",server->config.dbDir,
		dbName, tableName, indexName);

	fd = open(defPath,O_RDWR | O_CREAT , 0600);
	if (fd < 0)
	{
		(void)close(fd);
		strcpy(errMsg,"Can't open index definition file");
		debugTrace(TRACE_OUT,"processCreateIndex()");
		return(-1);
	}

	while(read(fd, &tmp, sizeof(tmp)) == sizeof(tmp))
	{
		if ( *(tmp.name) != *(indexName))
			continue;
		if (strcmp(tmp.name, indexName) != 0)
			continue;
		
		strcpy(errMsg,"Bad index name");
		debugTrace(TRACE_OUT,"processCreateIndex()");
		close(fd);
		return(-1);
	}
	
	/*
	** OK, setup the struct and add it to the index def file
	*/
	indexField = query->fieldHead;
	fieldCount = 0;
	while(indexField)
	{
		fieldLoc = 0;
		curField = entry->def;
		while(curField)
		{
			if ( *(curField->name) != *(indexField->name))
			{
				curField = curField->next;
				fieldLoc++;
				continue;
			}
			if (strcmp(curField->name, indexField->name)!=0)
			{
				curField = curField->next;
				fieldLoc++;
				continue;
			}
			break;
		}
		if (!curField)
		{
			snprintf(errMsg,MAX_ERR_MSG,"Unknown field '%s'",
				indexField->name);
			debugTrace(TRACE_OUT,"msqlCreateIndex()");
			close(fd);
			return(-1);
		}
		if (curField->type == TEXT_TYPE)
		{
			strcpy(errMsg,"Can't index on a TEXT field!");
			debugTrace(TRACE_OUT,"msqlCreateIndex()");
			close(fd);
			return(-1);
		}
		query->indexDef.fields[fieldCount] = fieldLoc;
		fieldCount++;
		length += curField->length;
		if(fieldCount > MAX_INDEX_WIDTH - 1)
		{
			strcpy(errMsg,"Too many fields in index");
			debugTrace(TRACE_OUT,"msqlCreateIndex()");
			close(fd);
			return(-1);
		}
		indexField = indexField->next;
	}

	if (fieldCount == 1)
	{
		switch(typeBaseType(curField->type))
		{
			case CHAR_TYPE:
				query->indexDef.keyType = IDX_CHAR;
				break;

			case INT_TYPE:
				query->indexDef.keyType = IDX_INT;
				break;

			case UINT_TYPE:
				query->indexDef.keyType = IDX_UINT;
				break;

			case REAL_TYPE:
				query->indexDef.keyType = IDX_REAL;
				break;

			default:
				query->indexDef.keyType = IDX_BYTE;
				break;
		}
	}
	else
	{
		query->indexDef.keyType = IDX_BYTE;
	}

	query->indexDef.fields[fieldCount] = -1;
	query->indexDef.length = length;
	query->indexDef.fieldCount = fieldCount;
	write(fd, &(query->indexDef), sizeof(mIndex_t));
	close(fd);

	idxCreate(idxPath, query->indexDef.idxType, 0600, length, 
		query->indexDef.keyType, IDX_DUP, &query->indexDef.environ);


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

	cacheInvalidateEntry(entry);

	/*
	** If there's data in the table then prime the index
	*/
	if (existingData)
	{
		if(_populateIndexFile(server, query) < 0)
		{
			debugTrace(TRACE_OUT,"msqlCreateIndex()");
			return(-1);
		}
	}
	if (server->config.hasBroker)
		brokerChildSendFlush(query->curDB,query->indexDef.table);
	netOK(query->clientSock);
	debugTrace(TRACE_OUT,"msqlCreateIndex()");
	return(0);
}




int processDropSequence(server, query)
	msqld		*server;
	mQuery_t	*query;
{
	cache_t		*entry;

	debugTrace(TRACE_IN,"processDropSequence()");

	/*
	** See if there is a sequence on this table
	*/
	if ((entry = tableLoadDefinition(server,query->sequenceDef.table, NULL,
		query->curDB)) == NULL)
	{
		debugTrace(TRACE_OUT,"processDropSequence()");
		return(-1);
	}
	if (entry->sblk->sequence.step == 0)
	{
		snprintf(errMsg,MAX_ERR_MSG,
			"Table '%s' does not have a sequence",
			query->sequenceDef.table);
		debugTrace(TRACE_OUT,"processDropSequence()");
		return(-1);
	}

	entry->sblk->sequence.step = 0;
	entry->sblk->sequence.value = 0;
	if (server->config.hasBroker)
		brokerChildSendFlush(query->curDB, query->sequenceDef.table);
	netOK(query->clientSock);
	debugTrace(TRACE_OUT,"processDropSequence()");
	return(0);
}



int processCreateSequence(server, query)
	msqld		*server;
	mQuery_t	*query;
{
	cache_t		*entry;

	debugTrace(TRACE_IN,"processCreateSequence()");

	/*
	** See if there is a sequence on this table already
	*/
	if ((entry = tableLoadDefinition(server,query->sequenceDef.table,NULL,
		query->curDB)) == NULL)
	{
		debugTrace(TRACE_OUT,"processCreateSequence()");
		return(-1);
	}
	if (entry->sblk->sequence.step != 0)
	{
		snprintf(errMsg,MAX_ERR_MSG,
			"Table '%s' already has a sequence",
			query->sequenceDef.table);
		debugTrace(TRACE_OUT,"processCreateSequence()");
		return(-1);
	}

	entry->sblk->sequence.step = query->sequenceDef.step;
	entry->sblk->sequence.value = query->sequenceDef.value;
	if (server->config.hasBroker)
		brokerChildSendFlush(query->curDB,query->sequenceDef.table);
	netOK(query->clientSock);
	debugTrace(TRACE_OUT,"processCreateSequence()");
	return(0);
}




int processDropTable(server, query)
	msqld		*server;
	mQuery_t	*query;
{
	extern	cache_t	*tableCache;

	char		path[MSQL_PATH_LEN],
			defPath[MSQL_PATH_LEN],
			*cp;
	FILE		*fp;
	int		fd;
	mIndex_t	tmp;
	cache_t 	*entry;
	int		count;

	debugTrace(TRACE_IN,"processDropTable()");

	/* 
	** Invalidate the cache entry so that we don't use it again 
	*/

	count = 0;
	while(count < server->config.tableCache)
	{
		entry = tableCache + count;
		if (*entry->db == *query->curDB)
		{
			if((strcmp(entry->db,query->curDB)==0) &&
		   	(strcmp(entry->table,query->tableHead->name)==0 ||
		    	strcmp(entry->cname,query->tableHead->name)==0))
			{
				cacheInvalidateEntry(entry);
			}
		}
		count++;
	}

	/*
	** Now blow away the table files
	*/
	snprintf(path,MSQL_PATH_LEN,"%s/%s/%s.def",server->config.dbDir,
		query->curDB, query->tableHead->name);
	cp = (char *)rindex(path,'.');
	fp = fopen(path,"rb");
	if (!fp)
	{
		snprintf(errMsg,MAX_ERR_MSG,BAD_TABLE_ERROR,
			query->tableHead->name);
		msqlDebug1(MOD_ERR,"Unknown table \"%s\"\n",
			query->tableHead->name);
		debugTrace(TRACE_OUT,"processDropTable()");
		return(-1);
	}
	(void)fclose(fp);
	unlink(path);

	*cp = 0;
	strcat(path,".dat");
	unlink(path);
	*cp = 0;
	strcat(path,".ofl");
	unlink(path);

	/*
	** Take care of the index files.
	*/
	*cp = 0;
	strcpy(defPath,path);
	strcat(defPath,".idx");
	*cp = 0;
	strcat(path,".idx-");
	cp = path + strlen(path);
	fd = open(defPath,O_RDONLY ,0);
	if (fd >= 0)
	{
		while(read(fd,&tmp,sizeof(tmp)) == sizeof(tmp))
		{
			strcat(path,tmp.name);
			unlink(path);
			*cp = 0;
		}
		close(fd);
	}
	unlink(defPath);

	if (server->config.hasBroker)
		brokerChildSendFlush(query->curDB, query->tableHead->name);
	netOK(query->clientSock);
	debugTrace(TRACE_OUT,"processDropTable()");
	return(0);
}



int processDropIndex(server, query, internal)
	msqld		*server;
	mQuery_t	*query;
	int		internal;
{
	char		defPath[255],
			tmpPath[255];
	int		in,
			out,
			found;
	mIndex_t	tmp;
	cache_t		*entry;


	/* 
	** Note : internal flag used to determine if we've been called
	** directly from a "drop index" query or if some other part
	** of the backend has called us (eg. during the processing
	** of a table drop)
	*/

	debugTrace(TRACE_IN,"processDropIndex()");

	/*
	** Open the definition file and a file to copy it into
	*/
	if ((entry = tableLoadDefinition(server,query->indexDef.table, NULL,
		query->curDB)) == NULL)
	{
		debugTrace(TRACE_OUT,"processDropIndex()");
		return(-1);
	}

	snprintf(defPath,MSQL_PATH_LEN,"%s/%s/%s.idx", server->config.dbDir,
		query->curDB, query->indexDef.table);
	in = open(defPath,O_RDONLY ,0600);
	if (in < 0)
	{
		snprintf(errMsg,MAX_ERR_MSG,"No indices defined for '%s'",
			query->indexDef.table);
		debugTrace(TRACE_OUT,"processDropIndex()");
		return(-1);
	}
	snprintf(tmpPath,MSQL_PATH_LEN,"%s/%s/%s.idx-tmp", server->config.dbDir,
		query->curDB, query->indexDef.table);
	out = open(tmpPath,O_RDWR | O_CREAT ,0600);
	if (out < 0)
	{
		(void)close(in);