Better Understanding of ACID Principle In SQL Database

-
ACID principle in SQL database

ACID  is a set of principles whose acronym is Atomicity, Consistency, isolation and durability. As any other principle, it’s done by the developer or database admin or available feature on the database system of choice (MySQL, Postgres, SQL server). So as a developer or data admin you must know this principle in order to design and develop a database system for your project.

Dealing with database transactions that have many queries in it should be handled following the ACID principle. When a set of queries are executed ACID prevents disaster in your data because something that is partially error in the middle of transaction can lead into data inconsistency. Because the app query expects all the query should be completed with no interruption, sometimes your database depends on other data.

So here’s what ACID principles acronym are:

Atomicity

All queries in a transaction are treated as a single thing, if one query fails, the whole thing shouldn’t change anything.

Atomicity preserves the “completeness” of the business process. Consistency refers to the state of the data both before and after the transaction is executed. A transaction maintains the consistency of the state of the data. In other words, after running a transaction, all data in the database is “correct.”

If you are using MySQL, you must be familiar with

START TRANSACTION

  Query 1

  Query 2

  Query 3

COMMIT

Consistency

If database crash in the middle of transaction, the consistency of the data should remain valid.

When one part of the transaction fails, all of the pending changes are rolled back, leaving the database as it was before you initiated the transaction. For instance, when you delete a customer record, you should also delete all of that customer's records from associated tables (such as invoices and line items). A properly configured database wouldn't let you delete the customer record, if that meant leaving its invoices, and other associated records stranded.

Behind the system, MySQL has two functional operations to handle consistency double write buffer and crash recovery. 

- Double write, when a transaction happens, the queries are not committed yet to the actual MySQL table, rather in buffered memory, only if finished with no crash.

- Crash recovery, MySQL innoDB engine has crash-recovery that will recover failed transactions from transaction log.

Isolation

Lock the data to prevent different transactions modify the same data value at the same time.

Isolation principle will ensure that each transaction in MySQL is invisible to any other transaction that is in progress. MySQL system must allow each transaction to complete and then decide which transaction value is the final data value for the data.

In MySQL InnoDB it implements row-level locking. The row-level locking will lock the data record that’s being modified, so it prevents different queries modifying the same row in a table. MySQL locking does what it says when a transaction is being committed to the database, it locks rows and other threads that modify the same rows can’t access the data.

Durability

Because of the consistency principle,  transactions that are not committed successfully won't be written to the database. However, the durability principle states that when the database is restarted after such a failure(because of resource outage, etc), it should examine those failures in the transaction log, and then it must apply them when the system is back under normal state.

MySQL implements double-buffer, crash recovery to comply with durability principle. The innodb_flush_log_at_trx_commit variable. The sync_binlog variable. The innodb_file_per_table variable. It also provides a feature that interacts with particular hardware configuration. 

ACID principle allows safe, consistent  data to minimize corrupting the data that is not performed by the client when a transaction has such failure. 

When doing transactions that have many queries in it, you should treat the changes to data as a single operation, so if it breaks or partially breaks, those transactions should be canceled or rolled back.

Popular posts from this blog

ERROR 1348 Column Password Is Not Updatable When Updating MySQL Root Password

-
Image
MySQL and MariaDB password As already mentioned in the title of this blog, this error message sometimes occurred when we are trying to update our root password database, either MySQL or MariaDB, The error says: ERROR 1348 (HY000): Column 'Password' is not updatable This is because if we use this SQL command to update our database root password, and it turn out to be Restricted by MySQL to use update on mysql database. UPDATE mysql.user SET Password=PASSWORD('1234') WHERE User='root'; The solutions for MySQL Error1348 So you can not update a user password using Update commands, to update the password, use ALTER commands instead. like the following. ALTER USER 'root'@'localhost' IDENTIFIED BY '1234'; And then you need to do the flush privileges to commit previous queries (that alter command above) into the system, simply do like this. flush privileges; So now you have your root with password 1234. Although it is recommended to...
Read more

How To Create Spring Boot Project Using Netbeans

-
Image
Spring Boot is a handy tool that simplifies the development of Spring Framework applications by reducing the need for cumbersome configuration. In this tutorial, I'll guide you through creating a Spring Boot application using the Netbeans IDE. While you can certainly create a Spring Boot application in Netbeans manually, it's much easier with a plugin designed for Spring development. Here's a step-by-step guide to get you started: 1. Install the Spring Boot Plugin: Open Netbeans and navigate to the Tools menu. Click on "Plugins." Once the Plugins window opens, select the "Available Plugins" tab. Look for the "Nb SpringBoot" plugin, then install and activate it. 2. Create a New Spring Boot Project: After restarting Netbeans IDE, you can create a new project with Spring Boot. Go to File > New Project. Under Categories, select Maven, then choose "Spring Boot Basic." 3. Add Dependencies: With your new project created, open the po...
Read more

Spring Kafka - How to use ReplyingKafkaTemplate send and reply synchronously

-
Image
Microservice Spring with Apache Kafka Today, I want to share how to use Kafka. It's quite interesting once you get the hang of it, and I hope my explanation will make it a bit easier for you. So, Kafka is primarily known as an asynchronous messaging queuing system. This means it allows different parts of your application to communicate with each other without waiting for immediate responses. However, there are times when you might need a more immediate reply from another service in your project. Luckily, Kafka can handle this too. Here’s how it works: The client side sends a message to the server side via Kafka. This message includes a special identifier in the Kafka header request, known as KafkaHeaders.CORRELATION_ID, along with a topic where the server should respond. The server, after processing the request, sends a message back to the same topic with the same correlation ID. This way, the client knows that the message is a response to its initial request and can act accordingl...
Read more