bzr push into mysql-6.0-falcon-team branch (hky:2843 to 2844)

[Hakan Kuecuekyilmaz]

 2844 Hakan Kuecuekyilmaz	2008-10-01
      Removed unused
         JString tableSpace = JString::upcase(tableSpaceName);
      
      and while on it also fixed trailing whitespaces.
modified:
  storage/falcon/StorageHandler.cpp

 2843 Kevin Lewis	2008-09-30
      Bug#39321 Add an exclusive lock on Database::syncScavenge in
      Database::truncateTable before the lock of Table::syncObject
      just in case the truncateTable process has to call
      Database::forceRecordScavenge.  syncScavenge must be locked
      before Table::syncObject because the scavenger does it that way.
      
      According to the Deadlock Predictor (SyncHandler.cpp), 
      syncScavenge must also be locked before Database::syncTables.
modified:
  storage/falcon/Database.cpp

=== modified file 'storage/falcon/StorageHandler.cpp'
--- a/storage/falcon/StorageHandler.cpp	2008-09-11 10:56:00 +0000
+++ b/storage/falcon/StorageHandler.cpp	2008-10-01 03:13:44 +0000
@@ -61,11 +61,11 @@ static const char *createTempSpace = "up
 static const char *falconSchema [] = {
 	//"create tablespace " DEFAULT_TABLESPACE " filename '" FALCON_USER "' allocation
2000000000",
 	createTempSpace,
-	
+
 	"upgrade table falcon.tablespaces ("
 	"    name varchar(128) not null primary	key,"
 	"    pathname varchar(1024) not null)",
-	
+
 	"upgrade table falcon.tables ("
 	"    given_schema_name varchar(128) not null,"
 	"    effective_schema_name varchar(128) not null,"
@@ -73,11 +73,11 @@ static const char *falconSchema [] = {
 	"    effective_table_name varchar(128) not null,"
 	"    tablespace_name varchar(128) not null,"
 	"    pathname varchar(1024) not null primary key)",
-	
+
 	"upgrade unique index effective on falcon.tables (effective_schema_name,
effective_table_name)",
 
 	NULL };
-				
+
 class Server;
 extern Server*	startServer(int port, const char *configFile);
 
@@ -95,13 +95,13 @@ static const char THIS_FILE[]=__FILE__;
 int init()
 {
 	const char *p;
-	
+
 	for (p = WHITE_SPACE; *p; p++)
 		charTable[(unsigned char)*p] = 1;
-	
+
 	for (p = PUNCTUATION_CHARS; *p; p++)
 		charTable[(unsigned char)*p] = 1;
-	
+
 	return 1;
 }
 
@@ -109,7 +109,7 @@ StorageHandler*	getFalconStorageHandler(
 {
 	if (!storageHandler)
 		storageHandler = new StorageHandler(lockSize);
-	
+
 	return storageHandler;
 }
 
@@ -151,7 +151,7 @@ StorageHandler::~StorageHandler(void)
 			storageDatabases[n] = storageDatabase->collision;
 			delete storageDatabase;
 			}
-	
+
 	for (int n = 0; n < tableHashSize; ++n)
 		for (StorageTableShare *table; (table = tables[n]);)
 			{
@@ -190,11 +190,11 @@ void StorageHandler::shutdownHandler(voi
 		dictionaryConnection->close();
 		dictionaryConnection = NULL;
 		}
-	
+
 	for (int n = 0; n < databaseHashSize; ++n)
 		for (StorageDatabase *storageDatabase = storageDatabases[n]; storageDatabase;
storageDatabase = storageDatabase->collision)
 			storageDatabase->close();
-	
+
 	/***
 	Configuration configuration(NULL);
 	Connection *connection = new Connection(&configuration);
@@ -207,14 +207,14 @@ void StorageHandler::databaseDropped(Sto
 {
 	if (!storageDatabase && storageConnection)
 		storageDatabase = storageConnection->storageDatabase;
-		
+
 	if (storageDatabase)
 		{
 		Sync syncHash(&hashSyncObject, "StorageHandler::databaseDropped(1)");
 		int slot = JString::hash(storageDatabase->name, databaseHashSize);
 		syncHash.lock(Exclusive);
 		StorageDatabase **ptr;
-		
+
 		for (ptr = storageDatabases + slot; *ptr; ptr = &(*ptr)->collision)
 			if (*ptr == storageDatabase)
 				{
@@ -240,7 +240,7 @@ void StorageHandler::databaseDropped(Sto
 		for (StorageConnection *cnct = connections[n]; cnct; cnct = cnct->collision)
 			if (cnct != storageConnection)
 				cnct->databaseDropped(storageDatabase);
-			
+
 	sync.unlock();
 }
 
@@ -256,8 +256,8 @@ int StorageHandler::startTransaction(THD
 	Sync sync(&syncObject, "StorageHandler::commit");
 	sync.lock(Shared);
 	int slot = HASH(mySqlThread, connectionHashSize);
-	
-	for (StorageConnection *storageConnection = connections[slot]; 
+
+	for (StorageConnection *storageConnection = connections[slot];
 		 storageConnection; storageConnection = storageConnection->collision)
 		{
 		if (storageConnection->mySqlThread == mySqlThread)
@@ -276,16 +276,16 @@ int StorageHandler::commit(THD* mySqlThr
 	Sync sync(&syncObject, "StorageHandler::commit");
 	sync.lock(Shared);
 	int slot = HASH(mySqlThread, connectionHashSize);
-	
+
 	for (StorageConnection *connection = connections[slot]; connection; connection =
connection->collision)
 		if (connection->mySqlThread == mySqlThread)
 			{
 			int ret =connection->commit();
-			
+
 			if (ret)
 				return ret;
 			}
-	
+
 	return 0;
 }
 
@@ -294,16 +294,16 @@ int StorageHandler::prepare(THD* mySqlTh
 	Sync sync(&syncObject, "StorageHandler::prepare");
 	sync.lock(Shared);
 	int slot = HASH(mySqlThread, connectionHashSize);
-	
+
 	for (StorageConnection *connection = connections[slot]; connection; connection =
connection->collision)
 		if (connection->mySqlThread == mySqlThread)
 			{
 			int ret = connection->prepare(xidSize, xid);
-			
+
 			if (ret)
 				return ret;
 			}
-	
+
 	return 0;
 }
 
@@ -312,16 +312,16 @@ int StorageHandler::rollback(THD* mySqlT
 	Sync sync(&syncObject, "StorageHandler::rollback");
 	sync.lock(Shared);
 	int slot = HASH(mySqlThread, connectionHashSize);
-	
+
 	for (StorageConnection *connection = connections[slot]; connection; connection =
connection->collision)
 		if (connection->mySqlThread == mySqlThread)
 			{
 			int ret = connection->rollback();
-			
+
 			if (ret)
 				return ret;
 			}
-	
+
 	return 0;
 }
 
@@ -330,11 +330,11 @@ int StorageHandler::releaseVerb(THD* myS
 	Sync sync(&syncObject, "StorageHandler::releaseVerb");
 	sync.lock(Shared);
 	int slot = HASH(mySqlThread, connectionHashSize);
-	
+
 	for (StorageConnection *connection = connections[slot]; connection; connection =
connection->collision)
 		if (connection->mySqlThread == mySqlThread)
 			connection->releaseVerb();
-	
+
 	return 0;
 }
 
@@ -343,11 +343,11 @@ int StorageHandler::rollbackVerb(THD* my
 	Sync sync(&syncObject, "StorageHandler::rollbackVerb");
 	sync.lock(Shared);
 	int slot = HASH(mySqlThread, connectionHashSize);
-	
+
 	for (StorageConnection *connection = connections[slot]; connection; connection =
connection->collision)
 		if (connection->mySqlThread == mySqlThread)
 			connection->rollbackVerb();
-	
+
 	return 0;
 }
 
@@ -357,7 +357,7 @@ int StorageHandler::savepointSet(THD* my
 	sync.lock(Shared);
 	int slot = HASH(mySqlThread, connectionHashSize);
 	StorageSavepoint *savepoints = NULL;
-	
+
 	for (StorageConnection *connection = connections[slot]; connection; connection =
connection->collision)
 		if (connection->mySqlThread == mySqlThread)
 			{
@@ -367,9 +367,9 @@ int StorageHandler::savepointSet(THD* my
 			savepoint->storageConnection = connection;
 			savepoint->savepoint = connection->savepointSet();
 			}
-	
+
 	*((void**) savePoint) = savepoints;
-	
+
 	return 0;
 }
 
@@ -377,15 +377,15 @@ int StorageHandler::savepointRelease(THD
 {
 	Sync sync(&syncObject, "StorageHandler::savepointRelease");
 	sync.lock(Shared);
-	
-	for (StorageSavepoint *savepoints = *(StorageSavepoint**) savePoint, *savepoint; 
+
+	for (StorageSavepoint *savepoints = *(StorageSavepoint**) savePoint, *savepoint;
 		  (savepoint = savepoints);)
 		{
 		savepoint->storageConnection->savepointRelease(savepoint->savepoint);
 		savepoints = savepoint->next;
 		delete savepoint;
 		}
-		
+
 	*((void**) savePoint) = NULL;
 
 	return 0;
@@ -395,15 +395,15 @@ int StorageHandler::savepointRollback(TH
 {
 	Sync sync(&syncObject, "StorageHandler::savepointRollback");
 	sync.lock(Shared);
-	
-	for (StorageSavepoint *savepoints = *(StorageSavepoint**) savePoint, *savepoint; 
+
+	for (StorageSavepoint *savepoints = *(StorageSavepoint**) savePoint, *savepoint;
 		   (savepoint = savepoints);)
 		{
 		savepoint->storageConnection->savepointRollback(savepoint->savepoint);
 		savepoints = savepoint->next;
 		delete savepoint;
 		}
-	
+
 	*((void**) savePoint) = NULL;
 
 	return 0;
@@ -414,22 +414,22 @@ StorageDatabase* StorageHandler::getStor
 	Sync sync(&hashSyncObject, "StorageHandler::getStorageDatabase");
 	int slot = JString::hash(dbName, databaseHashSize);
 	StorageDatabase *storageDatabase;
-	
+
 	if (storageDatabases[slot])
 		{
 		sync.lock(Shared);
-		
+
 		if ( (storageDatabase = findDatabase(dbName)) )
 			return storageDatabase;
-			
+
 		sync.unlock();
 		}
-		
+
 	sync.lock(Exclusive);
 
 	if ( (storageDatabase = findDatabase(dbName)) )
 		return storageDatabase;
-	
+
 	storageDatabase = new StorageDatabase(this, dbName, path);
 	storageDatabase->load();
 	storageDatabase->collision = storageDatabases[slot];
@@ -437,7 +437,7 @@ StorageDatabase* StorageHandler::getStor
 	storageDatabase->addRef();
 	storageDatabase->next = databaseList;
 	databaseList = storageDatabase;
-	
+
 	return storageDatabase;
 }
 
@@ -446,7 +446,7 @@ void StorageHandler::closeDatabase(const
 	Sync sync(&hashSyncObject, "StorageHandler::closeDatabase");
 	int slot = JString::hash(path, databaseHashSize);
 	sync.lock(Exclusive);
-	
+
 	for (StorageDatabase *storageDatabase, **ptr = storageDatabases + slot; (storageDatabase
= *ptr); ptr = &storageDatabase->collision)
 		if (storageDatabase->filename == path)
 			{
@@ -505,9 +505,7 @@ int StorageHandler::createTablespace(con
 		return StorageErrorTableSpaceExist;
 		}
 
-	JString tableSpace = JString::upcase(tableSpaceName);
-
-	TableSpaceManager *tableSpaceManager = 
+	TableSpaceManager *tableSpaceManager =
 		dictionaryConnection->database->tableSpaceManager;
 
 	if (!tableSpaceManager->waitForPendingDrop(filename, 10))
@@ -527,16 +525,16 @@ int StorageHandler::createTablespace(con
 		{
 		if (exception.getSqlcode() == TABLESPACE_EXIST_ERROR)
 			return StorageErrorTableSpaceExist;
-			
+
 		if (exception.getSqlcode() == TABLESPACE_NOT_EXIST_ERROR)
 			return StorageErrorTableSpaceNotExist;
 
 		if (exception.getSqlcode() == TABLESPACE_DATAFILE_EXIST_ERROR)
 			return StorageErrorTableSpaceDataFileExist;
-			
+
 		return StorageErrorTablesSpaceOperationFailed;
 		}
-	
+
 	return 0;
 }
 
@@ -554,7 +552,7 @@ int StorageHandler::deleteTablespace(con
 		{
 		return StorageErrorTablesSpaceOperationFailed;
 		}
-		
+
 	try
 		{
 		CmdGen gen;
@@ -568,16 +566,16 @@ int StorageHandler::deleteTablespace(con
 	catch (SQLException& exception)
 		{
 		int sqlCode = exception.getSqlcode();
-		
+
 		if (sqlCode == TABLESPACE_NOT_EXIST_ERROR)
 			return StorageErrorTableSpaceNotExist;
-			
+
 		if (sqlCode == TABLESPACE_NOT_EMPTY)
 			return StorageErrorTableNotEmpty;
-			
+
 		return StorageErrorTablesSpaceOperationFailed;
 		}
-	
+
 	return 0;
 }
 
@@ -592,26 +590,26 @@ StorageTableShare* StorageHandler::findT
 	if (tables[slot])
 		{
 		sync.lock(Shared);
-		
+
 		for (tableShare = tables[slot]; tableShare; tableShare = tableShare->collision)
 			if (tableShare->pathName == filename)
 				return tableShare;
-	
+
 		sync.unlock();
 		}
 
 	sync.lock(Exclusive);
-	
+
 	for (tableShare = tables[slot]; tableShare; tableShare = tableShare->collision)
 		if (tableShare->pathName == filename)
 			return tableShare;
-	
+
 	tableShare = new StorageTableShare(this, filename, NULL, mySqlLockSize, false);
 	tableShare->collision = tables[slot];
 	tables[slot] = tableShare;
-	
+
 	ASSERT(tableShare->collision != tableShare);
-	
+
 	return tableShare;
 }
 
@@ -632,7 +630,7 @@ StorageTableShare* StorageHandler::preDe
 		{
 		Sync sync(&hashSyncObject, "StorageHandler::preDeleteTable");
 		sync.lock(Shared);
-		
+
 		for (tableShare = tables[slot]; tableShare; tableShare = tableShare->collision)
 			if (tableShare->pathName == filename)
 				return tableShare;
@@ -643,14 +641,14 @@ StorageTableShare* StorageHandler::preDe
 		tableShare = new StorageTableShare(this, filename, NULL, mySqlLockSize, false);
 		JString path = tableShare->lookupPathName();
 		delete tableShare;
-		
+
 		if (path == pathname)
 			return findTable(pathname);
 		}
 	catch (...)
 		{
 		}
-	
+
 	return NULL;
 }
 
@@ -663,17 +661,17 @@ StorageTableShare* StorageHandler::creat
 		return NULL;
 
 	StorageTableShare *tableShare = new StorageTableShare(this, pathname, tableSpaceName,
mySqlLockSize, tempTable);
-	
+
 	if (tableShare->tableExists())
 		{
 		delete tableShare;
-		
+
 		return NULL;
 		}
 
 	addTable(tableShare);
 	tableShare->registerTable();
-	
+
 	return tableShare;
 }
 
@@ -684,7 +682,7 @@ void StorageHandler::addTable(StorageTab
 	sync.lock(Exclusive);
 	table->collision = tables[slot];
 	tables[slot] = table;
-	
+
 	ASSERT(table->collision != table);
 }
 
@@ -693,7 +691,7 @@ void StorageHandler::removeTable(Storage
 	Sync sync(&hashSyncObject, "StorageHandler::removeTable");
 	sync.lock(Exclusive);
 	int slot = JString::hash(table->pathName, tableHashSize);
-	
+
 	for (StorageTableShare **ptr = tables + slot; *ptr; ptr = &(*ptr)->collision)
 		if (*ptr == table)
 			{
@@ -705,7 +703,7 @@ void StorageHandler::removeTable(Storage
 StorageConnection* StorageHandler::getStorageConnection(StorageTableShare* tableShare,
THD* mySqlThread, int mySqlThdId, OpenOption createFlag)
 {
 	Sync sync(&syncObject, "StorageHandler::getStorageConnection");
-	
+
 	if (!defaultDatabase)
 		initialize();
 
@@ -727,10 +725,10 @@ StorageConnection* StorageHandler::getSt
 			if (storageConnection->mySqlThread == mySqlThread) // &&
storageConnection->storageDatabase == tableShare->storageDatabase)
 				{
 				storageConnection->addRef();
-				
+
 				if (!tableShare->storageDatabase)
 					tableShare->setDatabase(storageDatabase);
-					
+
 				return storageConnection;
 				}
 
@@ -743,16 +741,16 @@ StorageConnection* StorageHandler::getSt
 		if (storageConnection->mySqlThread == mySqlThread) // &&
storageConnection->storageDatabase == tableShare->storageDatabase)
 			{
 			storageConnection->addRef();
-				
+
 			if (!tableShare->storageDatabase)
 				tableShare->setDatabase(storageDatabase);
-					
+
 			return storageConnection;
 			}
-	
+
 	storageConnection = new StorageConnection(this, storageDatabase, mySqlThread,
mySqlThdId);
 	bool success = false;
-	
+
 	if (createFlag != CreateDatabase) // && createFlag != OpenTemporaryDatabase)
 		try
 			{
@@ -763,15 +761,15 @@ StorageConnection* StorageHandler::getSt
 			{
 			//fprintf(stderr, "database open failed: %s\n", exception.getText());
 			storageConnection->setErrorText(exception.getText());
-			
+
 			if (createFlag == OpenDatabase)
 				{
 				delete storageConnection;
-				
+
 				return NULL;
 				}
 			}
-	
+
 	if (!success && createFlag != OpenDatabase)
 		try
 			{
@@ -780,29 +778,29 @@ StorageConnection* StorageHandler::getSt
 		catch (SQLException&)
 			{
 			delete storageConnection;
-			
+
 			return NULL;
 			}
-	
+
 	tableShare->setDatabase(storageDatabase);
 	storageConnection->collision = connections[slot];
 	connections[slot] = storageConnection;
-	
+
 	return storageConnection;
 }
 
 StorageDatabase* StorageHandler::findDatabase(const char* dbName)
 {
 	int slot = JString::hash(dbName, databaseHashSize);
-	
+
 	for (StorageDatabase *storageDatabase = storageDatabases[slot]; storageDatabase;
storageDatabase = storageDatabase->collision)
 		if (storageDatabase->name == dbName)
 			{
 			storageDatabase->addRef();
-			
+
 			return storageDatabase;
 			}
-			
+
 	return NULL;
 }
 
@@ -820,7 +818,7 @@ void StorageHandler::changeMySqlThread(S
 void StorageHandler::removeConnection(StorageConnection* storageConnection)
 {
 	int slot = HASH(storageConnection->mySqlThread, connectionHashSize);
-	
+
 	for (StorageConnection **ptr = connections + slot; *ptr; ptr =
&(*ptr)->collision)
 		if (*ptr == storageConnection)
 			{
@@ -838,7 +836,7 @@ int StorageHandler::closeConnections(THD
 	for (StorageConnection *storageConnection = connections[slot], *next; storageConnection;
storageConnection = next)
 		{
 		next = storageConnection->collision;
-		
+
 		if (storageConnection->mySqlThread == thd)
 			{
 			sync.unlock();
@@ -847,7 +845,7 @@ int StorageHandler::closeConnections(THD
 
 			if (storageConnection->mySqlThread)
 				storageConnection->release();	// This is for thd->ha_data[falcon_hton->slot]
-			
+
 			storageConnection->release();	// This is for storageConn
 			}
 		}
@@ -861,25 +859,25 @@ int StorageHandler::dropDatabase(const c
 	char pathname[FILENAME_MAX];
 	const char *SEPARATOR = pathname;
 	char *q = pathname;
-	
+
 	for (const char *p = path; *p;)
 		{
 		char c = *p++;
-		
+
 		if (c == '/')
 			{
 			if (*p == 0)
 				break;
-				
+
 			SEPARATOR = q + 1;
 			}
-		
+
 		*q++ = c;
 		}
-	
+
 	*q = 0;
 	JString dbName = JString::upcase(SEPARATOR);
-	strcpy(q, StorageTableShare::getDefaultRoot());	
+	strcpy(q, StorageTableShare::getDefaultRoot());
 	StorageDatabase *storageDatabase = getStorageDatabase(dbName, pathname);
 	databaseDropped(storageDatabase, NULL);
 
@@ -893,7 +891,7 @@ int StorageHandler::dropDatabase(const c
 
 	storageDatabase->release();
 	***/
-	
+
 	return 0;
 }
 
@@ -901,7 +899,7 @@ void StorageHandler::getIOInfo(InfoTable
 {
 	Sync sync(&hashSyncObject, "StorageHandler::getIOInfo");
 	sync.lock(Shared);
-	
+
 	for (StorageDatabase *storageDatabase = databaseList; storageDatabase; storageDatabase =
storageDatabase->next)
 		storageDatabase->getIOInfo(infoTable);
 }
@@ -930,7 +928,7 @@ void StorageHandler::getTransactionInfo(
 {
 	Sync sync(&hashSyncObject, "StorageHandler::getTransactionInfo");
 	sync.lock(Shared);
-	
+
 	for (StorageDatabase *storageDatabase = databaseList; storageDatabase; storageDatabase =
storageDatabase->next)
 		storageDatabase->getTransactionInfo(infoTable);
 }
@@ -939,7 +937,7 @@ void StorageHandler::getSerialLogInfo(In
 {
 	Sync sync(&hashSyncObject, "StorageHandler::getSerialLogInfo");
 	sync.lock(Shared);
-	
+
 	for (StorageDatabase *storageDatabase = databaseList; storageDatabase; storageDatabase =
storageDatabase->next)
 		storageDatabase->getSerialLogInfo(infoTable);
 }
@@ -953,7 +951,7 @@ void StorageHandler::getTransactionSumma
 {
 	Sync sync(&hashSyncObject, "StorageHandler::getTransactionSummaryInfo");
 	sync.lock(Shared);
-	
+
 	for (StorageDatabase *storageDatabase = databaseList; storageDatabase; storageDatabase =
storageDatabase->next)
 		storageDatabase->getTransactionSummaryInfo(infoTable);
 }
@@ -962,7 +960,7 @@ void StorageHandler::getTableSpaceInfo(I
 {
 	Sync sync(&hashSyncObject, "StorageHandler::getTableSpaceInfo");
 	sync.lock(Shared);
-	
+
 	for (StorageDatabase *storageDatabase = databaseList; storageDatabase; storageDatabase =
storageDatabase->next)
 		storageDatabase->getTableSpaceInfo(infoTable);
 }
@@ -971,7 +969,7 @@ void StorageHandler::getTableSpaceFilesI
 {
 	Sync sync(&hashSyncObject, "StorageHandler::getTableSpaceFilesInfo");
 	sync.lock(Shared);
-	
+
 	for (StorageDatabase *storageDatabase = databaseList; storageDatabase; storageDatabase =
storageDatabase->next)
 		storageDatabase->getTableSpaceFilesInfo(infoTable);
 }
@@ -980,16 +978,16 @@ void StorageHandler::initialize(void)
 {
 	if (initialized)
 		return;
-	
+
 	Sync sync(&syncObject, "StorageHandler::initialize");
 	sync.lock(Exclusive);
-	
+
 	if (initialized)
 		return;
-		
+
 	initialized = true;
 	defaultDatabase = getStorageDatabase(MASTER_NAME, MASTER_PATH);
-	
+
 	try
 		{
 		defaultDatabase->getOpenConnection();
@@ -1001,7 +999,7 @@ void StorageHandler::initialize(void)
 		{
 		int err = e.getSqlcode();
 
-		// If got one of following errors, just rethrow. No point in 
+		// If got one of following errors, just rethrow. No point in
 		// trying to create database.
 		if (err != OPEN_MASTER_ERROR)
 			throw;
@@ -1046,14 +1044,14 @@ void StorageHandler::createDatabase(void
 void StorageHandler::dropTempTables(void)
 {
 	Statement *statement = dictionaryConnection->createStatement();
-	
+
 	try
 		{
 		PStatement select = dictionaryConnection->prepareStatement(
 			"select schema,tablename from system.tables where tablespace='" TEMPORARY_TABLESPACE
"'");
 		RSet resultSet = select->executeQuery();
 		bool hit = false;
-		
+
 		while (resultSet->next())
 			{
 			CmdGen gen;
@@ -1061,14 +1059,14 @@ void StorageHandler::dropTempTables(void
 			statement->executeUpdate(gen.getString());
 			hit = true;
 			}
-		
+
 		//if (hit)
 			//statement->executeUpdate(dropTempSpace);
 		}
 	catch(...)
 		{
 		}
-	
+
 	try
 		{
 		statement->executeUpdate(createTempSpace);
@@ -1077,7 +1075,7 @@ void StorageHandler::dropTempTables(void
 		{
 		Log::log("Can't create temporary tablespace: %s\n", exception.getText());
 		}
-	
+
 	statement->close();
 }
 
@@ -1118,7 +1116,7 @@ void StorageHandler::cleanFileName(const
 	char *q = filename;
 	char *end = filename + filenameLength - 1;
 	filename[0] = 0;
-	
+
 	for (const char *p = pathname; q < end && (c = *p++); prior = c)
 		if (c != SEPARATOR || c != prior)
 			*q++ = c;
@@ -1136,7 +1134,7 @@ void StorageHandler::getFalconVersionInf
 
 int StorageHandler::recoverGetNextLimbo(int xidLength, unsigned char* xid)
 	{
-	if (!defaultDatabase)	
+	if (!defaultDatabase)
 		initialize();
 
 	if (Connection* connection = dictionaryConnection)
@@ -1149,14 +1147,14 @@ const char* StorageHandler::normalizeNam
 {
 	char *q = buffer;
 	char *end = buffer + bufferSize - 1;
-	
+
 	for (const char *p = name; *p && q < end; ++p)
 		if (charTable[(unsigned char)*p])
 			return name;
 		else
 			*q++ = UPPER(*p);
-	
+
 	*q = 0;
-	
+
 	return buffer;
 }