应用memcached构建支持Master/Slave读写分离的数据库操作类

最新推荐文章于 2023-03-09 10:15:31 发布

jun54555

最新推荐文章于 2023-03-09 10:15:31 发布

阅读量2.6k

点赞数

文章标签：数据库 memcached sql function string mysql

原文地址:http://blog.csdn.net/heiyeshuwu/archive/2007/07/30/1716041.aspx

一般对于访问量比较大的网站来说，采用基本的MySQL Master/Slave 结构是很正常，而且一般都是一台Master，多台Slave的情况，但是一般在进行这个访问的时候问题比较多，因为读写操作必须分离，所以今天没事就构造了这个数据库操作类。

数据库操作类基本特点：

1. 支持一台Master，多台Slave的情况，所有SQL能够强制调用Master来处理

2. 能够自动识别是写入还是读取操作，然后自动连接到需要的Master/Slave服务器。操作过程中能够自动识别，如果没有Slave，则所有操作都是指向Master的，如果当前连接的Slave无法工作则自动连接其他Slave。对于Slave读取数据采用随机挑选Slave服务器的方式来读取数据

3. 在同一个PHP程序中能够重用连接，不会重复去连接数据库，减少因为反复连接带来的资源消耗

4.增加了memcahced的支持,已查询数据从memcache中获取,减少对数据库的访问(对原来的修改)

缺点：

1. 对于Slave是采取随机选择Slave来进行读取数据，所以不是真正意义上的负载均衡

2. 每次初始化都是连接好所有的数据库，比较浪费连接资源和时间。在多个PHP程序中无法保持数据库连接，每次启动都需要连接到远程数据库，浪费了很多连接处理的时间，但是这个跟PHP是脚本程序有关。

3. 无法支持多个Master的情况，同时可定制性比较差，很多东西都是固定的，必须按照固有模式来执行查询

相关：

代码中注释不是很全，部分注释而且不一定正确，所以如果自己使用，最好进行二次修改。

本数据库类参考了我之前写的《简单快速有趣的MySQL数据库操作类：SimpleDB》，可以对照着看。

（类库中的接口我大部分都经过了测试，都正常使用，如果发现不正常或者有更好的想法，请留言）

文件：db_common.class.php

<?php

//----------------------------------------------------

// Master/Slave数据库读写分开操作类

// 作者: heiyeluren <http://blog.csdn.net/heiyeshuwu>

// 修改: Chelin Tsien

// 时间: 2007-7-30

// 描述：支持所有写操作在一台Master执行，所有读操作在

// Slave执行，并且能够支持多台Slave主机

//----------------------------------------------------

/**

* 常量定义

define("_DB_INSERT", 1);

define("_DB_UPDATE", 2);

/**

* DB Common class

* 描述：能够分别处理一台Master写操作，多台Slave读操作

class DBCommon

{

/**

* 数据库配置信息

var $wdbConf = array();

var $rdbConf = array();

/**

* Master数据库连接

var $wdbConn = null;

/**

* Slave数据库连接

var $rdbConn = array();

/**

* 数据库结果

var $dbResult;

/**

* 数据库查询结果集

var $dbRecord;

/**

* SQL语句

var $dbSql;

/**

* 数据库编码

var $dbCharset = "UTF8";

/**

* 数据库版本

var $dbVersion = "4.1";

/**

* 初始化的时候是否要连接到数据库

var $isInitConn = false;

/**

* 是否要设置字符集

var $isCharset = true;

/**

* 数据库结果集提取方式

var $fetchMode = MYSQL_ASSOC;

/**

* 执行中发生错误是否记录日志

var $isLog = true;

/**

* 是否查询出错的时候终止脚本执行

var $isExit = false;

var $memObject = null;

var $memConfig = array('host'=>'192.168.0.200', 'port'=>11211);

var $expire_time = 15;

//------------------------

// 基础的DB操作

//------------------------

/**

* 构造函数

* 传递配置信息，配置信息数组结构：

* $masterConf = array(

* "host" => Master数据库主机地址

* "user" => 登录用户名

* "pwd" => 登录密码

* "db" => 默认连接的数据库

* );

* $slaveConf = array(

* "host" => Slave1数据库主机地址|Slave2数据库主机地址|...

* "user" => 登录用户名

* "pwd" => 登录密码

* "db" => 默认连接的数据库

* );

function DBCommon($masterConf, $slaveConf=array()){

//初始化 memcached

$this->initMemcacheObj();

//构造数据库配置信息

if (is_array($masterConf) && !empty($masterConf)){

$this->wdbConf = $masterConf;

}

if (!is_array($slaveConf) || empty($slaveConf)){

$this->rdbConf = $masterConf;

} else {

$this->rdbConf = $slaveConf;

}

//初始化连接（一般不推荐）

if ($this->isInitConn){

$this->getDbWriteConn();

$this->getDbReadConn();

}

/**

* 获取Master的写数据连接

function initMemcacheObj(){

if (!class_exists('Memcache') || !function_exists('memcache_connect')){

$this->errorLog('Failed: Memcache extension not install, please from http://pecl.php.net download and install');

}

if ($this->memObject && is_object($this->memObject)){

return true;

}

$mem = new Memcache;

if (!@$mem->connect($this->memConfig['host'], $this->memConfig['port'])){

$this->errorLog('Failed: Connect memcache host '. $this->memConfig['host'] .':'. $this->memConfig['port'] .' failed');

}

$this->memObject = $mem;

return true;

}

/**

* 获取Master的写数据连接

function getDbWriteConn(){

//判断是否已经连接

if ($this->wdbConn && is_resource($this->wdbConn)) {

return $this->wdbConn;

}

//没有连接则自行处理

$db = $this->connect($this->wdbConf['host'], $this->wdbConf['user'], $this->wdbConf['pwd'], $this->wdbConf['db']);

if (!$db || !is_resource($db)) {

return false;

}

$this->wdbConn = $db;

return $this->wdbConn;

}

/**

* 获取Slave的读数据连接

function getDbReadConn(){

//如果有可用的Slave连接，随机挑选一台Slave

if (is_array($this->rdbConn) && !empty($this->rdbConn)) {

$key = array_rand($this->rdbConn);

if (isset($this->rdbConn[$key]) && is_resource($this->rdbConn[$key])) {

return $this->rdbConn[$key];

}

//连接到所有Slave数据库，如果没有可用的Slave机则调用Master

$arrHost = explode("|", $this->rdbConf['host']);

if (!is_array($arrHost) || empty($arrHost)){

return $this->getDbWriteConn();

}

$this->rdbConn = array();

foreach($arrHost as $tmpHost){

$db = $this->connect($tmpHost, $this->rdbConf['user'], $this->rdbConf['pwd'], $this->rdbConf['db']);

if ($db && is_resource($db)){

$this->rdbConn[] = $db;

}

//如果没有一台可用的Slave则调用Master

if (!is_array($this->rdbConn) || empty($this->rdbConn)){

$this->errorLog("Not availability slave db connection, call master db connection");

return $this->getDbWriteConn();

}

//随机在已连接的Slave机中选择一台

$key = array_rand($this->rdbConn);

if (isset($this->rdbConn[$key]) && is_resource($this->rdbConn[$key])){

return $this->rdbConn[$key];

}

//如果选择的slave机器是无效的，并且可用的slave机器大于一台则循环遍历所有能用的slave机器

if (count($this->rdbConn) > 1){

foreach($this->rdbConn as $conn){

if (is_resource($conn)){

return $conn;

}

//如果没有可用的Slave连接，则继续使用Master连接

return $this->getDbWriteConn();

}

/**

* 连接到MySQL数据库公共方法

function connect($dbHost, $dbUser, $dbPasswd, $dbDatabase){

//连接数据库主机

$db = mysql_connect($dbHost, $dbUser, $dbPasswd);

if (!$db) {

$this->errorLog("Mysql connect ". $dbHost ." failed");

return false;

}

//选定数据库

if (!mysql_select_db($dbDatabase, $db)) {

$this->errorLog("select db $dbDatabase failed", $db);

return false;

}

//设置字符集

if ($this->isCharset){

if ( $this->dbVersion == '' ){

$res = mysql_query("SELECT VERSION()");

$this->dbVersion = mysql_result($res, 0);

}

if ($this->dbCharset!='' && preg_match("/^(5.|4.1)/", $this->dbVersion)){

if (mysql_query("SET NAMES '".$this->dbCharset."'", $db) === false){

$this->errorLog("Set db_host '$dbHost' charset=". $this->dbCharset ." failed.", $db);

return false;

}

return $db;

}

/**

* 关闭数据库连接

function disconnect($dbConn=null, $closeAll=false){

//关闭指定数据库连接

if ($dbConn && is_resource($dbConn)){

mysql_close($dbConn);

$dbConn = null;

}

//关闭所有数据库连接

if ($closeAll){

if ($this->rdbConn && is_resource($this->rdbConn)){

mysql_close($this->rdbConn);

$this->rdbConn = null;

}

if (is_array($this->rdbConn) && !empty($this->rdbConn)){

foreach($this->rdbConn as $conn){

if ($conn && is_resource($conn)){

mysql_close($conn);

}

$this->rdbConn = array();

}

return true;

}

/**

* 选择数据库

function selectDb($dbName, $dbConn=null){

//重新选择一个连接的数据库

if ($dbConn && is_resource($dbConn)){

if (!mysql_select_db($dbName, $dbConn)){

$this->errorLog("Select database:$dbName failed.", $dbConn);

return false;

}

return true;

}

//重新选择所有连接的数据库

if ($this->wdbConn && is_resource($this->wdbConn)){

if (!mysql_select_db($dbName, $this->wdbConn)){

$this->errorLog("Select database:$dbName failed.", $this->wdbConn);

return false;

}

if (is_array($this->rdbConn && !empty($this->rdbConn))){

foreach($this->rdbConn as $conn){

if ($conn && is_resource($conn)){

if (!mysql_select_db($dbName, $conn)){

$this->errorLog("Select database:$dbName failed.", $conn);

return false;

}

return true;

}

/**

* 执行SQL语句（底层操作）

function query($sql, $isMaster=false){

if (trim($sql) == ""){

$this->errorLog("Sql query is empty.");

return false;

}

//获取执行SQL的数据库连接

if (!$isMaster){

$optType = trim(strtolower(array_shift(explode(" ", ltrim($sql)))));

}

//如果初始化了 ,则调用已经存在的连接(对原文的修改)

if (!$isInitConn) {

if ($isMaster || $optType!="select"){

$dbConn = $this->getDbWriteConn();

} else {

$dbConn = $this->getDbReadConn();

}

}elseif ($isMaster || $optType!="select"){

if (isset($this->wdbConn) && is_resource($this->wdbConn)) {

$dbConn = $this-->wdbConn;;

}

return FALSE;

}else {

if (isset($this->rdbConn) && is_resource($this->rdbConn)) {

$dbConn = $this->rdbConn;

}

return FALSE;

}

if (!$dbConn || !is_resource($dbConn)){

$this->errorLog("Not availability db connection. Query SQL:". $sql);

if ($this->isExit) {

exit;

}

return false;

}

//执行查询

$this->dbSql = $sql;

$this->dbResult = null;

$this->dbResult = @mysql_query($sql, $dbConn);

if ($this->dbResult === false){

$this->errorLog("Query sql failed. SQL:".$sql, $dbConn);

if ($this->isExit) {

exit;

}

return false;

}

return true;

}

/**

* 错误日志

function errorLog($msg='', $conn=null){

if (!$this->isLog){

return;

}

if ($msg=='' && !$conn) {

return false;

}

$log = "MySQL Error: $msg";

if ($conn && is_resource($conn)) {

$log .= " mysql_msg:". mysql_error($conn);

}

$log .= " [". date("Y-m-d H:i:s") ."]";

error_log($log);

return true;

}

//--------------------------

// 数据获取接口

//--------------------------

/**

* 获取SQL执行的全部结果集(二维数组)

* @param string $sql 需要执行查询的SQL语句

* @return 成功返回查询结果的二维数组,失败返回false

function getAll($sql, $isMaster=false){

if ($this->dbRecord=$this->memObject->get($sql.'getall')) {

return $this->dbRecord;

}

if (!$this->query($sql, $isMaster)){

return false;

}

$this->dbRecord = array();

while ($row = @mysql_fetch_array($this->dbResult, $this->fetchMode)) {

$this->dbRecord[] = $row;

}

@mysql_free_result($this->dbResult);

if (!is_array($this->dbRecord) || empty($this->dbRecord)){

return false;

}

$this->memObject->set($sql.'getall', $this->dbRecord,$this->expire_time);

return $this->dbRecord;

}

/**

* 获取单行记录(一维数组)

* @param string $sql 需要执行查询的SQL语句

* @return 成功返回结果记录的一维数组,失败返回false

function getRow($sql, $isMaster=false){

if ($this->dbRecord=$this->memObject->get($sql.'getrow')) {

return $this->dbRecord;

}

if (!$this->query($sql, $isMaster)){

return false;

}

$this->dbRecord = array();

$this->dbRecord = @mysql_fetch_array($this->dbResult, $this->fetchMode);

@mysql_free_result($this->dbResult);

if (!is_array($this->dbRecord) || empty($this->dbRecord)){

return false;

}

$this->memObject->set($sql.'getrow',$this->dbRecord,$this->expire_time);

return $this->dbRecord;

}

/**

* 获取一列数据(一维数组)

* @param string $sql 需要获取的字符串

* @param string $field 需要获取的列,如果不指定,默认是第一列

* @return 成功返回提取的结果记录的一维数组,失败返回false

function getCol($sql, $field='', $isMaster=false){

if ($this->dbRecord=$this->memObject->get($sql.'getcol')) {

return $this->dbRecord;

}

if (!$this->query($sql, $isMaster)){

return false;

}

$this->dbRecord = array();

while($row = @mysql_fetch_array($this->dbResult, $this->fetchMode)){

if (trim($field) == ''){

$this->dbRecord[] = current($row);

} else {

$this->dbRecord[] = $row[$field];

}

@mysql_free_result($this->dbResult);

if (!is_array($this->dbRecord) || empty($this->dbRecord)){

return false;

}

$this->memObject->set($sql.'getcol',$this->dbRecord,$this->expire_time);

return $this->dbRecord;

}

/**

* 获取一个数据(当条数组)

* @param string $sql 需要执行查询的SQL

* @return 成功返回获取的一个数据,失败返回false

function getOne($sql, $field='', $isMaster=false){

if ($this->dbRecord=$this->memObject->get($sql.'getone')) {

return $this->dbRecord;

}

if (!$this->query($sql, $isMaster)){

return false;

}

$this->dbRecord = array();

$row = @mysql_fetch_array($this->dbResult, $this->fetchMode);

@mysql_free_result($this->dbResult);

if (!is_array($row) || empty($row)){

return false;

}

if (trim($field) != ''){

$this->dbRecord = $row[$field];

}else{

$this->dbRecord = current($row);

}

$this->memObject->set($sql.'getone',$this->dbRecord,$this->expire_time);

return $this->dbRecord;

}

/**

* 获取指定各种条件的记录

* @param string $table 表名(访问的数据表)

* @param string $field 字段(要获取的字段)

* @param string $where 条件(获取记录的条件语句,不包括WHERE,默认为空)

* @param string $order 排序(按照什么字段排序,不包括ORDER BY,默认为空)

* @param string $limit 限制记录(需要提取多少记录,不包括LIMIT,默认为空)

* @param bool $single 是否只是取单条记录(是调用getRow还是getAll,默认是false,即调用getAll)

* @return 成功返回记录结果集的数组,失败返回false

function getRecord($table, $field='*', $where='', $order='', $limit='', $single=false, $isMaster=false){

$sql = "SELECT $field FROM $table";

$sql .= trim($where)!='' ? " WHERE $where " : $where;

$sql .= trim($order)!='' ? " ORDER BY $order " : $order;

$sql .= trim($limit)!='' ? " LIMIT $limit " : $limit;

if ($single){

return $this->getRow($sql, $isMaster);

}

return $this->getAll($sql, $isMaster);

}

/**

* 获取指点各种条件的记录(跟getRecored类似)

* @param string $table 表名(访问的数据表)

* @param string $field 字段(要获取的字段)

* @param string $where 条件(获取记录的条件语句,不包括WHERE,默认为空)

* @param array $order_arr 排序数组(格式类似于: array('id'=>true), 那么就是按照ID为顺序排序, array('id'=>false), 就是按照ID逆序排序)

* @param array $limit_arr 提取数据的限制数组()

* @return unknown

function getRecordByWhere($table, $field='*', $where='', $arrOrder=array(), $arrLimit=array(), $isMaster=false){

$sql = " SELECT $field FROM $table ";

$sql .= trim($where)!='' ? " WHERE $where " : $where;

if (is_array($arrOrder) && !empty($arrOrder)){

$arrKey = key($arrOrder);

$sql .= " ORDER BY $arrKey " . ($arrOrder[$arrKey] ? "ASC" : "DESC");

}

if (is_array($arrLimit) && !empty($arrLimit)){

$startPos = intval(array_shift($arrLimit));

$offset = intval(array_shift($arrLimit));

$sql .= " LIMIT $startPos,$offset ";

}

return $this->getAll($sql, $isMaster);

}

/**

* 获取指定条数的记录

* @param string $table 表名

* @param int $startPos 开始记录

* @param int $offset 偏移量

* @param string $field 字段名

* @param string $where 条件(获取记录的条件语句,不包括WHERE,默认为空)

* @param string $order 排序(按照什么字段排序,不包括ORDER BY,默认为空)

* @return 成功返回包含记录的二维数组,失败返回false

function getRecordByLimit($table, $startPos, $offset, $field='*', $where='', $oder='', $isMaster=false){

$sql = " SELECT $field FROM $table ";

$sql .= trim($where)!='' ? " WHERE $where " : $where;

$sql .= trim($order)!='' ? " ORDER BY $order " : $order;

$sql .= " LIMIT $startPos,$offset ";

return $this->getAll($sql, $isMaster);

}

/**

* 获取排序记录

* @param string $table 表名

* @param string $orderField 需要排序的字段(比如id)

* @param string $orderMethod 排序的方式(1为顺序, 2为逆序, 默认是1)

* @param string $field 需要提取的字段(默认是*,就是所有字段)

* @param string $where 条件(获取记录的条件语句,不包括WHERE,默认为空)

* @param string $limit 限制记录(需要提取多少记录,不包括LIMIT,默认为空)

* @return 成功返回记录的二维数组,失败返回false

function getRecordByOrder($table, $orderField, $orderMethod=1, $field='*', $where='', $limit='', $isMaster=false){

//$order_method的值为1则为顺序, $order_method值为2则2则是逆序排列

$sql = " SELECT $field FROM $table ";

$sql .= trim($where)!='' ? " WHERE $where " : $where;

$sql .= " ORDER BY $orderField " . ( $orderMethod==1 ? "ASC" : "DESC");

$sql .= trim($limit)!='' ? " LIMIT $limit " : $limit;

return $this->getAll($sql, $isMaster);

}

/**

* 分页查询(限制查询的记录条数)

* @param string $sql 需要查询的SQL语句

* @param int $startPos 开始记录的条数

* @param int $offset 每次的偏移量,需要获取多少条

* @return 成功返回获取结果记录的二维数组,失败返回false

function limitQuery($sql, $startPos, $offset, $isMaster=false){

$start_pos = intval($startPos);

$offset = intval($offset);

$sql = $sql . " LIMIT $startPos,$offset ";

return $this->getAll($sql, $isMaster);

}

//--------------------------

// 无数据返回操作

//--------------------------

/**

* 执行执行非Select查询操作

* @param string $sql 查询SQL语句

* @return bool 成功执行返回true, 失败返回false

function execute($sql, $isMaster=false){

if (!$this->query($sql, $isMaster)){

return false;

}

return true;

// $count = @mysql_affected_rows($this->dbLink);

// if ($count <= 0){

// return false;

// }

// return true;

}

/**

* 自动执行操作(针对Insert/Update操作)

* @param string $table 表名

* @param array $field_array 字段数组(数组中的键相当于字段名,数组值相当于值, 类似 array( 'id' => 100, 'user' => 'heiyeluren')

* @param int $mode 执行操作的模式 (是插入还是更新操作, 1是插入操作Insert, 2是更新操作Update)

* @param string $where 如果是更新操作,可以添加WHERE的条件

* @return bool 执行成功返回true, 失败返回false

function autoExecute($table, $arrField, $mode, $where='', $isMaster=false){

if ($table=='' || !is_array($arrField) || empty($arrField)){

return false;

}

//$mode为1是插入操作(Insert), $mode为2是更新操作

if ($mode == 1){

$sql = " INSERT INTO `$table` SET ";

} elseif ($mode == 2) {

$sql = " UPDATE `$table` SET ";

} else {

$this->errorLog("Operate type '$mode' is error, in call DB::autoExecute process table $table.");

return false;

}

foreach ($arrField as $key => $value){

$sql .= "`$key`='$value',";

}

$sql = rtrim($sql, ',');

if ($mode==2 && $where!=''){

$sql .= "WHERE $where";

}

return $this->execute($sql, $isMaster);

}

/**

* 锁表表

* @param string $tblName 需要锁定表的名称

* @return mixed 成功返回执行结果，失败返回错误对象

function lockTable($tblName){

return $this->query("LOCK TABLES $tblName", true);

}

/**

* 对锁定表进行解锁

* @param string $tblName 需要锁定表的名称

* @return mixed 成功返回执行结果，失败返回错误对象

function unlockTable($tblName){

return $this->query("UNLOCK TABLES $tblName", true);

}

/**

* 设置自动提交模块的方式（针对InnoDB存储引擎）

* 一般如果是不需要使用事务模式，建议自动提交为1，这样能够提高InnoDB存储引擎的执行效率，如果是事务模式，那么就使用自动提交为0

* @param bool $autoCommit 如果是true则是自动提交，每次输入SQL之后都自动执行，缺省为false

* @return mixed 成功返回true，失败返回错误对象

function setAutoCommit($autoCommit = false){

$autoCommit = ( $autoCommit ? 1 : 0 );

return $this->query("SET AUTOCOMMIT = $autoCommit", true);

}

/**

* 开始一个事务过程（针对InnoDB引擎，兼容使用 BEGIN 和 START TRANSACTION）

* @return mixed 成功返回true，失败返回错误对象

function startTransaction(){

if (!$this->query("BEGIN")){

return $this->query("START TRANSACTION", true);

}

/**

* 提交一个事务（针对InnoDB存储引擎）

* @return mixed 成功返回true，失败返回错误对象

function commit(){

if (!$this->query("COMMIT", true)){

return false;

}

return $this->setAutoCommit( true );

}

/**

* 发生错误，会滚一个事务（针对InnoDB存储引擎）

* @return mixed 成功返回true，失败返回错误对象

function rollback(){

if (!$this->query("ROLLBACK", true)){

return false;

}

return $this->setAutoCommit( true );

}

//--------------------------

// 其他数据相关操作

//--------------------------

/**

* 获取最后一次查询的SQL语句

* @return string 返回最后一次查询的SQL语句

function getLastSql(){

return $this->dbSql;

}

/**

* 获取上次插入操作的的ID

* @return int 如果没有连接或者查询失败,返回0, 成功返回ID

function getLastId(){

$dbConn = $this->getDbWriteConn();

if (($lastId = mysql_insert_id($dbConn)) > 0){

return $lastId;

}

return $this->getOne("SELECT LAST_INSERT_ID()", '', true);

}

/**

* 获取记录集里面的记录条数 (用于Select操作)

* @return int 如果上一次无结果集或者记录结果集为空,返回0, 否则返回结果集数量

function getNumRows($res=null){

if (!$res || !is_resource($res)){

$res = $this->dbResult;

}

return mysql_num_rows($res);

}

/**

* 获取受到影响的记录数量 (用于Update/Delete/Insert操作)

* @return int 如果没有连接或者影响记录为空, 否则返回影响的行数量

function getAffectedRows(){

if (!isset($this->wdbConn) || !is_resource($this->wdbConn)) {

$this->getDbWriteConn();

}

$dbConn = $this->wdbConn;

if ( ($affetedRows = mysql_affected_rows($dbConn)) <= 0){

return $affetedRows;

}

return $this->getOne("SELECT ROW_COUNT()", "", true);

}

测试代码文件：

<?php

/**

* 测试代码

//构造数据库配置信息

$masterConf = array("host"=>"localhost", "user"=>"root", "pwd"=>"", "db"=>"db");

$slaveConf = array("host"=>"localhost|localhost", "user"=>"root", "pwd"=>"", "db"=>"db");

//初始化类

$db = new DBCommon($masterConf, $slaveConf);

print_r($db);

//创建表

$db->execute("CREATE TABLE `tbl1` ( `id` INTEGER(11) NOT NULL AUTO_INCREMENT, `name` CHAR(32) DEFAULT NULL, `email` CHAR(64) DEFAULT NULL, PRIMARY KEY (`id`))ENGINE=MyISAM;");

//插入数据

$arrInsert = array("name" => "heiyeluren", "email"=>"heiyeluren@125.com");

$db->autoExecute("tbl1", $arrInsert, _DB_INSERT);

$arrInsert = array("name" => "heiyeluren2", "email"=>heiyeluren@128.com);

$db->autoExecute("tbl1", $arrInsert, _DB_INSERT);

$s = $db->getAffectedRows();

echo $s;

//获取数据

$s = $db->getAll("select * from tbl1");

print_r($s);

//选择其他数据库

$db->selectDb("test");

//关闭所有连接

$db->disconnect(null, true);

测试输出结果：

DBCommon Object

(

[wdbConf] => Array

(

[host] => localhost

[user] => root

[pwd] =>

[db] => db

)

[rdbConf] => Array

(

[host] => localhost|localhost

[user] => root

[pwd] =>

[db] => db

)

[wdbConn] =>

[rdbConn] => Array

(

)

[dbResult] =>

[dbRecord] =>

[dbSql] =>

[dbCharset] => UTF8

[dbVersion] => 4.1

[isInitConn] =>

[isCharset] => 1

[fetchMode] => 1

[isLog] => 1

[isExit] =>

)

Array

(

[0] => Array

(

[id] => 1

[name] => heiyeluren

[email] => heiyeluren@125.com

)

[1] => Array

(

[id] => 2

[name] => heiyeluren2

[email] => heiyeluren@

)

)128.com

【其他数据操作方法使用代码】

/**

* 示例代码

//构造数据库配置信息

$masterConf = array(

"host" => "192.168.0.1",

"user" => "root",

"pwd" => "",

"db" => "db"

);

$slaveConf = array(

"host" => "192.168.0.3|192.168.0.2",

"user" => "root",

"pwd" => "",

"db" => "db"

);

//初始化类

$db = new DBCommon($masterConf, $slaveConf);

//创建表

$db->execute("CREATE TABLE `tbl1` ( `id` INTEGER(11) NOT NULL AUTO_INCREMENT, `name` CHAR(32) DEFAULT NULL, `email` CHAR(64) DEFAULT NULL, PRIMARY KEY (`id`))ENGINE=MyISAM;");

//插入数据

$arrInsert = array(

"name" => "heiyeluren",

"email" => "heiyeluren@125.com"

);

$db->autoExecute("tbl1", $arrInsert, _DB_INSERT);

//更新数据

$arrUpdate = array(

"name" => "heiyeluren2",

"email" => "heiyeluren@1111.com"

);

$db->autoExecute("tbl1", $arrUpdate, _DB_UPDATE, "id = 1");

//获取操作影响的行

$s = $db->getAffectedRows();

//获取数据

//获取所有数据（二维数组）

$s = $db->getAll("select * from tbl1");

//获取一行数据（一维数组）

$s = $db->getRow("select * from tbl1 where id = 1");

//获取一列数据（一维数组）

$s = $db->getCol("select id from tbl1 where name LIKE '%heiyeluren%'");

//获取一个数据（直接返回数据）

$s = $db->getOne("select count(1) from tbl1");

//删除数据

$db->execute("delete from tbl1 where id = 1");

//选择其他数据库

$db->selectDb("test");

//关闭所有连接

$db->disconnect(null, true);

jun54555

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
应用memcached构建支持Master/Slave读写分离的数据库操作类

原文地址:http://blog.csdn.net/heiyeshuwu/archive/2007/07/30/1716041.aspx 一般对于访问量比较大的网站来说，采用基本的MySQL Master/Slave 结构是很正常，而且一般都是一台Master，多台Slave的情况，但是一般在进行这个访问的时候问题比较多，因为读写操作必须分离，所以今天没事就构造了这个数据
复制链接

扫一扫