Below is the list of changes that have just been committed into a local
6.0 repository of cpowers. When cpowers 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, 2007-11-12 17:13:28-06:00, chris@stripped +20 -0
Bug#22173, "TRUNCATE does not reset auto_increment counter"
- Implemented delete_all_rows() in handler.
- Added fast truncate to StorageTable, StorageTableShare, StorageDatabase, Database, and Transaction classes.
- Added Sequence::recreate() to drop and add autoincrement sequence.
storage/falcon/Database.cpp@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +23 -0
Added truncateTable()
storage/falcon/Database.h@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +1 -0
Added truncateTable()
storage/falcon/Sequence.cpp@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +5 -0
Added recreate()
storage/falcon/Sequence.h@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +1 -0
Added recreate()
storage/falcon/SequenceManager.cpp@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +9 -0
Added recreateSequence()
storage/falcon/SequenceManager.h@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +1 -0
Added recreateSequence()
storage/falcon/StorageDatabase.cpp@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +15 -1
Added truncateTable()
storage/falcon/StorageDatabase.h@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +1 -0
Added truncateTable()
storage/falcon/StorageTable.cpp@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +7 -0
Added truncateTable()
storage/falcon/StorageTable.h@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +1 -0
Added truncateTable()
storage/falcon/StorageTableShare.cpp@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +11 -0
Added truncateTable()
storage/falcon/StorageTableShare.h@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +1 -0
Added truncateTable()
storage/falcon/Table.cpp@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +66 -2
Added truncate()
Added force option to rebuildIndexes()
storage/falcon/Table.h@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +2 -1
Added truncate()
Added force option to rebuildIndexes()
storage/falcon/Transaction.cpp@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +16 -0
Added truncateTable().
storage/falcon/Transaction.h@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +1 -0
Added truncateTable().
storage/falcon/TransactionManager.cpp@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +11 -0
Added truncateTable().
storage/falcon/TransactionManager.h@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +1 -0
Added truncateTable().
storage/falcon/ha_falcon.cpp@stripped, 2007-11-12 17:13:25-06:00, chris@stripped +28 -3
Implemented delete_all_rows()
storage/falcon/ha_falcon.h@stripped, 2007-11-12 17:13:26-06:00, chris@stripped +1 -0
Implemented delete_all_rows()
diff -Nrup a/storage/falcon/Database.cpp b/storage/falcon/Database.cpp
--- a/storage/falcon/Database.cpp 2007-11-05 15:11:20 -06:00
+++ b/storage/falcon/Database.cpp 2007-11-12 17:13:25 -06:00
@@ -75,6 +75,7 @@
#include "LogStream.h"
#include "SyncTest.h"
#include "PriorityScheduler.h"
+#include "Sequence.h"
#ifndef STORAGE_ENGINE
#include "Applications.h"
@@ -1406,6 +1407,28 @@ void Database::dropTable(Table * table,
delete table;
}
+void Database::truncateTable(Table *table, Transaction *transaction)
+{
+ Sync scavenge(&table->syncScavenge, "Database::truncateTable");
+
+ table->checkDrop();
+
+ // Check for records in active transactions
+
+ if (hasUncommittedRecords(table, transaction))
+ throw SQLError(UNCOMMITTED_UPDATES, "table %s.%s has uncommitted updates and cannot be truncated",
+ table->schemaName, table->name);
+
+ scavenge.lock(Shared);
+
+ // Purge records out of committed transactions
+
+ transactionManager->truncateTable(table, transaction);
+
+ // Recreate data/blob sections and indexes
+
+ table->truncate(transaction);
+}
void Database::addTable(Table * table)
{
diff -Nrup a/storage/falcon/Database.h b/storage/falcon/Database.h
--- a/storage/falcon/Database.h 2007-11-02 11:54:37 -05:00
+++ b/storage/falcon/Database.h 2007-11-12 17:13:25 -06:00
@@ -169,6 +169,7 @@ public:
void shutdown();
void execute (const char *sql);
void addTable (Table *table);
+ void truncateTable(Table *table, Transaction *transaction);
void dropTable (Table *table, Transaction *transaction);
void flushInversion(Transaction *transaction);
bool matches (const char *fileName);
diff -Nrup a/storage/falcon/Sequence.cpp b/storage/falcon/Sequence.cpp
--- a/storage/falcon/Sequence.cpp 2007-09-20 10:42:33 -05:00
+++ b/storage/falcon/Sequence.cpp 2007-11-12 17:13:25 -06:00
@@ -60,3 +60,8 @@ void Sequence::rename(const char* newNam
{
database->sequenceManager->renameSequence(this, newName);
}
+
+Sequence* Sequence::recreate(void)
+{
+ return database->sequenceManager->recreateSequence(this);
+}
diff -Nrup a/storage/falcon/Sequence.h b/storage/falcon/Sequence.h
--- a/storage/falcon/Sequence.h 2007-09-20 10:42:33 -05:00
+++ b/storage/falcon/Sequence.h 2007-11-12 17:13:25 -06:00
@@ -45,6 +45,7 @@ public:
Schema *schema;
Database *database;
void rename(const char* newName);
+ Sequence *recreate(void);
};
#endif // !defined(AFX_SEQUENCE_H__52A2DA15_7937_11D4_98F0_0000C01D2301__INCLUDED_)
diff -Nrup a/storage/falcon/SequenceManager.cpp b/storage/falcon/SequenceManager.cpp
--- a/storage/falcon/SequenceManager.cpp 2007-10-11 07:12:01 -05:00
+++ b/storage/falcon/SequenceManager.cpp 2007-11-12 17:13:25 -06:00
@@ -139,6 +139,15 @@ Sequence* SequenceManager::createSequenc
return sequence;
}
+Sequence* SequenceManager::recreateSequence(Sequence *oldSequence)
+{
+ const char *schemaName = database->getSymbol(oldSequence->schemaName);
+ const char *sequenceName = database->getSymbol(oldSequence->name);
+
+ deleteSequence(schemaName, sequenceName);
+ return createSequence(schemaName, sequenceName, 0);
+}
+
void SequenceManager::deleteSequence(const char *schema, const char *name)
{
Sync sync (&database->syncSysConnection, "SequenceManager::deleteSequence");
diff -Nrup a/storage/falcon/SequenceManager.h b/storage/falcon/SequenceManager.h
--- a/storage/falcon/SequenceManager.h 2007-09-20 10:42:33 -05:00
+++ b/storage/falcon/SequenceManager.h 2007-11-12 17:13:25 -06:00
@@ -48,6 +48,7 @@ protected:
SyncObject syncObject;
public:
void renameSequence(Sequence* sequence, const char* newName);
+ Sequence *recreateSequence(Sequence *oldSequence);
};
#endif // !defined(AFX_SEQUENCEMANAGER_H__52A2DA14_7937_11D4_98F0_0000C01D2301__INCLUDED_)
diff -Nrup a/storage/falcon/StorageDatabase.cpp b/storage/falcon/StorageDatabase.cpp
--- a/storage/falcon/StorageDatabase.cpp 2007-11-03 00:33:55 -05:00
+++ b/storage/falcon/StorageDatabase.cpp 2007-11-12 17:13:25 -06:00
@@ -520,6 +520,21 @@ int StorageDatabase::deleteTable(Storage
return res;
}
+int StorageDatabase::truncateTable(StorageConnection* storageConnection, StorageTableShare *tableShare)
+{
+ Connection *connection = storageConnection->connection;
+ Transaction *transaction = connection->transaction;
+ Database *database = connection->database;
+ Sequence *sequence = tableShare->sequence;
+
+ database->truncateTable(tableShare->table, transaction);
+
+ if (sequence)
+ sequence = sequence->recreate();
+
+ return 0;
+}
+
int StorageDatabase::deleteRow(StorageConnection *storageConnection, Table* table, int recordNumber)
{
Connection *connection = storageConnection->connection;
@@ -592,7 +607,6 @@ int StorageDatabase::updateRow(StorageCo
return 0;
}
-
int StorageDatabase::createIndex(StorageConnection *storageConnection, Table* table, const char* indexName, const char* sql)
{
diff -Nrup a/storage/falcon/StorageDatabase.h b/storage/falcon/StorageDatabase.h
--- a/storage/falcon/StorageDatabase.h 2007-09-20 10:42:40 -05:00
+++ b/storage/falcon/StorageDatabase.h 2007-11-12 17:13:25 -06:00
@@ -58,6 +58,7 @@ public:
int savepointRelease(Connection* connection, int savePoint);
int savepointRollback(Connection* connection, int savePoint);
int deleteTable(StorageConnection* storageConnection,StorageTableShare *tableShare);
+ int truncateTable(StorageConnection* storageConnection, StorageTableShare *tableShare);
int createIndex(StorageConnection *storageConnection, Table* table, StorageIndexDesc* indexDesc);
int renameTable(StorageConnection* storageConnection, Table* table, const char* newName, const char *schemaName);
Bitmap* indexScan(Index* index, StorageKey *lower, StorageKey *upper, int searchFlags, StorageConnection* storageConnection, Bitmap *bitmap);
diff -Nrup a/storage/falcon/StorageTable.cpp b/storage/falcon/StorageTable.cpp
--- a/storage/falcon/StorageTable.cpp 2007-11-03 00:33:56 -05:00
+++ b/storage/falcon/StorageTable.cpp 2007-11-12 17:13:25 -06:00
@@ -81,6 +81,13 @@ int StorageTable::deleteTable(void)
return ret;
}
+int StorageTable::truncateTable(void)
+{
+ int ret = share->truncateTable(storageConnection);
+
+ return ret;
+}
+
int StorageTable::insert(void)
{
try
diff -Nrup a/storage/falcon/StorageTable.h b/storage/falcon/StorageTable.h
--- a/storage/falcon/StorageTable.h 2007-10-31 01:41:17 -05:00
+++ b/storage/falcon/StorageTable.h 2007-11-12 17:13:25 -06:00
@@ -68,6 +68,7 @@ public:
virtual int open(void);
virtual int deleteTable(void);
virtual int deleteRow(int recordNumber);
+ virtual int truncateTable(void);
virtual int setIndex(int numberIndexes, int indexId, StorageIndexDesc* storageIndex);
virtual int indexScan();
virtual int setIndex(int indexId);
diff -Nrup a/storage/falcon/StorageTableShare.cpp b/storage/falcon/StorageTableShare.cpp
--- a/storage/falcon/StorageTableShare.cpp 2007-10-30 16:24:58 -05:00
+++ b/storage/falcon/StorageTableShare.cpp 2007-11-12 17:13:25 -06:00
@@ -142,6 +142,17 @@ int StorageTableShare::deleteTable(Stora
return res;
}
+int StorageTableShare::truncateTable(StorageConnection *storageConnection)
+{
+ int res = storageDatabase->truncateTable(storageConnection, this);
+
+ if (res == 0 || res == StorageErrorTableNotFound)
+ {
+ }
+
+ return res;
+}
+
void StorageTableShare::cleanupFieldName(const char* name, char* buffer, int bufferLength)
{
char *q = buffer;
diff -Nrup a/storage/falcon/StorageTableShare.h b/storage/falcon/StorageTableShare.h
--- a/storage/falcon/StorageTableShare.h 2007-11-03 00:33:58 -05:00
+++ b/storage/falcon/StorageTableShare.h 2007-11-12 17:13:25 -06:00
@@ -106,6 +106,7 @@ public:
int getIndexId(const char* schemaName, const char* indexName);
int create(StorageConnection *storageConnection, const char* sql, int64 autoIncrementValue);
int deleteTable(StorageConnection *storageConnection);
+ int truncateTable(StorageConnection *storageConnection);
void load(void);
void registerTable(void);
void unRegisterTable(void);
diff -Nrup a/storage/falcon/Table.cpp b/storage/falcon/Table.cpp
--- a/storage/falcon/Table.cpp 2007-11-09 11:27:37 -06:00
+++ b/storage/falcon/Table.cpp 2007-11-12 17:13:25 -06:00
@@ -1453,6 +1453,70 @@ void Table::drop(Transaction *transactio
database->commitSystemTransaction();
}
+void Table::truncate(Transaction *transaction)
+{
+ // Absolutely no access until truncate complete
+
+ Sync syncObj(&syncObject, "Table::truncate");
+ syncObj.lock(Exclusive);
+
+ // Ensure control of system transaction commit
+
+ Sync syncConnection(&database->syncSysConnection, "Table::truncate");
+ syncConnection.lock(Shared);
+
+ // Keep scavenger out of the way
+
+ Sync syncScavenger(&syncScavenge, "Table::truncate");
+ syncScavenger.lock(Shared);
+
+ Transaction *sysTransaction = database->getSystemTransaction();
+
+ // Delete data and blob sections
+
+ expunge(sysTransaction);
+
+ // Recreate data and blob sections
+
+ dataSectionId = dbb->createSection(TRANSACTION_ID(sysTransaction));
+ blobSectionId = dbb->createSection(TRANSACTION_ID(sysTransaction));
+
+ // Update system.tables with new section ids
+
+ PreparedStatement *statement = database->prepareStatement("update Tables set dataSection=?, blobSection=? where tableId=?");
+ statement->setInt(1, dataSectionId);
+ statement->setInt(2, blobSectionId);
+ statement->setInt(3, tableId);
+ statement->executeUpdate();
+ statement->close();
+
+ // Commit the physical and system changes
+
+ syncConnection.unlock();
+ database->commitSystemTransaction();
+
+ if (records)
+ {
+ delete records;
+ records = NULL;
+ }
+
+ // Rebuild indexes
+
+ rebuildIndexes(sysTransaction, true);
+
+ // Reset select Table attributes
+
+ priorCardinality = cardinality; // forces update to system tables during scavenge
+ cardinality = 0;
+ ageGroup = database->currentGeneration;
+ emptySections->clear();
+ recordBitmap->clear();
+ debugThawedRecords = 0;
+ debugThawedBytes = 0;
+ alterIsActive = false;
+}
+
void Table::checkNullable(Record * record)
{
Value value;
@@ -2609,10 +2673,10 @@ void Table::collationChanged(Field *fiel
END_FOR;
}
-void Table::rebuildIndexes(Transaction *transaction)
+void Table::rebuildIndexes(Transaction *transaction, bool force)
{
FOR_INDEXES(index, this);
- if (index->rebuild)
+ if (index->rebuild || force)
{
index->rebuild = false;
rebuildIndex(index, transaction);
diff -Nrup a/storage/falcon/Table.h b/storage/falcon/Table.h
--- a/storage/falcon/Table.h 2007-10-31 01:41:22 -05:00
+++ b/storage/falcon/Table.h 2007-11-12 17:13:25 -06:00
@@ -92,7 +92,7 @@ public:
void insertView(Transaction *transaction, int count, Field **fieldVector, Value **values);
void bind (Table *table);
void clearIndexesRebuild();
- void rebuildIndexes (Transaction *transaction);
+ void rebuildIndexes (Transaction *transaction, bool force = false);
void collationChanged (Field *field);
void validateBlobs (int optionMask);
void cleanupRecords(RecordScavenge *recordScavenge);
@@ -148,6 +148,7 @@ public:
void addField (Field *field);
void checkNullable (Record *record);
virtual void drop(Transaction *transaction);
+ virtual void truncate(Transaction *transaction);
void updateInversion (Record *record, Transaction *transaction);
int getFieldId (const char *name);
ForeignKey* findForeignKey (ForeignKey *key);
diff -Nrup a/storage/falcon/Transaction.cpp b/storage/falcon/Transaction.cpp
--- a/storage/falcon/Transaction.cpp 2007-10-31 01:41:24 -05:00
+++ b/storage/falcon/Transaction.cpp 2007-11-12 17:13:25 -06:00
@@ -863,6 +863,22 @@ void Transaction::dropTable(Table* table
ptr = &rec->nextInTrans;
}
+void Transaction::truncateTable(Table* table)
+{
+ Sync sync(&syncIndexes, "Transaction::truncateTable");
+ sync.lock(Exclusive);
+
+ releaseDeferredIndexes(table);
+
+ // Keep exclusive lock to avoid race condition with writeComplete
+
+ for (RecordVersion **ptr = &firstRecord, *rec; (rec = *ptr);)
+ if (rec->format->table == table)
+ removeRecord(rec);
+ else
+ ptr = &rec->nextInTrans;
+}
+
bool Transaction::hasUncommittedRecords(Table* table)
{
for (RecordVersion *rec = firstRecord; rec; rec = rec->nextInTrans)
diff -Nrup a/storage/falcon/Transaction.h b/storage/falcon/Transaction.h
--- a/storage/falcon/Transaction.h 2007-10-31 01:41:26 -05:00
+++ b/storage/falcon/Transaction.h 2007-11-12 17:13:25 -06:00
@@ -108,6 +108,7 @@ public:
void waitForTransaction();
bool waitForTransaction (TransId transId);
void dropTable(Table* table);
+ void truncateTable(Table* table);
bool hasUncommittedRecords(Table* table);
void writeComplete(void);
void releaseDependency(void);
diff -Nrup a/storage/falcon/TransactionManager.cpp b/storage/falcon/TransactionManager.cpp
--- a/storage/falcon/TransactionManager.cpp 2007-11-10 13:12:54 -06:00
+++ b/storage/falcon/TransactionManager.cpp 2007-11-12 17:13:25 -06:00
@@ -141,6 +141,17 @@ void TransactionManager::dropTable(Table
committedTrans.unlock();
}
+void TransactionManager::truncateTable(Table* table, Transaction* transaction)
+{
+ Sync committedTrans (&committedTransactions.syncObject, "TransactionManager::truncateTable");
+ committedTrans.lock (Shared);
+
+ for (Transaction *trans = committedTransactions.first; trans; trans = trans->next)
+ trans->truncateTable(table);
+
+ committedTrans.unlock();
+}
+
bool TransactionManager::hasUncommittedRecords(Table* table, Transaction* transaction)
{
Sync syncTrans (&activeTransactions.syncObject, "TransactionManager::hasUncommittedRecords");
diff -Nrup a/storage/falcon/TransactionManager.h b/storage/falcon/TransactionManager.h
--- a/storage/falcon/TransactionManager.h 2007-09-25 00:14:42 -05:00
+++ b/storage/falcon/TransactionManager.h 2007-11-12 17:13:25 -06:00
@@ -33,6 +33,7 @@ public:
TransId findOldestActive();
Transaction* startTransaction(Connection* connection);
void dropTable(Table* table, Transaction* transaction);
+ void truncateTable(Table* table, Transaction* transaction);
bool hasUncommittedRecords(Table* table, Transaction* transaction);
void commitByXid(int xidLength, const UCHAR* xid);
void rollbackByXid(int xidLength, const UCHAR* xid);
diff -Nrup a/storage/falcon/ha_falcon.cpp b/storage/falcon/ha_falcon.cpp
--- a/storage/falcon/ha_falcon.cpp 2007-11-10 13:29:52 -06:00
+++ b/storage/falcon/ha_falcon.cpp 2007-11-12 17:13:25 -06:00
@@ -812,7 +812,6 @@ THR_LOCK_DATA **StorageInterface::store_
DBUG_RETURN(to);
}
-
int StorageInterface::delete_table(const char *tableName)
{
DBUG_ENTER("StorageInterface::delete_table");
@@ -859,13 +858,40 @@ int StorageInterface::delete_table(const
DBUG_RETURN(error(res));
}
+int StorageInterface::delete_all_rows()
+{
+ DBUG_ENTER("StorageInterface::delete_all_rows");
+
+ int ret = 0;
+ struct st_table_share *tableShare = table_share;
+ struct st_table *tableObj = table;
+ const char *tableName = tableShare->normalized_path.str;
+
+ if (!mySqlThread)
+ mySqlThread = current_thd;
+
+ if (!storageShare)
+ if ( !(storageShare = storageHandler->preDeleteTable(tableName)) )
+ DBUG_RETURN(0);
+
+ if (!storageConnection)
+ if ( !(storageConnection = storageHandler->getStorageConnection(storageShare, mySqlThread, mySqlThread->thread_id, OpenDatabase)) )
+ DBUG_RETURN(0);
+
+ if (!storageTable)
+ storageTable = storageConnection->getStorageTable(storageShare);
+
+ storageTable->truncateTable();
+
+ DBUG_RETURN(ret);
+}
+
uint StorageInterface::max_supported_keys(void) const
{
DBUG_ENTER("StorageInterface::max_supported_keys");
DBUG_RETURN(MAX_KEY);
}
-
int StorageInterface::write_row(uchar *buff)
{
DBUG_ENTER("StorageInterface::write_row");
@@ -983,7 +1009,6 @@ int StorageInterface::delete_row(const u
DBUG_RETURN(0);
}
-
int StorageInterface::commit(handlerton *hton, THD* thd, bool all)
{
diff -Nrup a/storage/falcon/ha_falcon.h b/storage/falcon/ha_falcon.h
--- a/storage/falcon/ha_falcon.h 2007-11-09 09:06:13 -06:00
+++ b/storage/falcon/ha_falcon.h 2007-11-12 17:13:26 -06:00
@@ -93,6 +93,7 @@ public:
virtual int reset_auto_increment(ulonglong value);
virtual const COND* cond_push(const COND* cond);
virtual int optimize(THD* thd, HA_CHECK_OPT* check_opt);
+ virtual int delete_all_rows(void);
void getDemographics(void);
int createIndex(const char *schemaName, const char *tableName,
| Thread |
|---|
| • bk commit into 6.0 tree (chris:1.2666) BUG#22173 | cpowers | 13 Nov |
