Detection And Recovery System For Database Corruption Computer Science Essay

Published: Last Edited:

This essay has been submitted by a student. This is not an example of the work written by our professional essay writers.

Does database records protect by intruders or unauthorized changes? Can anybody trust on database records? Etc. There are several questions that could be occurred about a database and these questions occurred because there may be lot of corrupted data in a database. If there is corrupted data, sometimes all the systems depend on this database would be useless. Therefore what will happen to the company, organization or a country that use these kinds of applications? Therefore database plays an important role in an application and data in the database becomes the valuable asset which should protect from intruders.

Intruders are violated main security concerns like Confidentiality, Integrity and Availability. When these concerns are violated in a database, a corruption occurs. Corruption can occur because of a hacker, some type of statistical inference or some users tries to get information using their privileges. Most of applications prevent these issues. But still there are chances to happen such things. Transactions that are operating these kinds of corrupted data may be aborted or commit. When a data is corrupted from an intruder and a transaction is aborted there should be a system for detect those corruptions. There are lots of detecting systems which use different algorithms to detect these corruptions. One algorithm cannot handle all the corruptions. Therefore different kinds of systems are used to different kind of corruptions and some of detecting systems and algorithms are mentioned in this research. They use different kind of data structures, Log records and tables etc.

When a corruption is detected, there should be a recovery system to recover it. Assume if data is lost because of corruptions. Then that lost data must be recovered or should remove from committed transactions. When this process completed, application will work fine. Therefore proper application should have all these techniques regarding corruptions. Therefore through this research it will help to identify different methods to detect database corruptions and the ways to recover from those corruptions.



First and foremost, I would like to thank my supervisor, Dr. Jeewani Goonetillake for the valuable guidance and advice given to this research. She inspired me greatly to work in this project.

Besides, I would like to thank Mr. Malik Silva, for providing me necessary knowledge about Latex which helped in arranging this documentation. Also, I would like to give my regards to my colleague, Chamith malindaSiri Wijesundara for the help given to make this research a success. Without helps of the particular that mentioned above, I would have faced many difficulties while doing this project.




The main topic in this research is Detection and Recovery Systems for database corruptions. Today, most of the applications have huge databases which use database management systems. These systems help with lot of features because database's data play a major role. These data can be corrupted from intruders which is one of the main issues that data is facing with. There are different kinds of databases which store different kinds of data like defense data, data that are regarding an experiment data regarding a transmissions and etc. therefore what happen if these data's are corrupted? That's the big question that most of the researches are trying to find solutions and in this paper, Lot of solutions are mentioned after doing a thorough analysis.

When data is corrupted, detection plays a major role on data because before recovering from that corruption, corruption should be identified clearly. If data is detected, several clues may be revealed. These clues reveal about corruption, how it happens, abort/committed transaction and some patterns on a corrupted data. In this research, Corruption detecting systems are mentioned at the beginning. Dali system is the first detecting system in this research. This system uses a checksum for detection algorithm. Checksum can enable in different ways in different databases. Code word based protection is the next detecting system in this research. This system uses some Dali algorithm's features. Data mining is another powerful detecting system where Detection is happened through pattern recognition. Misuse detecting system and anomaly detection system are briefly described.

Recovery is another important term in this research. After detecting the corruptions, they should be recovered. Dali algorithm has a recovery methodology that uses database images in recovery process. Those are undo and redo images. Next recovery methodology is ARIES recovery system. C-ARIES is researched under ARIES system. This algorithm uses some data structures and it has three recovery phases. Therefore recovery database form corruption is process through these 3 phases. Delete transaction model is the next recovery model. Deleting the effects of the corruption from database is main concerned in this model. This algorithm is used in checkpoint also. Finally Redo transaction model is researched. In here, physical and logical redo log becomes important. There is lots of detecting and recovery systems for database corruptions but this research analyzes few systems from those where Author conclusion is the final one.

Lots of researches help to create this paper. There are lots of methods that are not mentioned here but this will be helpful for lot of applications to be stable.

\chapter{Detection System For Database Corruptions}

\section{Dali System}

Dali system is a main memory storage system for persistent data which prepares the database in main memory to a suitable environment. From this system, database is mapped to virtual address space of processes. In \cite{1}, Dali system divides the database in to database files and store related data in the database file. Also it locates unrelated data in different files and System data like log records, lock structures etc in a system database file. Because of this system relevant files could be able to access by multiple processes without mapping the whole database. Dali system plays a major role in \cite{1}. In the study of database corruption it reveals that the main vulnerability for such corruption is the direct access done by user. If data in a database is corrupted it would be a severe problem because those data might be highly sensitive and costly. In such situations, to detect corruptions and minimize the damage a detection methodology can be used. Dali system is a one methodology which uses checksum as the detecting method.

In this system a checksum is computed using bit pattern of words in the database files and then store the checksum in the page header. When a process retrieves the same record from a database file, recomputed checksum will be same as the previous computed checksum. Finally two checksums will be compared. If they are different, it gives a clue that a corruption has happened in the database. Today most of the Database management systems provide the tools for this checksum method. In \cite{2}, Page checksum is the new method introduced in SQL 2005 for checksum method and it can be enabled through ALTER database command. If a user wants to enable checksum to the entire database, it can be done by running DBCC CHECKDB command with PHYSICAL\_ONLY option. Then checksum will be eligible for the entire database. Mysql database also provides this kind of service where CHECKSUM TABLE gives a checksum for a table and where CHECKSUM option in CREATE TABLE statement gives a checksum for entire rows in \cite{4}.

In a database operation mainly two things happening which are read and write. In this checksum method verification happens in reading the data. Once it is recognized that there is no any corruption, data would be written. Also the checksum is verified at the check point time to verify whether uncorrupted data has written to the disk. If it identifies any corruption, write action will be aborted immediately.

Dali system also comprises with a recovery methodology which will be discussed in the recovery chapter precisely and some of the features of this recovery algorithm are used in detection algorithms.

\section{Code word Based protection}

Database corruptions can be categorized as direct corruptions and indirect corruptions. Direct physical corruptions happen when byte code of data is modified due to incorrect transactions or unauthorized access to the database. Indirect corruptions happen when a data is directly corrupted and if one of process can read this corrupted data. After reading, the process will write the corrupted data to the database which prompt an indirect corruption.

Data Codeword and Data codeword with deferred Maintenance are codeword based techniques which are used to detect corruptions. Read logging technique is used to detect indirect corruptions. According to \cite{5}, there are techniques which protect data by dividing the database into protection regions. Each region has a codeword. The codeword is the bitwise exclusive or of the words that are in the protection region. When the data in a region is updated, codeword also would update.




\caption{Hierarchy of protection region and codeword. source : \cite{5}}


Protection latch and codeword latch are important in data code word technology. Protection latch is associated with each protection region and it is in exclusive mode when data is being update or when a reader checks the region against the code word. Another mode of protection latch is shared mode. In this mode, update on different places on a region concurrently. Cord word latch is used to serialize updates in cord words. In code words, detect direct physical corruption using a subsequent database audit.

Read Prechecking is a prevention algorithm for indirect corruptions which uses the technique of verifying code word is before and after the model update. If the computed code word and stored word are different it will recover the data. Refer \cite{5} for more details about algorithm. Consider a situation when prechecking is not used. Auditing is asynchronous check consistency of words in region and code word. When auditing is asynchronous, large area is considered as protection region and protection latch is used by several transactions concurrently because its mode is in shared mode to updaters. Now cord word latch is used to guard the code word from updates. During updates, code word become exclusive mode and checks the consistency between region and code word. Auditing has an algorithm.

Auditing algorithm in \cite{5} declare various terms like undo log, redo log and ATT. When a physical update happens, it generates the undo image and redo image of database region. It helps to abort transaction and recover the transaction.ATT is the active transaction table. Logical Undo and redo logs which are created during transaction are stored in ATT per transaction basis. When a check point happen physical undo logs stored in disk. This physical undo is created using logical undo instruction in each transaction. When a recovery mechanism is needed, ATT would be important for that. Here Fuzzy precheck is used because Auditing algorithm is expensive when it used for entire database. In here code word value of the page is computed, without considering ongoing updates. Finally a comparison of code word value and the code word value in code word table is done. Problem is, when there is a corrupted data, update can be happen to code word of this corrupted data itself.

Following steps are taken in \cite{5} to audit the database.


\item for each page


\item Note the value in the codeword table for the page

\item Compute its codeword (without latches or Locks).

\item Note the value in the codeword table for the page a second time.

\item If the computed value does not match either noted value, add the page to AU\_needed.


\item Note end\_of\_stable\_log into AU\_begin.

\item Copy pages in AU\_needed to the side.

\item Extract the trailing physical-undo log records affecting pages in AU\_needed for in-process transactions from the active transaction table ATT. Call this collection of physical records the AU\_att. Records are gathered from different transactions independently, using a latch on the entry to ensure that operations are not committed by a transaction while we are gathering records from its log.

\item Get the flush latch and execute a flush to cause code words from outstanding log records to be applied to the codeword table. Note the new end\_of\_stable\_log in AU\_end. Note the codeword values for all pages in AU\_needed into a copy of the codeword table called AU\_codewords. Finally, release the flush latch.

\item Scan the system log from AU\_begin to AU\_end. Physical redo records which apply to pages in AU\_needed are applied to the side copy of those pages. Also, if the undo corresponding to this physical redo is in the AU\_att, it is removed.

\item All remaining physical undo records from AU\_att are applied to the checkpoint image.

\item Compute code words of each page in AU\_needed and compare them to the value in AU\_codewords. If any differ, report that direct physical corruption has occurred on this page.


AU , end\_of\_stable\_log are the terms used to audit which introduced in the system log. The stable system log and the tail system log are the two system logs that contain in a system log. When a transaction is committed, redo log records are moved from local redo log to system log tail. End\_of\_stable\_log is like a flag or a variable. It keeps a pointer to the system log. When the transaction commits or during a checkpoint, all records till pointer is flushed to the stable system log is known as the Log flush process.

\section{Data Mining Approach for detect database corruptions}

In these systems, data mining approaches are mainly used to find data dependency. According to \cite{6}, Data dependency of a transaction can find through a set of sequences. Sequence is an ordered list of read/write operation. Operations are denoted as oi ? {r, w}, a data item is denoted as dk, 1 ? k ? n. Sequence s is denoted as $<$o1(d1), o2(d2), ', on(dn)$>$. D(s) represent set of data items that are in sequence s. it implies as D(s)={ d1, d2, ', dn}. There are three sequences in when transaction happen on a data item. Those are read sequence, write sequence and weight of data dependency. In read sequence format of data item x is $<$r (d1), r (d2), ', r (dn), w (x)$>$. This format implies, the transaction should read the entire data item in x before update the x. The write sequence format of data item x is $<$ w (x), w (d1), w (d2), ', w (dn) $>$. This implies, transaction should write data item in x after update x data set. The weight of data dependency show, How data item x depend on other data items. This implies as rwright (x,D(s)-x) and wweight (x,D(s)-x) for reading/writing data items before/after update x. These sequences are mentioned in \cite{6}\cite{7}\cite{12}. Another parameter is threshold. From threshold, weakness or strong data dependency can identify.

\subsection{Methodology in data mining approach}

Problem is divided in to three main steps where sequentially pattern discovery phase is the First phase. According to \cite{6}, Discover the sequential pattern of transaction using Aprio algorithm is done in first phase, considering the threshold. A sequential pattern mined table would be the final output of this phase. Read and write sequence set generation phase can be described as the second phase where data dependency is considered. Here data which has more than one operation in sequential pattern mined table is considered. The single operations data is neglected this phase. Second important thing is read operation where Corruption detection is the most important. Therefore in this phase write operation plays the main role among operations. Therefore sequential data mined table rows that have only read operations are neglected here. For other sequential operations it will find the read write sequential sets. For write operation w(di) ,get the $<$r(di1), r(di2), r(di3),', r(din), w(di)$>$ as read sequence set of item di where {r(di1), r(di2), r(di3),', r(din)} is read operations before w(di). Then get write sequences. It also has same procedure. Get $<$w(di), w(dj1), w(dj2), w(dj3),', w(djk)$>$ as write sequence set of item di where {w(di1), w(di2), w(di3),', w(din)} is write operations after w(di).

Data dependency rule generation phase is the Final phase in this process where Read rules and write rules are categorized . Generate the read rules with the format w(di)?r(di1), r(di2), ', r(din) from read sequence set. If the confidence of the read rule is larger than the minimum confidence then it is consider as a read rule. This implies before update di, di1, di2, ', din data item should read from same transaction. Next generate the write rules. Get the write rules with the format of w(di)?w(dj1), w(dj2), ', w(djk) from write sequence set. In here also compare the confidence and build the write rules. This rule say after update di, dj1, dj2,', djk data item should update from same transaction. Finally find the corruption processes from these two rules. If a transaction updates the database without following these data dependency rules, detect those transactions. Algorithm for data mining approach is in \cite{6}.

\section{Misuse detection System}

According to \cite{8}, these systems have attack description. Then match them with audit logs. Problem in this system is, they only can detect previously known defects. Misuse detection system can't detect new defects. DEMIDS is the Misuse detection system, made for relational databases. DEMIDS is mentioned in \cite{7}\cite{12}.

\section{Anomaly Detection}

Anomaly detection model checks the user's or application's behavior according to \cite{8}. This model detects an intrusion if users expected behavior is deviate from normal behavior. Anomaly detection model can detect previously unknown defects. In \cite{11}, describe how to get user's behaviors using audit files.

\chapter{Recovery Systems for Database Corruptions}

\section{Dali Recovery Algorithm}

Physical logging and logical logging are the terms discussed in this algorithm. Before or after database image logging is considered as the Physical logging while the logging of operations are considered as Logical logging. Dali Recovery algorithm has some key features. Persistent log contain redo records of committed transaction. Redo and undo records are kept separately in main memory for uncommitted and successful transactions. If a transaction is committed, only kept redo records. Undo and redo records for aborted transactions are neglect and don't keep them. When a checkpoint is performed for an uncommitted and successful transaction, undo record for that transaction is kept in disk. When the crash is happen, then scan the log to losers. Undo log of losers keep separate from redo log because avoid the undo log records. If redo is required, process the redo records.

Article \cite{1} precisely describes how checkpoints are made. Checkpoints could perform at any place and Checkpointing algorithm follows a ping pong scheme where continues checkpoints are written in different place on hard disk.

\section{ARIES Recovery Algorithm}

Algorithm for Recovery and Isolation Exploiting Semantics is called as ARIES in \cite{9}. In this \cite{9}'s algorithm, LSN - Log Sequence Number is the main thing that should be known. Every page has a LSN to identify which updates are applied exactly once. In the dirty page table, dirty pages are noted. Fuzzy check points are a useful term to be known in this algorithm. It increased up speed of crash recovery. Checkpoints data is written to disk at checkpoints. Checkpoints are described in \cite{5}\cite{10}, Following data are stored at that time. ATT (active transaction table) data are stored. ATT has firstLSN; it means LSN of first log records written for the transaction. DirtyLSN value also stored at checkpoint. DirtyLSN showed oldest update to any dirty page that has not yet in disk.

This article describe about C -Aries algorithm which is same as ARIES in \cite{9}.

Following are the several crash recovery tables used in ARIES algorithm in \cite{9}\cite{10},

\textbf{Transaction State Table } - store the status of transactions that are activating after the check point.

\textbf{Page Link (PLink) List} - Link list of log records for each page.

\textbf{Page Start List} - Keep the records about redo phase beginning position per a page.

\textbf{Page End List} - Increase performance.

\textbf{Undone List} - store a list of all previously undone operations.

\subsection{ARIES algorithm}

ARIES algorithm consists of three phases according to \cite{9}\cite{10}. First one is the Analysis Phase. Collecting data to restored DB to most recent consistent state is the Main objective of first phase. Initialization is the first activity under this objective which is Initialize the transaction status table and find the starting point (scanLSN) to forward scan of the log. ScanLSN is lowest LSN of DirtyLSN or Lowest LSN of FirstLSN. After initialization, the log is scanned. While scanning, change transaction status, modify the transaction table and pLink list, create page start or end list entry as what is required and add entry to undone list is happened. Completion is the Final activity in Analysis phase and acquiring the X-lock for all pages that are in Page start List is happened there.

Redo Phase is the Second phase where returning each page in database in to immediate stable position that held before crash is the Main objective. Under this phase allocates thread for each page in Page start List to repeats history for each page. In this phase, used pLink List to move forward through log record until page's records are finished. If last log of a page is processed undo phase will continue. Undo Phase is the final phase. Main objective in this phase is undo previous updates for looser transactions. In this phase, thread for a page work backward through the log. PagelastLSN process each log record. When the tread has completed all the records, the page can be unlocked.

\section{Delete - Transaction Model}

Delete - transaction model is about removing the effects of corruptions from database image according to \cite{5}. In this model, checkpoint \cite{5}\cite{10} is used to update -consistent to free from corruptions. Recovery is started from non corrupted database image. This Algorithm considers that error occurred after the last clean audit began. Audit\_LSN is the pointer in log for last clean audit began. Two data tables are mainly used here. CorruptTransTable and CorruptDataTable are those two tables. Delete - Transaction Model also has three phases in \cite{5} which are Redo phase, Undo Phase and Checkpoint. If a transaction has read corrupt data, that should be in the CorruptDataTable. In Redo phase, checkpointed database image is loaded to main memory and then redo phase of Dali recovery algorithm \cite{1} is initiated. After that forward log scan is started from CK\_end. This happen before Audit\_LSN in redo log. There are lots of steps during forward scan which are mentioned bellow.


\item If read or write record indicates that transaction has read corrupted data, transaction added to CorruptTransTable. Physical log data of transaction's undo log is added to CorruptDataTable.

\item If a log record for physical write found consider these two scenarios. The log record generated from transaction is in CorruptionTransTable or not. If it is in there, the data it would have written is inserted in to CorruptDataTable. If it is not in there, redo is applied to database image as Dali recovery algorithm.

\item If starting operation log record is from a transaction that is not in CorruptionTransTable, then it is checked against the operations in the undo log record of all the transactions that are in CorruptionTransTable. If there is a conflict, add that transaction to CorruptTransTable. From this corrupted transactions are roll backed. If there is not a conflict, then it is handled as in normal restart recovery algorithm.

\item If a transaction in a CorruptTransTable is generate an abort transaction or commit operation as a logical record, then that record is ignored. Otherwise the record is handled as in normal restart recovery algorithm.

\item When Audit\_LSN is passed, all the corrupt data noted by last audit is added to the CorruptDataTable.


At the end of Forward scan, incomplete transactions are roll backed. Then consider the Undo phase. In this phase, Undo of all incomplete transactions is performed level by level. Redo log add transactions to CorruptTransTable. Therefore there is an undo log for these transactions. Action taken by a transaction before read a corrupted data is contained in undo log. Therefore in this phase, get the undo log of a corrupt transaction and undone those records same as when they perform at time of crash.

Recovery is completed by performing a check point. From checkpoint, it ensure about database, is it crash free or not. If check point is not performed, recovery process again rediscover the crash and transactions that are started after this recovery phase, are called as corrupted transactions.

\section{Redo Transaction Model}

Redo transaction model of corruption recovery is conveyed this idea in \cite{5}. That is once a direct error has been identified and corrected; transactions effected by error are logically rerun in history. Therefore transactions rerun in same order of original transactions. There are two assumptions for Redo transactions model in \cite{5}. That is transaction must be independent. That's mean; the processed transactions must not be depending on current or past database state. Another assumption also made when the algorithm is implemented. That is logical or physical redo logging is performed by database management system. In this model mainly find the read corrupted data. That can happen among CorruptDataTable and transaction's read log. This CorruptDataTable contains tuples from database and read log records. This shows the relationship with database. If a tuple in CorruptDataTable is matched with a transaction's read log, that transaction have read corrupted data.

Here is the algorithm in \cite{5}.

Until a commit transaction happened, log records for transactions are saved. After that, if a commit log record for transaction is seen then finds read corrupted data in committed transaction. After that transaction is marked as corrupt. Then transaction is reexecuted logically and update it's redo records in log from new logical redo records. Some set of tuples updates from original transaction or reexecuted transaction. A tuple from this data set is added to CorruptDataTable if that tuple is present in the database following original execution but not following reexecution or if that tuple is not present in database following the original execution but is present following the reexecution. If the transaction is not marked as corrupt, its log records are executed in normal way. Finally, if an abort record for transaction is found, the log records for that transaction are removed.


This research paper described variety of detection and prevention techniques for database corruptions. Each techniques use different kind of methodologies to complete detects corruption or recover from corruptions. Dali system is a main memory storage system. Database divided to data files. There are lots of benefits. According to \cite{1}, User processes can access the data file avoiding inter process communication because of this benefit some corrupted transactions may be prevent. Processes can be mapped directly to suitable data file instead of whole database. From this uncorrupted data do the normal transaction because committed are stored in different kind of files. Another benefit mentioned in \cite{1} is multiple processes can access database concurrently. This helps to improve the efficiency of database actions. Dali system helps to improve performance of the application. Dali uses a checksum to detect corruptions. How checksum is behaved, what is cryptographic checksum and at what level checksum can be applied? Those are mentioned in \cite{3}. Different databases use different kinds of tools for activate checksum. Mysql and Sql 2005 show how they use this tool in \cite{2}\cite{4}. Daily uses a recovery algorithm to recover from database corruptions. This can handle using a check points and undo and redo images.

Code word based protection also used Dali algorithm to detect database corruptions. It uses a code word. It is like a checksum in Dali. Code word latch and protection latch control the concurrency access. In this system, undo image and redo image play a major role. It is important to recovery process as well. This system handles both direct physical corruption and indirect physical corruptions. Therefore lot of corruptions can handle by this system. Prevention also can be done using code words. Prevention technique is Pre checking. Data mining approaches also detect database corruptions. Pattern checking is the main method used in Data mining. Using pattern checking, lot of intruders can be identified and it is one of the best methodologies. Lot of corrupted transactions can be identified while analyzing the pattern among read and write sequences. In modern world, lot of things identified by analyzing the patterns. Those analyzed results are correct if analyzers used accurate procedures. Data mining techniques are very efficient because corrupted transaction can be identified easily using set of steps. This is one of efficient and interesting algorithm.

ARIES and Delete transaction uses set of phases. This is the good approach because recovery can be done through set of steps. Recovery process divides in to different components. Basic ARIES algorithm uses page indexing to discover what update happen for each data page. It uses set of data structures which helps to analyze data. ARIES has different kind of algorithms. In this research C-ARIES is implemented. ARIES/LHS is another one which is described in \cite{13}. C-ARIES use a multi threaded version. This allows transactions to roll back simultaneously. In \cite{9}, Concurrency is happen in higher level. Also it is capable of doing updates that are roll backed without any corruptions and conflicts. Delete -Transaction algorithm use a forward scan on log records. It uses pointers to forward scan. Main purpose of this method is to remove corrupted transactions from the database. Check points also plays a major role in this algorithm. Checkpoints convey whether the database is corrupted or not? Problem is if check point is not happen accurately, corrupted data will be still in the database.

Redo transaction use same set of tables that are in Delete -transaction Model. Main thing is, it re execute transactions when a corruption happen. Some tuples are executed from normal update or reexecution. Enter those tuples to a CorruptDataTable using some conditions that are in \cite{5}. Aborted transactions are identified finally. Check points are the important factor in lot of models. Check points should perform effectively and efficiency. If that happen detection and recovery will be happened in perfect manner. Therefore these algorithms are useful for all the databases because all the databases are not free from crash.


\bibitem {1}H.V. Jagadish , Daniel Lieuwen ,Rajeev Rastogi, S.Sudarshan, Avi Silberschatz ,\textit{A High Performance Main Memory Storage Manager}, Lab- AT\&T Bell Labs

\bibitem {2}


\bibitem {4}Susan Gordon ,\textit{Database Integrity: Security, Reliability, and Performance Considerations}, University- Indiana University South Bend

\bibitem {5}Philip Bohannon,RajeevRastogi, S.Seshadri, AviSilberschatz, Fellow, IEEE,and S.Sudarshan, \textit{Detection and Recovery Techniques for Database Corruption}, 2003

\bibitem {6}Yi Hu, Brajendra Panda, \textit{A Data Mining Approach for Database Intrusion Detection}, University- University of Arkansas , 2004

\bibitem {7}Abhijit Bhosale, \textit{Intrusion Detection and Containment in Database Systems}, University - School of Information Technology , 2004

\bibitem {8}Richard A. Kemmerer and Giovanni Vigna, \textit{Intrusion Detection: A Brief History and Overview}, University - University of California Santa Barbara

\bibitem {9}Jayson Speer and Markus Kirchberg, \textit{C-ARIES: A Multi-threaded Version of the ARIES Recovery Algorithm},Information Science Research Centre, Massey University,New Zealand

\bibitem {10}C. Mohan, D. Haderle, B. Lindsay, H. Pirahesh, and P. Schwarz, \textit{ARIES Recovery Algorithm ARIES Recovery Algorithm}, 1992

\bibitem {11}Ashish Kamra, Elisa Bertino, Guy Lebanon, \textit{Mechanisms for Database Intrusion Detection and Response}, University- Computer Science Purdue University , 2008

\bibitem {12}Dr. Shamik Sural, \textit{Intrusion Detection and Containment in Database Systems g}, Information Technology Indian Institute of Technology, Kharagpur , 2005

\bibitem {13}C.Mohan, \textit{ARIES/LHS : A Concurrency Control and Recovery Method Using Write ' Ahead Logging for Linear Hashing with Separators}, Database Technology Institute, IBM Almadan Reseach center, USA\end{thebibliography}