bk commit into 6.0 tree (klewis:1.2633) BUG#35692

[klewis]

Below is the list of changes that have just been committed into a local
6.0 repository of klewis.  When klewis does a push these changes
will be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2008-04-21 21:12:08-05:00, klewis@klewis-mysql. +8 -0
  Bug#35692 - Use syncPrior in RecordVersion::fetchVersion.
  syncPrior is not needed in Table::rollbackRecord, deleteRecord
  nor validateAndInsert.
  Nothing need be returned from RecordVersion::rollback

  storage/falcon/Record.cpp@stripped, 2008-04-21 21:11:21-05:00, klewis@klewis-mysql. +5 -0
    Bug#35692 - Use syncPrior in RecordVersion::fetchVersion

  storage/falcon/Record.h@stripped, 2008-04-21 21:11:26-05:00, klewis@klewis-mysql. +2 -1
    Bug#35692 - Use syncPrior in RecordVersion::fetchVersion

  storage/falcon/RecordVersion.cpp@stripped, 2008-04-21 21:11:29-05:00, klewis@klewis-mysql.
+14 -7
    Bug#35692 - Use syncPrior in RecordVersion::fetchVersion
    Nothing need be returned from RecordVersion::rollback

  storage/falcon/RecordVersion.h@stripped, 2008-04-21 21:11:32-05:00, klewis@klewis-mysql. +3
-2
    Bug#35692 - Use syncPrior in RecordVersion::fetchVersion
    Nothing need be returned from RecordVersion::rollback

  storage/falcon/SyncObject.cpp@stripped, 2008-04-21 21:11:37-05:00, klewis@klewis-mysql. +0
-1
    Merge cleanup

  storage/falcon/Table.cpp@stripped, 2008-04-21 21:11:40-05:00, klewis@klewis-mysql. +13 -25
    Bug#35692 - syncPrior is not needed in rollbackRecord, deleteRecord
    nor validateAndInsert.
    Nothing need be returned from RecordVersion::rollback

  storage/falcon/Table.h@stripped, 2008-04-21 21:11:42-05:00, klewis@klewis-mysql. +1 -1
    Nothing need be returned from RecordVersion::rollback

  storage/falcon/TableSpaceManager.cpp@stripped, 2008-04-21 21:11:45-05:00,
klewis@klewis-mysql. +6 -6
    cleanup

diff -Nrup a/storage/falcon/Record.cpp b/storage/falcon/Record.cpp
--- a/storage/falcon/Record.cpp	2008-04-09 09:51:44 -05:00
+++ b/storage/falcon/Record.cpp	2008-04-21 21:11:21 -05:00
@@ -310,6 +310,11 @@ Record* Record::fetchVersion(Transaction
 	return this;
 }
 
+Record* Record::fetchVersionRecursive(Transaction * transaction)
+{
+	return this;
+}
+
 void Record::getValue(int fieldId, Value * value)
 {
 	getRawValue(fieldId, value);
diff -Nrup a/storage/falcon/Record.h b/storage/falcon/Record.h
--- a/storage/falcon/Record.h	2008-04-09 09:51:48 -05:00
+++ b/storage/falcon/Record.h	2008-04-21 21:11:26 -05:00
@@ -75,7 +75,8 @@ public:
 	virtual TransId	getTransactionId();
 	virtual int		getSavePointId();
 	virtual void	setSuperceded (bool flag);
-	virtual Record*	fetchVersion (Transaction *transaction);
+	virtual Record*	fetchVersion (Transaction * transaction);
+	virtual Record*	fetchVersionRecursive (Transaction *transaction);
 	virtual bool	scavenge(RecordScavenge *recordScavenge, LockType lockType);
 	virtual void	scavenge(TransId targetTransactionId, int oldestActiveSavePointId);
 	virtual bool	isVersion();
diff -Nrup a/storage/falcon/RecordVersion.cpp b/storage/falcon/RecordVersion.cpp
--- a/storage/falcon/RecordVersion.cpp	2008-04-11 21:22:43 -05:00
+++ b/storage/falcon/RecordVersion.cpp	2008-04-21 21:11:29 -05:00
@@ -120,6 +120,15 @@ Record* RecordVersion::releaseNonRecursi
 
 Record* RecordVersion::fetchVersion(Transaction * trans)
 {
+	Sync syncPrior(format->table->getSyncPrior(this), "RecordVersion::fetchVersion");
+    if (priorVersion)
+        syncPrior.lock(Shared);
+
+	return fetchVersionRecursive(trans);
+}
+
+Record* RecordVersion::fetchVersionRecursive(Transaction * trans)
+{
 	// Unless the record is at least as old as the transaction, it's not for us
 
 	Transaction *recTransaction = transaction;
@@ -144,15 +153,13 @@ Record* RecordVersion::fetchVersion(Tran
 	if (!priorVersion)
 		return NULL;
 		
-	return priorVersion->fetchVersion(trans);
+	return priorVersion->fetchVersionRecursive(trans);
 }
 
-Record* RecordVersion::rollback(Transaction *transaction)
+void RecordVersion::rollback(Transaction *transaction)
 {
-	if (superceded)
-		return NULL;
-
-	return format->table->rollbackRecord (this, transaction);
+	if (!superceded)
+		format->table->rollbackRecord (this, transaction);
 }
 
 bool RecordVersion::isVersion()
@@ -238,7 +245,7 @@ void RecordVersion::scavenge(TransId tar
 	if (!priorVersion)
 		return;
 
-	Sync syncPrior(getSyncPrior(), "RecordVersion::scavenge(2)");
+	Sync syncPrior(getSyncPrior(), "RecordVersion::scavenge()-savepoint");
 	syncPrior.lock(Shared);
 	
 	Record *rec = priorVersion;
diff -Nrup a/storage/falcon/RecordVersion.h b/storage/falcon/RecordVersion.h
--- a/storage/falcon/RecordVersion.h	2008-04-09 09:51:56 -05:00
+++ b/storage/falcon/RecordVersion.h	2008-04-21 21:11:32 -05:00
@@ -45,8 +45,9 @@ public:
 	virtual bool		scavenge(RecordScavenge *recordScavenge, LockType lockType);
 	virtual void		scavenge(TransId targetTransactionId, int oldestActiveSavePoint);
 	virtual bool		isVersion();
-	virtual Record*		rollback(Transaction *transaction);
-	virtual Record*		fetchVersion (Transaction *transaction);
+	virtual void		rollback(Transaction *transaction);
+	virtual Record*		fetchVersion (Transaction * trans);
+	virtual Record*		fetchVersionRecursive (Transaction *transaction);
 	virtual Record*		releaseNonRecursive();
 	virtual Record*		clearPriorVersion(void);
 	virtual void		setPriorVersion (Record *oldVersion);
diff -Nrup a/storage/falcon/SyncObject.cpp b/storage/falcon/SyncObject.cpp
--- a/storage/falcon/SyncObject.cpp	2008-04-20 09:10:18 -05:00
+++ b/storage/falcon/SyncObject.cpp	2008-04-21 21:11:37 -05:00
@@ -20,7 +20,6 @@
 #include <stdio.h>
 #include <string.h>
 #include <memory.h>
-#include <string.h>
 
 #ifdef _WIN32
 #include <windows.h>
diff -Nrup a/storage/falcon/Table.cpp b/storage/falcon/Table.cpp
--- a/storage/falcon/Table.cpp	2008-04-11 12:34:16 -05:00
+++ b/storage/falcon/Table.cpp	2008-04-21 21:11:40 -05:00
@@ -961,7 +961,7 @@ Record* Table::backlogFetch(int32 record
 	return NULL;	
 }
 
-Record* Table::rollbackRecord(RecordVersion * recordToRollback, Transaction *transaction)
+void Table::rollbackRecord(RecordVersion * recordToRollback, Transaction *transaction)
 {
 #ifdef CHECK_RECORD_ACTIVITY
 	recordToRollback->active = false;
@@ -970,15 +970,11 @@ Record* Table::rollbackRecord(RecordVers
 	int priorState = recordToRollback->state;
 	recordToRollback->state = recRollback;
 
-	// Hold syncPrior long enough to get prior version and addRef. Unlock before insert().
-	
-	Sync syncPrior(getSyncPrior(recordToRollback), "Table::rollbackRecord");
-
-	if (!transaction->systemTransaction)
-		syncPrior.lock(Shared);
-
 	// Find the record that will become the current version.
-	
+	// syncPrior is not needed here. No other thread can change this
+	// priorVersion now. Changing the base record is protected by
+	// RecordLeaf::syncObject
+
 	Record *priorRecord = recordToRollback->getPriorVersion();
 
 	if (priorRecord)
@@ -986,16 +982,13 @@ Record* Table::rollbackRecord(RecordVers
 		priorRecord->addRef();
 		priorRecord->setSuperceded(false);
 		}
-	
-	if (!transaction->systemTransaction)
-		syncPrior.unlock();
 
 	// Replace the current version of this record.
 
 	if (!insert(priorRecord, recordToRollback, recordToRollback->recordNumber))
 		{
 		if (priorRecord == NULL && priorState == recDeleted)
-			return priorRecord;
+			return;
 			
 		recordToRollback->printRecord("Table::rollbackRecord");
 		insert(priorRecord, recordToRollback, recordToRollback->recordNumber);
@@ -1012,8 +1005,6 @@ Record* Table::rollbackRecord(RecordVers
 	
 	if (priorRecord)
 		priorRecord->release();
-			
-	return priorRecord;
 }
 
 void Table::addFormat(Format * format)
@@ -1417,9 +1408,7 @@ void Table::deleteRecord(Transaction * t
 	database->preUpdate();
 	Sync scavenge(&syncScavenge, "Table::deleteRecord");
 
-	Sync syncPrior(getSyncPrior(orgRecord), "Table::deleteRecord");
-	syncPrior.lock(Shared);
-	
+    // syncPrior is not needed here.  It is handled in fetchVersion()
 	Record *candidate = fetch(orgRecord->recordNumber);
 	checkAncestor(candidate, orgRecord);
 	RecordVersion *record;
@@ -3273,17 +3262,18 @@ JString Table::getPrimaryKeyName(void)
 void Table::validateAndInsert(Transaction *transaction, RecordVersion *record)
 {
 	Sync syncTable(&syncObject, "Table::validateAndInsert");
-	Sync syncPrior(getSyncPrior(record), "Table::validateAndInsert");
-	
+
+	// Do not need syncPrior here since this is a new record.
+	// No other thread can see this records priorVersion pointer.
+
 	Record *prior = record->getPriorVersion();
-	
+
 	for (int n = 0; n < 10; ++n)
 		{
 		if (prior)
 			{
 			syncTable.lock(Exclusive);
 			Record *current = fetch(record->recordNumber);
-			syncPrior.lock(Shared);
 
 			if (current)
 				{
@@ -3297,13 +3287,11 @@ void Table::validateAndInsert(Transactio
 
 					TransId transId = current->getTransactionId();
 					current->release();
-					syncPrior.unlock();
 					syncTable.unlock();
 
 					if (transaction->waitForTransaction(transId))
 						{
 						current = fetch(record->recordNumber);
-						syncPrior.lock(Shared);
 						
 						if (current == prior)
 							current->release();
@@ -3747,7 +3735,7 @@ int32 Table::backlogRecord(RecordVersion
 
 void Table::deleteRecordBacklog(int32 recordNumber)
 {
-	Sync sync(&syncObject, "Table::rollbackRecord");
+	Sync sync(&syncObject, "Table::deleteRecordBacklog");
 	sync.lock(Shared);
 	int32 backlogId = backloggedRecords->get(recordNumber);
 	
diff -Nrup a/storage/falcon/Table.h b/storage/falcon/Table.h
--- a/storage/falcon/Table.h	2008-04-09 03:23:49 -05:00
+++ b/storage/falcon/Table.h	2008-04-21 21:11:42 -05:00
@@ -163,7 +163,7 @@ public:
 	void		makeSearchable (Field *field, Transaction *transaction);
 	int32		getBlobId (Value *value, int32 oldId, bool cloneFlag, Transaction *transaction);
 	void		addFormat (Format *format);
-	Record*		rollbackRecord (RecordVersion *recordVersion, Transaction *transaction);
+	void		rollbackRecord (RecordVersion *recordVersion, Transaction *transaction);
 	Record*		fetch (int32 recordNumber);
 	void		init(int id, const char *schema, const char *tableName, TableSpace *tblSpace);
 	void		loadFields();
diff -Nrup a/storage/falcon/TableSpaceManager.cpp b/storage/falcon/TableSpaceManager.cpp
--- a/storage/falcon/TableSpaceManager.cpp	2008-04-12 22:46:09 -05:00
+++ b/storage/falcon/TableSpaceManager.cpp	2008-04-21 21:11:45 -05:00
@@ -116,12 +116,12 @@ TableSpace* TableSpaceManager::findTable
 		
 		TableSpaceInit tsInit;
 		/***
-		tsInit.initialSize	= resultSet->getLong(4);
-		tsInit.extentSize	= resultSet->getLong(5);
-		tsInit.autoExtendSize = resultSet->getLong(6);
-		tsInit.maxSize		= resultSet->getLong(7);
-		tsInit.nodegroup	= resultSet->getInt(8);
-		tsInit.wait			= resultSet->getInt(9);
+		tsInit.initialSize	= resultSet->getLong(n++);
+		tsInit.extentSize	= resultSet->getLong(n++);
+		tsInit.autoExtendSize = resultSet->getLong(n++);
+		tsInit.maxSize		= resultSet->getLong(n++);
+		tsInit.nodegroup	= resultSet->getInt(n++);
+		tsInit.wait			= resultSet->getInt(n++);
 		***/
 		tsInit.comment		= resultSet->getString(n++);