PHP operates MySQL transaction instance, mysql transaction instance_PHP tutorial

PHP operates MySQL transaction instance, mysql transaction instance

The examples in this article describe how PHP operates MySQL transactions and are shared with you for your reference. The specific method is as follows:

Generally speaking, transactions should have ACID characteristics. The so-called ACID is written with the first letters of the four words Atomic (atomicity), Consistent (consistency), Isolated (isolation), and Durable (persistence). Let's take "bank transfer" as an example to explain their meanings. :

① Atomicity: The statements that make up a transaction form a logical unit, and only part of it cannot be executed. In other words, a transaction is the smallest indivisible unit. For example: During the bank transfer process, the transfer amount must be subtracted from one account and added to another account at the same time. It is unreasonable to only change one account.
② Consistency: The database is consistent before and after transaction processing is executed. That is, the transaction should correctly transform the system state. For example: During the bank transfer process, either the transfer amount is transferred from one account to another account, or both accounts remain unchanged, and there is no other situation.
③ Isolation: One transaction has no impact on another transaction. That is to say, it is impossible for any transaction to see a transaction in an incomplete state. For example, during a bank transfer, before the transfer transaction is submitted, another transfer transaction can only be in a waiting state.
④ Continuity: The effects of transaction processing can be preserved permanently. Conversely, transactions should be able to withstand all failures, including server, process, communication, media failures, etc. For example: During the bank transfer process, the account status after the transfer must be saved.

In PHP, mysqli has well encapsulated the related operations of mysql transactions. Example below:

Note here:

MyISAM: does not support transactions, used for read-only programs to improve performance
InnoDB: supports ACID transactions, row-level locks, and concurrency
Berkeley DB: supports transactions

I hope this article will be helpful to everyone’s PHP+MySQL database programming.

The following is a simple database encapsulation class for php5, suitable for learning. For other operations such as deletion and update, you can add it yourself:
class Mysql{ //First Define a class, with the first letter capitalized
public $host;//server name, access modifier PUBLIC proves that $host is a public attribute, accessible both inside and outside the class, and can be inherited
public $ user;//Username is a public attribute
private $pass;//Password, ask the modifier private to prove that $pass is private. It can only be used inside the class and cannot be inherited.
public $ dbname;//Database name is also a public attribute.
//__construct declares this to be a constructor, defining some initial information. There are three parameters
public function __construct($host, $user, $pass, $dbname){
$this->host = $host;
$this->user = $user;
$this->pass = $pass;
$this-> ;dbname = $dbname;
$link = @mysql_connect($this->host,$this->user,$this->pass)
or die("error");
@mysql_select_db($this->dbname,$link)
or die("error2");
}
//Define the search and display function of the database
function myQuery($sql){
$result = mysql_query($sql);
if(!$result){
echo "error3";
exit;
}
$num = mysql_num_rows($result) ;
if($num){
echo "NO".$num;
}
while($row = mysql_fetch_assoc($result)){
echo '< ;td bgcolor="#fffddd">

'.htmlspecialchars(stripslashes($row['body']))."
";
 }
 }
}
$rutt = new Mysql('localhost','root','ssss','calvin'); //Instantiate a class... Remember the parameters here are The same as the parameters of the constructor...
$rutt->myQuery(...the rest of the full text>>

 

I want to make a website, a piece of PHP programming code, how to implement PHP's MYSQL cache? It’s best to give an example


//The following is the cache class:
class cache {
 //Cache directory
 var $cacheRoot = "./cache/";
 //Cache update time in seconds Number, 0 means no caching
 var $cacheLimitTime = 0;
 //Cache file name
 var $cacheFileName = "";
 //Cache extension
 var $cacheFileExt = "html ";

 /* 
 * Constructor
 * int $cacheLimitTime cache update time
 */ 
 function cache( $cacheLimitTime ) {
 if( intval( $cacheLimitTime ) ) 
$this->cacheLimitTime = $cacheLimitTime;
 $this->cacheFileName = $this->getCacheFileName();
//echo $this->cacheFileName;
 ob_start();
 }

 /* 
 * Check whether the cached file is within the set update time 
 * Return: If it is within the update time, return the file content, otherwise return Failure
 */ 
 function cacheCheck(){
 if( file_exists( $this->cacheFileName ) ) {
$cTime = $this->getFileCreateTime( $this->cacheFileName ) ;
if( $cTime + $this->cacheLimitTime > time() ) {
 echo file_get_contents( $this->cacheFileName );
 ob_end_flush();
 exit;
}
 }
 return false;
 }

 /* 
 * Cache files or output static 
 * string $staticFileName static file name (including relative path) 
 */ 
 function caching( $staticFileName = "" ){
 if( $this->cacheFileName ) {
$cacheContent = ob_get_contents();
 //echo $cacheContent;
ob_end_flush();

if( $staticFileName ) {
$this->saveFile( $staticFileName, $cacheContent );
}

if( $this-> ;cacheLimitTime )
 $this->saveFile( $this->cacheFileName, $cacheContent );
 }
 }

 /* 
 ...the rest Full text>>

 


http://www.bkjia.com/PHPjc/906673.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/906673.htmlTechArticlePHP operates MySQL transaction example, mysql transaction example. This example describes the method of PHP operating MySQL transaction, and shares it with everyone. For everyone’s reference. The specific methods are as follows: Generally speaking, transactions should...