Solution to the problem of self-increasing ID in MySQL table_MySQL

When we perform table splitting on MySQL, we will no longer be able to rely on MySQL's automatic increment to generate unique IDs because the data has been dispersed into multiple tables. ​
You should try to avoid using auto-incremented IP as the primary key, which will bring great inconvenience to the database table partitioning operation.
There is a special feature in postgreSQL, oracle, and db2 databases---sequence. At any time, the database can obtain the next record number in the table based on the size and step size of the number of records in the current table. However, MySQL does not have such a sequence object.
You can use the following method to implement the sequence feature to generate a unique ID:

1. Generate ID through MySQL table
For insertion, that is, insert operation, the first step is to obtain the unique ID. You need a table to specifically create the ID, insert a record, and obtain the last inserted ID. The code is as follows:

CREATE TABLE `ttlsa_com`.`create_id` ( 
`id` BIGINT( 20 ) NOT NULL AUTO_INCREMENT PRIMARY KEY
) ENGINE = MYISAM 

In other words, when we need to insert data, the id value must be generated from this table. The method of my php code is as follows:

<&#63;php 
function get_AI_ID() { 
 $sql = "insert into create_id (id) values('')"; 
 $this->db->query($sql); 
 return $this->db->insertID(); 
} 
&#63;> 

This method works well, but in high concurrency situations, MySQL's AUTO_INCREMENT will cause the entire database to be slow. If there is an auto-increment field, MySQL will maintain an auto-increment lock, and innodb will save a counter in memory to record the auto_increment value. When a new row of data is inserted, a table lock will be used to lock the counter until the insertion is completed. . There is no problem if you insert row by row, but in high concurrency situations, it will be tragic. Table locks will cause SQL blocking, greatly affecting performance, and may even reach the max_connections value.
innodb_autoinc_lock_mode: 3 values ​​can be set: 0, 1, 2
0: traditonal (table lock will be generated every time)
1: Consecutive (default, new method is used when the number of rows can be predicted, table lock is used when it cannot be predicted, and batch locks will be obtained for simple insert to ensure continuous insertion)
2: interleaved (cannot lock tables, process them one by one, highest concurrency)
The myisam table engine is traditional and will lock the table every time.

2. Generate ID through redis

function get_next_autoincrement_waitlock($timeout = 60){
 $count = $timeout > 0 ? $timeout : 60;
 
 while($r->get("serial:lock")){
 $count++;
 sleep(1);
 if ($count > 10)
 return false;
 }
 
 return true;
}
 
function get_next_autoincrement($timeout = 60){
 // first check if we are locked...
 if (get_next_autoincrement_waitlock($timeout) == false)
 return 0;
 
 $id = $r->incr("serial");
 
 if ( $id > 1 )
 return $id;
 
 // if ID == 1, we assume we do not have "serial" key...
 
 // first we need to get lock.
 if ($r->setnx("serial:lock"), 1){
 $r->expire("serial:lock", 60 * 5);
 
 // get max(id) from database.
 $id = select_db_query("select max(id) from user_posts");
 // or alternatively:
 // select id from user_posts order by id desc limit 1
 
 // increase it
 $id++;
 
 // update Redis key
 $r->set("serial", $id);
 
 // release the lock
 $r->del("serial:lock");
 
 return $id;
 }
 
 // can not get lock.
 return 0;
}
 
$r = new Redis();
$r->connect("127.0.0.1", "6379");
 
$id = get_next_autoincrement();
if ($id){
  $sql = "insert into user_posts(id,user,message)values($id,'$user','$message')"
  $data = exec_db_query($sql);
}

3. Queue mode
In fact, this is also an explanation of the above
Use queue services, such as redis, memcacheq, etc., to pre-allocate a certain amount of IDs in a queue. For each insertion operation, first obtain an ID from the queue. If the insertion fails, add the ID to the queue again. At the same time, the number of queues is monitored, and when it is less than the threshold, elements are automatically added to the queue.
This method can allocate IDs in a planned way, and will also bring economic effects, such as QQ numbers, various beautiful numbers, and clearly marked prices. For example, the userid of the website allows uid to log in, launch various beautiful accounts, and clearly mark the prices. The ordinary IDs are scrambled and then randomly assigned.

<&#63;php
 
class common {
 
 private $r;
 
 function construct() {
  $this->__construct();
 }
 
 public function __construct(){
  $this->r=new Redis();
  $this->r->connect('127.0.0.1', 6379);
 }
 
 function set_queue_id($ids){
  if(is_array($ids) && isset($ids)){
  foreach ($ids as $id){
  $this->r->LPUSH('next_autoincrement',$id);
  }
  }
 }
 
 function get_next_autoincrement(){
  return $this->r->LPOP('next_autoincrement');
 }
 
}
 
$createid=array();
while(count($createid)<20){
 $num=rand(1000,4000);
 if(!in_array($num,$createid))
  $createid[]=$num;
}
 
$id=new common();
$id->set_queue_id($createid);
 
var_dump($id->get_next_autoincrement()); 

Monitor the number of queues, automatically replenish the queue and get the ID but not use it

The above is the entire content of this article. I hope it will be helpful to everyone’s study and I hope you will support me a lot.