首页 / MYSQL / mysql的两阶段提交协议

mysql的两阶段提交协议

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了mysql的两阶段提交协议，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含17964字，纯文字阅读大概需要26分钟。

内容图文

(1)先调用binglog_hton和innobase_hton的prepare方法完成第一阶段，binlog_hton的papare方法实际上什么也没做，innodb的prepare将事务状态设为TRX_PREPARED，并将redo log刷磁盘 (innobase_xa_prepare à trx_prepare_for_mysql à trx_prepare_off_kernel)。

(2)如果事务涉及的所有存储引擎的prepare都执行成功，则调用TC_LOG_BINLOG::log_xid将SQL语句写到binlog，此时，事务已经铁定要提交了。否则，调用ha_rollback_trans回滚事务，而SQL语句实际上也不会写到binlog。

(3)最后，调用引擎的commit完成事务的提交。实际上binlog_hton->commit什么也不会做(因为(2)已经将binlog写入磁盘)，innobase_hton->commit则清除undo信息，刷redo日志，将事务设为TRX_NOT_STARTED状态(innobase_commit à innobase_commit_low à trx_commit_for_mysql à trx_commit_off_kernel)。

//ha_innodb.cc

static

int

innobase_commit(

/*============*/

/* out: 0 */

THD* thd, /* in: MySQL thread handle of the user for whom

the transaction should be committed */

bool all) /* in: TRUE - commit transaction

FALSE - the current SQL statement ended */

{

...

trx->mysql_log_file_name = mysql_bin_log.get_log_fname();

trx->mysql_log_offset =

(ib_longlong)mysql_bin_log.get_log_file()->pos_in_file;

...

}

函数innobase_commit提交事务，先得到当前的binlog的位置，然后再写入事务系统PAGE(trx_commit_off_kernel à trx_sys_update_mysql_binlog_offset)。

InnoDB将MySQL binlog的位置记录到trx system header中：

//trx0sys.h

/* The offset of the MySQL binlog offset info in the trx system header */

#define TRX_SYS_MYSQL_LOG_INFO (UNIV_PAGE_SIZE - 1000)

#define TRX_SYS_MYSQL_LOG_MAGIC_N_FLD 0 /* magic number which shows

if we have valid data in the

MySQL binlog info; the value

is ..._MAGIC_N if yes */

#define TRX_SYS_MYSQL_LOG_OFFSET_HIGH 4 /* high 4 bytes of the offset

within that file */

#define TRX_SYS_MYSQL_LOG_OFFSET_LOW 8 /* low 4 bytes of the offset

within that file */

#define TRX_SYS_MYSQL_LOG_NAME 12 /* MySQL log file name */

5.3.2 事务恢复流程

Innodb在恢复的时候，不同状态的事务，会进行不同的处理(见trx_rollback_or_clean_all_without_sess函数)：

<1>对于TRX_COMMITTED_IN_MEMORY的事务，清除回滚段，然后将事务设为TRX_NOT_STARTED；

<2>对于TRX_NOT_STARTED的事务，表示事务已经提交，跳过；

<3>对于TRX_PREPARED的事务，要根据binlog来决定事务的命运，暂时跳过;

<4>对于TRX_ACTIVE的事务，回滚。

MySQL在打开binlog时，会检查binlog的状态(TC_LOG_BINLOG::open)。如果binlog没有正常关闭(LOG_EVENT_BINLOG_IN_USE_F为1)，则进行恢复操作，基本流程如下：

mysql的两阶段提交协议 - 文章图片

<1>扫描binlog，读取XID_EVENT事务，得到所有已经提交的XA事务列表(实际上事务在innodb可能处于prepare或者commit)；

<2>对每个XA事务，调用handlerton::recover，检查存储引擎是否存在处于prepare状态的该事务(见innobase_xa_recover)，也就是检查该XA事务在存储引擎中的状态；

<3>如果存在处于prepare状态的该XA事务，则调用handlerton::commit_by_xid提交事务；

<4>否则，调用handlerton::rollback_by_xid回滚XA事务。

5.3.3 几个参数讨论

(1)sync_binlog

Mysql在提交事务时调用MYSQL_LOG::write完成写binlog，并根据sync_binlog决定是否进行刷盘。默认值是0，即不刷盘，从而把控制权让给OS。如果设为1，则每次提交事务，就会进行一次刷盘；这对性能有影响(5.6已经支持binlog group)，所以很多人将其设置为100。

bool MYSQL_LOG::flush_and_sync()

{

int err=0, fd=log_file.file;

safe_mutex_assert_owner(&LOCK_log);

if (flush_io_cache(&log_file))

return 1;

if (++sync_binlog_counter >= sync_binlog_period && sync_binlog_period)

{

sync_binlog_counter= 0;

err=my_sync(fd, MYF(MY_WME));

}

return err;

}

(2) innodb_flush_log_at_trx_commit

该参数控制innodb在提交事务时刷redo log的行为。默认值为1，即每次提交事务，都进行刷盘操作。为了降低对性能的影响，在很多生产环境设置为2，甚至0。

mysql的两阶段提交协议 - 文章图片



trx_flush_log_if_needed_low(
/*========================*/
    lsn_t    lsn)    /*!< in: lsn up to which logs are to be
            flushed. */
{
    switch (srv_flush_log_at_trx_commit) {
    case 0:
        /* Do nothing */
        break;
    case 1:
        /* Write the log and optionally flush it to disk */
        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP,
                srv_unix_file_flush_method != SRV_UNIX_NOSYNC);
        break;
    case 2:
        /* Write the log but do not flush it to disk */
        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);

        break;
    default:
        ut_error;
    }
}

If the value of innodb_flush_log_at_trx_commit is 0, the log buffer is written out to the log file once per second and the flush to disk operation is performed on the log file, but nothing is done at a transaction commit. When the value is 1 (the default), the log buffer is written out to the log file at each transaction commit and the flush to disk operation is performed on the log file. When the value is 2, the log buffer is written out to the file at each commit, but the flush to disk operation is not performed on it. However, the flushing on the log file takes place once per second also when the value is 2. Note that the once-per-second flushing is not 100% guaranteed to happen every second, due to process scheduling issues.

The default value of 1 is required for full ACID compliance. You can achieve better performance by setting the value different from 1, but then you can lose up to one second worth of transactions in a crash. With a value of 0, any mysqld process crash can erase the last second of transactions. With a value of 2, only an operating system crash or a power outage can erase the last second of transactions.

(3) innodb_support_xa

用于控制innodb是否支持XA事务的2PC，默认是TRUE。如果关闭，则innodb在prepare阶段就什么也不做；这可能会导致binlog的顺序与innodb提交的顺序不一致(比如A事务比B事务先写binlog，但是在innodb内部却可能A事务比B事务后提交)，这会导致在恢复或者slave产生不同的数据。

int

innobase_xa_prepare(

/*================*/

/* out: 0 or error number */

THD* thd, /* in: handle to the MySQL thread of the user

whose XA transaction should be prepared */

bool all) /* in: TRUE - commit transaction

FALSE - the current SQL statement ended */

{

…

if (!thd->variables.innodb_support_xa) {

return(0);

}

ver  mysql 5.7

bool trans_xa_commit(THD *thd)
{
  bool res= TRUE;
  enum xa_states xa_state= thd->transaction.xid_state.xa_state;
  DBUG_ENTER("trans_xa_commit");

  if (!thd->transaction.xid_state.xid.eq(thd->lex->xid))
  {
    /*
      xid_state.in_thd is always true beside of xa recovery procedure.
      Note, that there is no race condition here between xid_cache_search
      and xid_cache_delete, since we always delete our own XID
      (thd->lex->xid == thd->transaction.xid_state.xid).
      The only case when thd->lex->xid != thd->transaction.xid_state.xid
      and xid_state->in_thd == 0 is in the function
      xa_cache_insert(XID, xa_states), which is called before starting
      client connections, and thus is always single-threaded.
    */
    XID_STATE *xs= xid_cache_search(thd->lex->xid);
    res= !xs || xs->in_thd;
    if (res)
      my_error(ER_XAER_NOTA, MYF(0));
    else
    {
      res= xa_trans_rolled_back(xs);
      ha_commit_or_rollback_by_xid(thd, thd->lex->xid, !res);
      xid_cache_delete(xs);
    }
    DBUG_RETURN(res);
  }

  if (xa_trans_rolled_back(&thd->transaction.xid_state))
  {
    xa_trans_force_rollback(thd);
    res= thd->is_error();
  }
  else if (xa_state == XA_IDLE && thd->lex->xa_opt == XA_ONE_PHASE)
  {
    int r= ha_commit_trans(thd, TRUE);
    if ((res= MY_TEST(r)))
      my_error(r == 1 ? ER_XA_RBROLLBACK : ER_XAER_RMERR, MYF(0));
  }
  else if (xa_state == XA_PREPARED && thd->lex->xa_opt == XA_NONE)
  {
    MDL_request mdl_request;

    /*
      Acquire metadata lock which will ensure that COMMIT is blocked
      by active FLUSH TABLES WITH READ LOCK (and vice versa COMMIT in
      progress blocks FTWRL).

      We allow FLUSHer to COMMIT; we assume FLUSHer knows what it does.
    */
    mdl_request.init(MDL_key::COMMIT, "", "", MDL_INTENTION_EXCLUSIVE,
                     MDL_TRANSACTION);

    if (thd->mdl_context.acquire_lock(&mdl_request,
                                      thd->variables.lock_wait_timeout))
    {
      ha_rollback_trans(thd, TRUE);
      my_error(ER_XAER_RMERR, MYF(0));
    }
    else
    {
      DEBUG_SYNC(thd, "trans_xa_commit_after_acquire_commit_lock");

      if (tc_log)
        res= MY_TEST(tc_log->commit(thd, /* all */ true));
      else
        res= MY_TEST(ha_commit_low(thd, /* all */ true));

      if (res)
        my_error(ER_XAER_RMERR, MYF(0));
    }
  }
  else
  {
    my_error(ER_XAER_RMFAIL, MYF(0), xa_state_names[xa_state]);
    DBUG_RETURN(TRUE);
  }

  thd->variables.option_bits&= ~OPTION_BEGIN;
  thd->transaction.all.reset_unsafe_rollback_flags();
  thd->server_status&=
    ~(SERVER_STATUS_IN_TRANS | SERVER_STATUS_IN_TRANS_READONLY);
  DBUG_PRINT("info", ("clearing SERVER_STATUS_IN_TRANS"));
  xid_cache_delete(&thd->transaction.xid_state);
  thd->transaction.xid_state.xa_state= XA_NOTR;

  DBUG_RETURN(res);
}

5.3.4 安全性/性能讨论

上面3个参数不同的值会带来不同的效果。三者都设置为1(TRUE)，数据才能真正安全。sync_binlog非1，可能导致binlog丢失(OS挂掉)，从而与innodb层面的数据不一致。innodb_flush_log_at_trx_commit非1，可能会导致innodb层面的数据丢失(OS挂掉)，从而与binlog不一致。

关于性能分析，可以参考

http://www.mysqlperformanceblog.com/2011/03/02/what-is-innodb_support_xa/

http://www.mysqlperformanceblog.com/2009/01/21/beware-ext3-and-sync-binlog-do-not-play-well-together/

在事务提交时innobase会调用ha_innodb.cc 中的innobase_commit，而innobase_commit通过调用trx_commit_complete_for_mysql（trx0trx.c)来调用log_write_up_to（log0log.c),也就是当innobase提交事务的时候就会调用log_write_up_to来写redo log
innobase_commit中
if (all              # 如果是事务提交
                || (!thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) {
通过下面的代码实现事务的commit串行化
if (innobase_commit_concurrency > 0) {
                        pthread_mutex_lock(&commit_cond_m);
                        commit_threads++;

                        if (commit_threads > innobase_commit_concurrency) {
                                commit_threads--;
                                pthread_cond_wait(&commit_cond,
                                        &commit_cond_m);
                                pthread_mutex_unlock(&commit_cond_m);
                                goto retry;
                        }
                        else {
                                pthread_mutex_unlock(&commit_cond_m);
                        }
                }

                trx->flush_log_later = TRUE;   # 在做提交操作时禁止flush binlog 到磁盘
                innobase_commit_low(trx);
                trx->flush_log_later = FALSE;
先略过innobase_commit_low调用 ,下面开始调用trx_commit_complete_for_mysql做write日志操作
trx_commit_complete_for_mysql(trx);  #开始flush  log
trx->active_trans = 0;
在trx_commit_complete_for_mysql中，主要做的是对系统参数srv_flush_log_at_trx_commit值做判断来调用
log_write_up_to，或者write redo log file或者write&&flush to disk
if (!trx->must_flush_log_later) {
                /* Do nothing */
        } else if (srv_flush_log_at_trx_commit == 0) {  #flush_log_at_trx_commit=0，事务提交不写redo log
                /* Do nothing */
        } else if (srv_flush_log_at_trx_commit == 1) { #flush_log_at_trx_commit=1,事务提交写log并flush磁盘,如果flush方式不是SRV_UNIX_NOSYNC （这个不是很熟悉）
                if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {
                        /* Write the log but do not flush it to disk */

                        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
                } else {
                        /* Write the log to the log files AND flush them to
                        disk */

                        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);
                }
        } else if (srv_flush_log_at_trx_commit == 2) {   #如果是2，则只write到redo log

                /* Write the log but do not flush it to disk */

                log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
        } else {
                ut_error;
        }
那么下面看log_write_up_to
if (flush_to_disk              #如果flush到磁盘，则比较当前commit的lsn是否大于已经flush到磁盘的lsn
            && ut_dulint_cmp(log_sys->flushed_to_disk_lsn, lsn) >= 0) {

                mutex_exit(&(log_sys->mutex));

                return;
        }

if (!flush_to_disk       #如果不flush磁盘则比较当前commit的lsn是否大于已经写到所有redo log file的lsn,或者在只等一个group完成条件下是否大于已经写到某个redo file的lsn
            && (ut_dulint_cmp(log_sys->written_to_all_lsn, lsn) >= 0
                || (ut_dulint_cmp(log_sys->written_to_some_lsn, lsn)
                    >= 0
                    && wait != LOG_WAIT_ALL_GROUPS))) {

                mutex_exit(&(log_sys->mutex));

                return;
        }
#下面的代码判断是否log在write,有的话等待其完成
if (log_sys->n_pending_writes > 0) {
          if (flush_to_disk    # 如果需要刷新到磁盘，如果正在flush的lsn包括了commit的lsn，只要等待操作完成就可以了
                    && ut_dulint_cmp(log_sys->current_flush_lsn, lsn)
                    >= 0) {
                      goto do_waits;
                }

                if (!flush_to_disk  # 如果是刷到redo log file的那么如果在write的lsn包括了commit的lsn,也只要等待就可以了
                    && ut_dulint_cmp(log_sys->write_lsn, lsn) >= 0) {
                      goto do_waits;
                }
      ......
                if (!flush_to_disk  # 如果在当前IO空闲情况下 ，而且不需要flush到磁盘，那么 如果下次写的位置已经到达buf_free位置说明wirte操作都已经完成了，直接返回
                         && log_sys->buf_free == log_sys->buf_next_to_write) {
                             mutex_exit(&(log_sys->mutex));
                         return;
               }
下面取到group,设置相关write or flush相关字段，并且得到起始和结束位置的block号
log_sys->n_pending_writes++;

        group = UT_LIST_GET_FIRST(log_sys->log_groups);
        group->n_pending_writes++;      /* We assume here that we have only
                                        one log group! */

        os_event_reset(log_sys->no_flush_event);
        os_event_reset(log_sys->one_flushed_event);

        start_offset = log_sys->buf_next_to_write;
        end_offset = log_sys->buf_free;

        area_start = ut_calc_align_down(start_offset, OS_FILE_LOG_BLOCK_SIZE);
        area_end = ut_calc_align(end_offset, OS_FILE_LOG_BLOCK_SIZE);

        ut_ad(area_end - area_start > 0);

        log_sys->write_lsn = log_sys->lsn;

        if (flush_to_disk) {
                log_sys->current_flush_lsn = log_sys->lsn;
        }
log_block_set_checkpoint_no调用设置end_offset所在block的LOG_BLOCK_CHECKPOINT_NO为log_sys中下个检查点号
        log_block_set_flush_bit(log_sys->buf + area_start, TRUE);   # 这个没看明白
        log_block_set_checkpoint_no(
                log_sys->buf + area_end - OS_FILE_LOG_BLOCK_SIZE,
                log_sys->next_checkpoint_no);
保存不属于end_offset但在其所在的block中的数据到下一个空闲的block
ut_memcpy(log_sys->buf + area_end,
                  log_sys->buf + area_end - OS_FILE_LOG_BLOCK_SIZE,
                  OS_FILE_LOG_BLOCK_SIZE);
对于每个group调用log_group_write_buf写redo log buffer
while (group) {
                log_group_write_buf(
                        group, log_sys->buf + area_start,
                        area_end - area_start,
                        ut_dulint_align_down(log_sys->written_to_all_lsn,
                                             OS_FILE_LOG_BLOCK_SIZE),
                        start_offset - area_start);

                log_group_set_fields(group, log_sys->write_lsn);   # 计算这次写的lsn和offset来设置group->lsn和group->lsn_offset

                group = UT_LIST_GET_NEXT(log_groups, group);
        }
......
if (srv_unix_file_flush_method == SRV_UNIX_O_DSYNC) {  # 这个是什么东西
                /* O_DSYNC means the OS did not buffer the log file at all:
                so we have also flushed to disk what we have written */

                log_sys->flushed_to_disk_lsn = log_sys->write_lsn;

        } else if (flush_to_disk) {

                group = UT_LIST_GET_FIRST(log_sys->log_groups);

                fil_flush(group->space_id);         # 最后调用fil_flush执行flush到磁盘
                log_sys->flushed_to_disk_lsn = log_sys->write_lsn;
        }

接下来看log_group_write_buf做了点什么

在log_group_calc_size_offset中,从group中取到上次记录的lsn位置（注意是log files组成的1个环状buffer),并计算这次的lsn相对于上次的差值
# 调用log_group_calc_size_offset计算group->lsn_offset除去多个LOG_FILE头部长度后的大小，比如lsn_offset落在第3个log file上，那么需要减掉3*LOG_FILE_HDR_SIZE的大小
gr_lsn_size_offset = (ib_longlong)
       log_group_calc_size_offset(group->lsn_offset, group);
group_size = (ib_longlong) log_group_get_capacity(group); # 计算group除去所有LOG_FILE_HDR_SIZE长度后的DATA部分大小

# 下面是典型的环状结构差值计算
if (ut_dulint_cmp(lsn, gr_lsn) >= 0) {

                difference = (ib_longlong) ut_dulint_minus(lsn, gr_lsn);
        } else {
                difference = (ib_longlong) ut_dulint_minus(gr_lsn, lsn);

                difference = difference % group_size;

                difference = group_size - difference;
        }

        offset = (gr_lsn_size_offset + difference) % group_size;
# 最后算上每个log file 头部大小，返回真实的offset
     return(log_group_calc_real_offset((ulint)offset, group));
接着看

# 如果需要写的内容超过一个文件大小
if ((next_offset % group->file_size) + len > group->file_size) {

                write_len = group->file_size                # 写到file末尾
                        - (next_offset % group->file_size);
        } else {
                write_len = len;                              # 否者写len个block
        }

# 最后真正的内容就是写buffer了，如果跨越file的话另外需要写file log file head部分

if ((next_offset % group->file_size == LOG_FILE_HDR_SIZE)
            && write_header) {
                /* We start to write a new log file instance in the group */

                log_group_file_header_flush(group,
                                            next_offset / group->file_size,
                                            start_lsn);
                srv_os_log_written+= OS_FILE_LOG_BLOCK_SIZE;
                srv_log_writes++;
        }

# 调用fil_io来执行buffer写
if (log_do_write) {
                log_sys->n_log_ios++;

                srv_os_log_pending_writes++;

                fil_io(OS_FILE_WRITE | OS_FILE_LOG, TRUE, group->space_id,
                       next_offset / UNIV_PAGE_SIZE,
                       next_offset % UNIV_PAGE_SIZE, write_len, buf, group);

                srv_os_log_pending_writes--;

                srv_os_log_written+= write_len;
                srv_log_writes++;

mysql的两阶段提交协议

标签：

本文系统来源：http://www.cnblogs.com/zengkefu/p/5674863.html

内容总结

以上是互联网集市为您收集整理的mysql的两阶段提交协议全部内容，希望文章能够帮你解决mysql的两阶段提交协议所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/467539.html

来源：【匿名】

【上一篇】MySQL权限管理【下一篇】用IE远程创建Mysql数据库的简易程序

更多 ►

【mysql的两阶段提交协议】教程文章相关的互联网学习教程文章

MySQL主从服务器slave无法连接master：SSL连接错误：协议版本不匹配【代码】【图】

首次发文刚学2个月的小白在VM上练习主从复制时候遇到了一个错误：ERROR 2026 (HY000): SSL connection error: protocol version mismatch在查看Firewalls和selinux都关闭后，无奈了反复连接都是这个错误，换了服务器连接还是提示同样的错误，崩溃了最后解决方法是在主从服务器上分别在/etc/my.cnf文件下加入一行代码 skip_ssl 注意是两个都要加保存，重启mysqld然后可以连接了go on！主从复制还未完成，ing。。。原文：ht...

mysql交互协议解析——mysql包基础数据、mysql包基本格式

mysql交互协议是开发mysql周边组件常用的协议，如JDBC,libmysql等等。在此我们要认识到mysql交互协议其实是半双工的交互协议，至于为什么，这里就先挖个小坑，以后再填。在探讨mysql交互协议的格式之前，我们要理清一个小问题，就是mysql交互协议会用到的基本数据类型。1.整数类型这里的整数类型可以用来表示mysql数据类型中的整数类型、日期时间类型、DOUBLE、FLOAT类型、比特类型以及枚举类型等等。所有的mysql整数类型都是小端的...

mysql通信协议【代码】

MySQL通信报文结构长度使用3个字节表示，最大值16MByte.TypeNameDescriptionint<3>payload_lengthpayload的长度，按照the least significant byte first存储，3个字节的payload 长度和1个字节的序列号组合成报文头int<1>sequence_idSequence ID序列号stringpayload报文体，长度即为前面指定的payload长度payload 长度使用3个字节表示，小端字节序( the least significant byte first)。序列号使用一个字节表示，新command开始时，重...

GPL协议的MySQL数据库

网络上多数朋友担心甲骨文会对MySQL软件采用收费模式，多数朋友也不清楚MySQL开源到底是什么模式，开源=免费嘛?是很多的疑问？MySQL是遵守双重协议的，一个是GPL授权协议，一个是商用授权协议(注释：为解决其他企业用MySQL软件牟利或引用了MySQL的源代码而不想开源)，虽然mysqlops也有写关于MySQL版权的来龙去脉，但是这篇文章写更透彻与详尽，特转载ITPUB上的帖子，希望大家能够更加清晰!　　如果你用了我的 GPL软件，那么你的软件...

Mysql通信协议

Mysql四种通信协议（linux下本地连接的都是socket 其他都是tcp）当连接mysql时，使用-h127.0.0.1时，linux与unix下的连接协议为socket协议，windows下为memory协议。如： [root@mysql ~]# mysql -uandy -pandy -h127.0.0.1当连接mysql时，使用非-h127.0.0.1时，使用tcp/ip协议。如： [root@mysql ~]# mysql -uandy -pandy 以下详细描述了和MySQL server进行交互所使用各种不同通信协议：1.TCP/IP协议 > 传输控制协议(Transmis...

PHP5连接mysql5的认证协议问题_PHP教程

MYSQL 4.1以后, 采用了一种新的用户认证协议, 对于老的客户端会出现不支持认证协议的错误, 以下是官方网站的解决方法﹔ １Upgrade all client programs to use a 4.1.1 or newer client library. 更新客户端库，这需要更新PHP的扩展库，对于老的api PHP已经不提供了这样的扩展库了２When connecting to the server with a pre-4.1 client program, use an account that still has a pre-4.1-style password. 使用以前建立的账号连...

既然HTTP是无状态协议，mysql_close还有必要么？

既然是查一次连接一次，为什么还要关闭连接呢？还有上传图片，有个imagedestroy函数释放内存，如果我不释放呢，机器内存就一直傻乎乎让图片占着直到死机吗？回复讨论(解决方案) mysql不是http协议连接吧？只是tcp 最为完整的函数集合既然有 mysql_connect 当然也改有 mysql_close 另外，你没有注意到 mysql_close 并不能由 mysql_pconnect 所打开的连接不过需要指出的是你把毫不相干 HTTP协议...

既是HTTP是无状态协议，mysql_close还有必要么

既然HTTP是无状态协议，mysql_close还有必要么？既然是查一次连接一次，为什么还要关闭连接呢？还有上传图片，有个imagedestroy函数释放内存，如果我不释放呢，机器内存就一直傻乎乎让图片占着直到死机吗？------解决方案--------------------你的网站的访问者(他的电脑或手机)和你的web server(比如apache)之间的连接是http,mysql_connect建立的是你的web server和你的mysql server之间的连接(即使它们在一个机器上)如果忘记关闭数...

PHP5连接Mysql5的认证协议问题_PHP

使用LR的ODBC协议进行mysql数据库测试【代码】【图】

一、ODBC环境配置系统环境：Win7 64位系统 1、安装：mysql驱动程序_mysql-connector-odbc-5.1.6-win32 2、64位系统，那就在这个目录下C:\Windows\SysWOW64找到odbcad32.exe运行，配置mysql数据源（如果你是32位的，在C:\Windows\System32路径下）二、ODBC协议脚本编写 1、可以进行录制：步骤：安装SqlDbx，启动LR的VUGen，选择ODBC协议，进行录制。缺点：录制脚本复杂且难以理解，而且回放效果不好。2、手写代码：步骤：1连接...

GPL协议的MySQL数据库

虽然mysqlops也有写关于MySQL版权的来龙去脉，但是这篇文章写更透彻与详尽，特转载ITPUB上的帖子，希望大家能够更加清晰!如果你用了我的 GPL软件，那么你的软件也必须要开源，否则就不能使用我的软件，你是否把你的软件商用和我没关系Oracle 卖的不是软件的版权，而是技术服务MySQL作为一个开源数据库，几乎所有的用户都只是通过自己的程序去操作这个数据库，不涉及到改动源码的问题，根本不用去考虑是否要遵循 GPL的问题。只有在你...

Java业务逻辑结合MySQL实现登录注册(XMPP协议的运用)【代码】【图】

XMPP协议：通信协议是一种约定的规则，XMPP也无外乎是一种接口规则。简单的说XMPP协议是一种标记格式的文本串。举例：<msg><send>hxjava</send><content>helloworld</content></msg>学习了XMPP协议之后，就实现C/S的登录注册操作，这一次的登录操作就不像以前那样用一些Map容器存储数据了。存储数据要用数据库，这样不仅便于数据管理维护，而且数据不容易丢失，建立Map容器存储的话，程序关闭数据就消失了。我自己编写C/S登录程序应...

MySQL协议分析2【代码】【图】

协议头● 数据变成在网络里传输的数据,需要额外的在头部添加4 个字节的包头. . packet length(3字节), 包体的长度 . packet number(1字节), 从0开始的递增的 ● sql “select 1” 的网络协议是？协议头● packet length三个字节意味着MySQL packet最大16M大于16M则被分包(net_write_command, my_net_write) ● packet number分包从0开始,依次递增.每一次执行sql, packet_number清零(sql/net_serv.c:net_clear) 协议类型● han...