mys

先看几个shave的例句： 1）Have you shaved today?(不及物动词,《朗文当代》) 2）He prefer to shave himself before breakfast.（及物动词,《柯林斯》） 3）The nurse washed and shaved him.（及物动词,《牛津高阶》） 4）She had to call a barber to shave him..（及物动词,《柯林斯》） 从后两个例句可以看出,have myself shaved是可以接受的用法.

对于程序开发人员而言，目前使用最流行的两种后台数据库即为MySQL and SQL Server。这两者最基本的相似之处在于数据存储和属于查询系统。你可以使用SQL来访问这两种数据库的数据，因为它们都支持ANSI-SQL。还有，这两种数据库系统都支持二进制关键词和关键索引，这就大大地加快了查询速度。同时，二者也都提供支持XML的各种格式。除了在显而易见的软件价格上的区别之外，这两个产品还有什么明显的区别吗？在这二者之间你是如何选择的？让我们看看这两个产品的主要的不同之处，包括发行费用，性能以及它们的安全性。 根本的区别是它们遵循的基本原则 二者所遵循的基本原则是它们的主要区别：开放vs保守。SQL服务器的狭隘的，保守的存储引擎与MySQL服务器的可扩展，开放的存储引擎绝然不同。虽然你可以使用SQL服务器的Sybase引擎，但MySQL能够提供更多种的选择，如MyISAM, Heap, InnoDB, and Berkeley DB。MySQL不完全支持陌生的关键词，所以它比SQL服务器要少一些相关的数据库。同时，MySQL也缺乏一些存储程序的功能，比如MyISAM引擎联支持交换功能。 发行费用：MySQL不全是免费，但很便宜 当提及发行的费用，这两个产品采用两种绝然不同的决策。对于SQL服务器，获取一个免费的开发费用最常的方式是购买微软的Office或者Visual Studio的费用。但是，如果你想用于商业产品的开发，你必须还要购买SQL Server Standard Edition。学校或非赢利的企业可以不考虑这一附加的费用。 性能：先进的MySQL 纯粹就性能而言，MySQL是相当出色的，因为它包含一个缺省桌面格式MyISAM。MyISAM 数据库与磁盘非常地兼容而不占用过多的CPU和内存。MySQL可以运行于Windows系统而不会发生冲突，在UNIX或类似UNIX系统上运行则更好。你还可以通过使用64位处理器来获取额外的一些性能。因为MySQL在内部里很多时候都使用64位的整数处理。Yahoo!商业网站就使用MySQL 作为后台数据库。 当提及软件的性能，SQL服务器的稳定性要比它的竞争对手强很多。但是，这些特性也要付出代价的。比如，必须增加额外复杂操作，磁盘存储，内存损耗等等。如果你的硬件和软件不能充分支持SQL服务器，我建议你最好选择其他如DBMS数据库，因为这样你会得到更好的结果。 安全功能 MySQL有一个用于改变数据的二进制日志。因为它是二进制，这一日志能够快速地从主机上复制数据到客户机上。即使服务器崩溃，这一二进制日志也会保持完整，而且复制的部分也不会受到损坏。 在SQL服务器中，你也可以记录SQL的有关查询，但这需要付出很高的代价。 安全性 这两个产品都有自己完整的安全机制。只要你遵循这些安全机制，一般程序都不会出现什么问题。这两者都使用缺省的IP端口，但是有时候很不幸，这些IP也会被一些黑客闯入。当然，你也可以自己设置这些IP端口。 恢复性:先进的SQL服务器 恢复性也是MySQL的一个特点，这主要表现在MyISAM配置中。这种方式有它固有的缺欠，如果你不慎损坏数据库，结果可能会导致所有的数据丢失。然而，对于SQL服务器而言就表现得很稳键。SQL服务器能够时刻监测数据交换点并能够把数据库损坏的过程保存下来。 根据需要决定你的选择 对于这两种数据库，如果非要让我说出到底哪一种更加出色，也许我会让你失望。以我的观点，任一对你的工作有帮助的数据库都是很好的数据库，没有哪一个数据库是绝对的出色，也没有哪一个数据库是绝对的差劲。我想要告诉你的是你应该多从你自己的需要出发，即你要完成什么样的任务？而不要单纯地从软件的功能出发。 如果你想建立一个.NET服务器体系，这一体系可以从多个不同平台访问数据，参与数据库的管理，那么你可以选用SQL服务器。如果你想建立一个第三方站点，这一站点可以从一些客户端读取数据，那么MySQL将是最好的选择。 这两者数据库都能够在.NET或J2EE下运行正常，同样，都能够利用RAID。 1，优点分析：MYSQL短小精悍，容易上手，操作简单，免费供用的。相对其它数据库有特色又实用的语法多一些。SQL怎么也算是大型数据库，稳定，能做一般大系统的数据仓库，运行速度明显比MYSQL快N多（海量数据下这个优势显而易见）。 2，缺点分析：MYSQL难担当大系统的数据仓库，运行速度慢，不够稳定，有掉线的情况。SQL SERVER价格贵（当然没说5元盗版），使用起来比MYSQL要难一些，毕竟东西大了说道多点。 3，按你的补充（如何登录）：MySQL自己有文字界面客户端，用起来咋说也没鼠标点方便（不过习惯了也好），当然配对MYSQL有专业的客户端软件，我是用SQLYOG519版的，各种操作真的是很方便的说。SQL SERVER 就用自带的查询分析器登录了：） 两者的前提是数据库服务都带打开，而且你得知道安装时的用户名密码哦：） SQL-Server 2000 是微软公司开发的中型数据库，它的可视化方面做得很好，在安全性等方面功能非常强大，并且有微软的强大技术支持，当然价格比较昂贵，适合应用于中型系统。 MySQL是 MySQL·AB开发的小型数据库，基本上具有了数据库所需的所有功能，但是功能没有SQL-Server强大，技术支持也跟不上，但是价格便宜，在满足它的许可协议的情况下可以免费使用，适合于小型系统。 语言都是一样的(SQL)是结构化查询语言.

mysql-server是什么？mysql-server表示服务器，是服务端；它是mysql核心程序，生成管理数据库实例，数据库实例任务调度线程之类，并提供相关接口供不同客户端调用。mysql-server用于持久保存数据并为其提供查询接口（SQL）；可以托管多个数据库并处理这些数据库上的查询。server是DBMS面向物理层次，包含存储数据的一系列机制、处理方法的集成。可以把sql语句翻译成对内存和文件的操作，也就是说，server是直接操作文件的。举例：mysql-server类似于QQ公司安装在他们自己公司的服务器上的一个总的应用程序。

安装本地网站数据库这一环节，用户名：root 密码：root 要跟登录phpmyadmin数据库的用户名和密码保持一致，

MySQL空间扩展不仅提供了空间数据的存储能力，而且还具备一些空间运算能力，这些功能通过MySQL内建的几何函数实现。最简单的几何函数昨天已经有所涉及，也就是转换WTK的GEOMFROMTEXT和ASTEXT。除此以外，不同的几何对象还具有不同的功能函数。几何类的函数DIMENSION，返回对象的尺寸，-1为空，0为点（没有长度没有面积），1为线（有长度而没有面积），2为多边形（有面积）；ENVELOPE，返回最小边界矩形；GEOMERYTYPE，返回几何类型（字符串）SRID，所谓SRID是空间基准坐标指示符，表示一个几何类型的坐标系统。点对象的函数X，Y两个函数用于返回点的X坐标和Y坐标线对象的函数GLENGTH，返回线长ISCLOSED，是否为封闭线段NUMPOINTS，线段包含点的数目STARTPOINT，ENDPOINT，POINTN，分别返回起点，终点和指定位置的点多边形对象的函数AREA，返回多边形面积EXTERIORRING，返回线型的外环INTERIORRINGN，返回指定的内环（对于包含空洞的多边形）NUMINTERIORRINGS，返回空洞数目几何集合对象的函数GEOMETRYN，返回指定位置的几何类型NUMGEOMETRIES，返回对象数目空间分析操作函数OpenGIS的空间分析操作函数目前还没有被MySQL完全支持，包括作缓冲区、联合、切割等操作还不能通过MySQL直接完成。最小边界矩形空间关系函数MySQL提供了一组函数来判断几个对象和最小边界矩形的位置关系MBRCONTAINSMBRDISJOINTMBREQUALMBRINTERSECTSMBROVERLAPSMBRTOUCHESMBRWITHIN几何对象空间关系函数MySQL5尚未实现以下几何对象的空间关系分析功能。CONTAINSCROSSESDISJOINTDISTANCEEQUALSINTERSECTSOVERLAPSRELATEDTOUCHESWITHINMySQL中的GIS几何函数和空间分析函数标签：nta联合interior集合geojoin数据尺寸函数

llikemyscarves。scarf有两种复数形式。常见的形式是scarves，不常见的形式是scarfs。当scarf做名词时，它属于可数名词，scarf的复数形式是scarfs或scarves。scarf的复数为scarfs、scarves（常见），其意思是围巾、披巾、头巾，例如dressedincoatsandscarves身着大衣和围着围巾、awoollenscarf一条羊毛围巾等。scarf还可作动词，其意思是披嵌接、用围巾围，其第三人称单数为scarves。现在分词为scarfing。过去式为scarfed。过去分词是scarfed。

.test>begin;Query OK, 0 rows affected (0.00 sec)先删除7中的id=1,sessionb中删除ttid=1delete from t7 where id=1; Query OK, 1 row affected (0.01 sec) session B delete from tt where id=1; Query OK, 1 row affected (0.00 sec) sessionA: delete from tt where id=1; 等待卡住 sessionB; delete from t7 where id=1; ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction 产生死锁LATEST DETECTED DEADLOCK2016-05-09 16:47:14 7f8ee2154700* (1) TRANSACTION:TRANSACTION 4443, ACTIVE 36 sec starting index readmysql tables in use 1, locked 1LOCK WAIT 4 lock struct(s), heap size 1184, 2 row lock(s), undo log entries 1MySQL thread id 10, OS thread handle 0x7f8ee20f2700, query id 133 192.168.90.109 myadmin updatingdelete from tt where id=1* (1) WAITING FOR THIS LOCK TO BE GRANTED:RECORD LOCKS space id 36 page no 3 n bits 88 index PRIMARY of table test.tt trx id 4443 lock_mode X locks rec but not gap waitingRecord lock, heap no 10 PHYSICAL RECORD: n_fields 4; compact format; info bits 320: len 8; hex 8000000000000001; asc ;;1: len 6; hex 00000000115a; asc Z;;2: len 7; hex 3800000151037d; asc 8 Q };;3: len 4; hex 800003e8; asc ;;* (2) TRANSACTION:TRANSACTION 4442, ACTIVE 52 sec starting index read, thread declared inside InnoDB 5000mysql tables in use 1, locked 14 lock struct(s), heap size 1184, 2 row lock(s), undo log entries 1MySQL thread id 12, OS thread handle 0x7f8ee2154700, query id 134 192.168.90.109 myadmin updatingdelete from t7 where id=1* (2) HOLDS THE LOCK(S):RECORD LOCKS space id 36 page no 3 n bits 88 index PRIMARY of table test.tt trx id 4442 lock_mode X locks rec but not gapRecord lock, heap no 10 PHYSICAL RECORD: n_fields 4; compact format; info bits 320: len 8; hex 8000000000000001; asc ;;1: len 6; hex 00000000115a; asc Z;;2: len 7; hex 3800000151037d; asc 8 Q };;3: len 4; hex 800003e8; asc ;;* (2) WAITING FOR THIS LOCK TO BE GRANTED:RECORD LOCKS space id 29 page no 3 n bits 72 index PRIMARY of table test.t7 trx id 4442 lock_mode X locks rec but not gap waitingRecord lock, heap no 2 PHYSICAL RECORD: n_fields 4; compact format; info bits 320: len 4; hex 80000001; asc ;;1: len 6; hex 00000000115b; asc [;;2: len 7; hex 39000001e00827; asc 9 ‘;;3: len 2; hex 6161; asc aa;;* WE ROLL BACK TRANSACTION (2)看到这种也是因为互相请求对方不释放的资源导致的死锁

业务是从上游系统中下载数据文件，并对数据文件进行处理，有两个表：对账单表对账单详情表对账单表中记录对账单的基本信息，还有为了提高统计速度而设计了一个统计字段，如正在下载的个数、下载成功/失败的个数、正在处理的个数、处理成功/失败的个数。需要处理的文件保存在对账单详情表中，当某文件的状态变化时，同时修改对账单详情表中的统计数据（加1或减1）。在多线程处理的过程中，当两个线程同时修改同一个对账单记录时，会发生死锁。我尝试过事务的隔离级别，在RC、RR和SERIALIZABLE中都会有死锁发生。死锁日志如下：------------------------LATEST DETECTED DEADLOCK------------------------2021-09-06 05:35:09 0x7f9d8efff700*** (1) TRANSACTION:TRANSACTION 1292232, ACTIVE 0 sec starting index readmysql tables in use 1, locked 1LOCK WAIT 7 lock struct(s), heap size 1128, 3 row lock(s), undo log entries 2MariaDB thread id 135, OS thread handle 140314685732608, query id 1327193 172.17.0.1 root UpdatingUPDATE bill SET processing=processing-1, process_fail=process_fail+1 WHERE id=621*** WAITING FOR THIS LOCK TO BE GRANTED:RECORD LOCKS space id 253 page no 3 n bits 24 index PRIMARY of table `ziwu2_ds`.`bill` trx id 1292232 lock_mode X locks rec but not gap waitingRecord lock, heap no 11 PHYSICAL RECORD: n_fields 19; compact format; info bits 0 0: len 4; hex 0000026d; asc m;; 1: len 6; hex 00000013b7bf; asc ;; 2: len 7; hex 4d000001b70ed6; asc M ;; 3: len 1; hex 01; asc ;; 4: len 1; hex 01; asc ;; 5: SQL NULL; 6: len 5; hex 99a7b20000; asc ;; 7: SQL NULL; 8: len 5; hex 99aa8c5261; asc Ra;; 9: SQL NULL; 10: len 1; hex 01; asc ;; 11: len 4; hex 80000ad7; asc ;; 12: len 4; hex 80000004; asc ;; 13: len 4; hex 8000053a; asc :;; 14: len 4; hex 80000000; asc ;; 15: len 4; hex 80000001; asc ;; 16: len 4; hex 80000000; asc ;; 17: len 4; hex 80000537; asc 7;; 18: len 4; hex 90289ab9; asc ( ;;*** CONFLICTING WITH:RECORD LOCKS space id 253 page no 3 n bits 24 index PRIMARY of table `ziwu2_ds`.`bill` trx id 1292232 lock mode S locks rec but not gapRecord lock, heap no 11 PHYSICAL RECORD: n_fields 19; compact format; info bits 0 0: len 4; hex 0000026d; asc m;; 1: len 6; hex 00000013b7bf; asc ;; 2: len 7; hex 4d000001b70ed6; asc M ;; 3: len 1; hex 01; asc ;; 4: len 1; hex 01; asc ;; 5: SQL NULL; 6: len 5; hex 99a7b20000; asc ;; 7: SQL NULL; 8: len 5; hex 99aa8c5261; asc Ra;; 9: SQL NULL; 10: len 1; hex 01; asc ;; 11: len 4; hex 80000ad7; asc ;; 12: len 4; hex 80000004; asc ;; 13: len 4; hex 8000053a; asc :;; 14: len 4; hex 80000000; asc ;; 15: len 4; hex 80000001; asc ;; 16: len 4; hex 80000000; asc ;; 17: len 4; hex 80000537; asc 7;; 18: len 4; hex 90289ab9; asc ( ;;*** (2) TRANSACTION:TRANSACTION 1292231, ACTIVE 0 sec starting index readmysql tables in use 1, locked 1LOCK WAIT 4 lock struct(s), heap size 1128, 2 row lock(s), undo log entries 1MariaDB thread id 152, OS thread handle 140314907342592, query id 1327189 172.17.0.1 root UpdatingUPDATE bill SET downloading=downloading+1 WHERE id=621*** WAITING FOR THIS LOCK TO BE GRANTED:RECORD LOCKS space id 253 page no 3 n bits 24 index PRIMARY of table `ziwu2_ds`.`bill` trx id 1292231 lock_mode X locks rec but not gap waitingRecord lock, heap no 11 PHYSICAL RECORD: n_fields 19; compact format; info bits 0 0: len 4; hex 0000026d; asc m;; 1: len 6; hex 00000013b7bf; asc ;; 2: len 7; hex 4d000001b70ed6; asc M ;; 3: len 1; hex 01; asc ;; 4: len 1; hex 01; asc ;; 5: SQL NULL; 6: len 5; hex 99a7b20000; asc ;; 7: SQL NULL; 8: len 5; hex 99aa8c5261; asc Ra;; 9: SQL NULL; 10: len 1; hex 01; asc ;; 11: len 4; hex 80000ad7; asc ;; 12: len 4; hex 80000004; asc ;; 13: len 4; hex 8000053a; asc :;; 14: len 4; hex 80000000; asc ;; 15: len 4; hex 80000001; asc ;; 16: len 4; hex 80000000; asc ;; 17: len 4; hex 80000537; asc 7;;

、实验环境Myql版本5.7.17-log实验表结构(root@localhost)[apex]>showcreatetabletest;+-------+-----------------------------------------------------------------------------------------------------------------------------------+|Table|CreateTable|+-------+-----------------------------------------------------------------------------------------------------------------------------------+|test|CREATETABLE`test`(`x`int(11)NOTNULL,`y`int(11)DEFAULTNULL,PRIMARYKEY(`x`))ENGINE=InnoDBDEFAULTCHARSET=gbk|+-------+-----------------------------------------------------------------------------------------------------------------------------------+1rowinset(0.01sec)插入数据(root@localhost)[apex]>insertintotestvalues(1,1);(root@localhost)[apex]>insertintotestvalues(2,2);(root@localhost)[apex]>insertintotestvalues(3,3);2、锁产生步骤会话一：开启事务，更新数据，不提交(root@localhost)[apex]>begin;QueryOK,0rowsaffected(0.00sec)(root@localhost)[apex]>updatetestsety=y+1wherex=1;QueryOK,1rowaffected(0.00sec)Rowsmatched:1Changed:1Warnings:0查看当前连接id号（线程id号）(root@localhost)[apex]>selectconnection_id();+-----------------+|connection_id()|+-----------------+|4|+-----------------+1rowinset(0.00sec)会话二：开启另一个事务，更新同一行数据，(root@localhost)[apex]>begin;QueryOK,0rowsaffected(0.00sec)(root@localhost)[apex]>updatetestsety=y+1wherex=1;ERROR1205(HY000):Lockwaittimeoutexceeded;tryrestartingtransaction执行update test set操作时，会卡在那边，不执行，经过50秒后，会报错；（上面的卡住现象，是由于锁，可以通过查看表information_schema.innodb_lock，获取锁的状态）(root@localhost)[information_schema]>select*frominformation_schema.innodb_locks;+-----------------+-------------+-----------+-----------+---------------+------------+------------+-----------+----------+-----------+|lock_id|lock_trx_id|lock_mode|lock_type|lock_table|lock_index|lock_space|lock_page|lock_rec|lock_data|+-----------------+-------------+-----------+-----------+---------------+------------+------------+-----------+----------+-----------+|757082:3279:3:2|757082|X|RECORD|`apex`.`test`|PRIMARY|3279|3|2|1||757081:3279:3:2|757081|X|RECORD|`apex`.`test`|PRIMARY|3279|3|2|1|+-----------------+-------------+-----------+-----------+---------------+------------+------------+-----------+----------+-----------+2rowsinset,1warning(0.00sec)查看当前连接id号（线程id号）(root@localhost)[apex]>selectconnection_id();+-----------------+|connection_id()|+-----------------+|5|+-----------------+1rowinset(0.00sec)以上说的50秒，是系统参数innodb_lock_wait_timeout决定的(root@localhost)[apex]>showvariableslike‘innodb_lock_wait_timeout‘;+--------------------------+-------+|Variable_name|Value|+--------------------------+-------+|innodb_lock_wait_timeout|50|+--------------------------+-------+1rowinset(0.00sec)3、mysql 如何查看未提交的事务方法一：(root@localhost)[performance_schema]>SELECT*FROMinformation_schema.INNODB_TRXG***************************1.row***************************trx_id:756996trx_state:RUNNINGtrx_started:2017-05-0815:08:07trx_requested_lock_id:NULLtrx_wait_started:NULLtrx_weight:3trx_mysql_thread_id:4trx_query:NULLtrx_operation_state:NULLtrx_tables_in_use:0trx_tables_locked:1trx_lock_structs:2trx_lock_memory_bytes:1136trx_rows_locked:1trx_rows_modified:1trx_concurrency_tickets:0trx_isolation_level:REPEATABLEREADtrx_unique_checks:1trx_foreign_key_checks:1trx_last_foreign_key_error:NULLtrx_adaptive_hash_latched:0trx_adaptive_hash_timeout:0trx_is_read_only:0trx_autocommit_non_locking:01rowinset(0.00sec)通过以上可看出线程id为4 一直未提交，事务开始的时间为2017-05-08 15:08:07。方法二：通过 show engine innodb statusG其中有一段关于事务的描述TRANSACTIONS------------Trxidcounter756998Purgedonefortrx‘sn:o<0undon:o<0state:runningbutidleHistorylistlength0LISTOFTRANSACTIONSFOREACHSESSION:---TRANSACTION421519065333360,notstarted0lockstruct(s),heapsize1136,0rowlock(s)---TRANSACTION421519065332448,notstarted0lockstruct(s),heapsize1136,0rowlock(s)---TRANSACTION756996,ACTIVE914sec2lockstruct(s),heapsize1136,1rowlock(s),undologentries1MySQLthreadid4,OSthreadhandle140041791522560,queryid25localhostroot从以上也可以看出线程id号为4的事务一直未提交。4、如何解决未提交的事务方法一：如果能知道哪个用户在执行这个操作，让他提交一下（这种可能性很小）方法二：kill掉这个线程id号，让事务回滚，(root@localhost)[information_schema]>showprocesslist;+----+-----------------+------------------+--------------------+---------+------+------------------------+------------------+|Id|User|Host|db|Command|Time|State|Info|+----+-----------------+------------------+--------------------+---------+------+------------------------+------------------+|1|event_scheduler|localhost|NULL|Daemon|4469|Waitingonemptyqueue|NULL||4|root|localhost|apex|Sleep|871||NULL||5|root|localhost|apex|Sleep|82||NULL||6|root|localhost|information_schema|Query|0|starting|showprocesslist||7|root|192.168.1.1:3708|NULL|Sleep|3221||NULL|+----+-----------------+------------------+--------------------+---------+------+------------------------+------------------+5rowsinset(0.00sec)(root@localhost)[information_schema]>kill4;QueryOK,0rowsaffected(0.01sec)本文出自 “corasql” 博客，请务必保留此出处http://corasql.blog.51cto.com/5908329/1923427mysql事务未提交导致锁等待如何解决标签：mysql q锁

项目中经常会用到自增id 比如uid 最简单的方法就是用直接用数据库提供的AUTO_INCREMENT 但是如果用户量非常大 几千万 几亿然后需要分表存储的时候呢 这种方案就搞不定了 所以最好有一个全局的自增ID的生成器 不管是否分表 都能从生成器中获取到全局自增的ID 实现方法应该有很多 不过所有的方案都需要解决一个问题 就是保证在高并发的情景下 数据获取依然正确 每次获取的ID都不会重复 这里我分享两种利用mysql的innodb的事务特性来实现的方案 一种是实现过了的 另一种没有试验过 不过应该也能走的通 先介绍第一种 在数据库中单独设置一张表 来存储ID 表有两个字段 一个是种类吧 一个就是ID 　　复制代码 代码如下: 　　CREATE TABLE auto_id( idname varchar( ) NOT NULL DEFAULT id bigint( ) NOT NULL DEFAULT MENT primary key(idname) )ENGINE=Innodb DEFAULT CHARSET=utf ; 接下来是一个存储过程 　　复制代码 代码如下: 　　delimiter // drop procedure if exists get_increment_id; create procedure get_increment_id(in idname_in varchar( ) in *** all_in bigint out id_out bigint) begin declare oldid bigint; start transaction; select id into oldid from maibo_auto_id where idname=idname_in for update; if oldid is NULL then insert into maibo_auto_id(idname id) value(idname_in *** all_in); set id_out= *** all_in; else update maibo_auto_id set id=id+ where idname=idname_in; set id_out=oldid+ ; end if; mit; end; // 重点是这句 select id into oldid from maibo_auto_id where idname=idname_in for update 会给相关数据加一个独占锁定 这时候别的进程如果来读取该条记录 就会进入等待 等待这个进程mit之后 再继续 这样就保证了在并发的情况下 不同的进程不会取到相同的值 如果你的前端是用php实现的 只需执行如下两个sql 就可以获取到 这个 *** all参数是定义的是从多少开始自增 　　复制代码 代码如下: 　　$sql = call get_increment_id( {$key} {$ *** all} @id) ; $ret = $db >getData( select @id ); 还有另外一种方法 就是利用mysql的auto_increment 先创建一张表 表里边只有一个自增字段 　　复制代码 代码如下: 　　create table test( `id` int( ) NOT NULL AUTO_INCREMENT MENT id primary key (id) )ENGINE=MyISAM AUTO_INCREMENT= DEFAULT CHARSET=utf ; 通过如下两条sql 　　复制代码 代码如下: 也能解决问题 LAST_INSERT_ID是不用查表的 而且只针对当前连接 也就是说别的连接的更新不会影响到当前连接的取值 这样可能每个ID都得弄一张表来维护 这也是缺点 具体使用中如何处理 就看自己的选择了 lishixinzhi/Article/program/MySQL/201405/30865

用工具如Navicat Premium 打开MySQL数据库的user表里可以看到。连接状态里可以查看用户名程序的配置文件里，有连接数据库的用户名你们。

前言GTID(Global Transaction ID)是MySQL5.6引入的功能，可以在集群全局范围标识事务，用于取代过去通过binlog文件偏移量定位复制位置的传统方式。借助GTID，在发生主备切换的情况下，MySQL的其它Slave可以自动在新主上找到正确的复制位置，这大大简化了复杂复制拓扑下集群的维护，也减少了人为设置复制位置发生误操作的风险。另外，基于GTID的复制可以忽略已经执行过的事务，减少了数据发生不一致的风险。GTID虽好，要想运用自如还需充分了解其原理与特性，特别要注意与传统的基于binlog文件偏移量复制方式不一样的地方。本文概述了关于GTID的几个常见问题，希望能对理解和使用基于GTID的复制有所帮助。GTID长什么样根据官方文档定义，GTID由source_id加transaction_id构成。GTID = source_id:transaction_id上面的source_id指示发起事务的MySQL实例，值为该实例的server_uuid。server_uuid由MySQL在第一次启动时自动生成并被持久化到auto.cnf文件里，transaction_id是MySQL实例上执行的事务序号，从1开始递增。 例如：e6954592-8dba-11e6-af0e-fa163e1cf111:1一组连续的事务可以用‘-‘连接的事务序号范围表示。例如e6954592-8dba-11e6-af0e-fa163e1cf111:1-5更一般的情况是GTID的集合。GTID集合可以包含来自多个source_id的事务，它们之间用逗号分隔；如果来自同一source_id的事务序号有多个范围区间，各组范围之间用冒号分隔，例如：e6954592-8dba-11e6-af0e-fa163e1cf111:1-5:11-18,e6954592-8dba-11e6-af0e-fa163e1cf3f2:1-27即，GTID集合拥有如下的形式定义：gtid_set:uuid_set [, uuid_set] ...| ‘‘uuid_set:uuid:interval[:interval]...uuid:hhhhhhhh-hhhh-hhhh-hhhh-hhhhhhhhhhhhh:[0-9|A-F]interval:n[-n](n >= 1)如何查看GTID可以通过MySQL的几个变量查看相关的GTID信息。gtid_executed在当前实例上执行过的GTID集合; 实际上包含了所有记录到binlog中的事务。所以，设置set sql_log_bin=0后执行的事务不会生成binlog 事件，也不会被记录到gtid_executed中。执行RESET MASTER可以将该变量置空。gtid_purgedbinlog不可能永远驻留在服务上，需要定期进行清理(通过expire_logs_days可以控制定期清理间隔)，否则迟早它会把磁盘用尽。gtid_purged用于记录已经被清除了的binlog事务集合，它是gtid_executed的子集。只有gtid_executed为空时才能手动设置该变量，此时会同时更新gtid_executed为和gtid_purged相同的值。gtid_executed为空意味着要么之前没有启动过基于GTID的复制，要么执行过RESET MASTER。执行RESET MASTER时同样也会把gtid_purged置空，即始终保持gtid_purged是gtid_executed的子集。gtid_next会话级变量，指示如何产生下一个GTID。可能的取值如下:1）AUTOMATIC：自动生成下一个GTID，实现上是分配一个当前实例上尚未执行过的序号最小的GTID。2）ANONYMOUS：设置后执行事务不会产生GTID。3）显式指定的GTID：可以指定任意形式合法的GTID值，但不能是当前gtid_executed中的已经包含的GTID，否则，下次执行事务时会报错。这些变量可以通过show命令查看，比如：如何产生GTIDGTID的生成受gtid_next控制。 在Master上，gtid_next是默认的AUTOMATIC,即在每次事务提交时自动生成新的GTID。它从当前已执行的GTID集合（即gtid_executed）中，找一个大于0的未使用的最小值作为下个事务GTID。同时在binlog的实际的更新事务事件前面插入一条set gtid_next事件。以下是一条insert语句生成的binlog记录：在Slave上回放主库的binlog时，先执行set gtid_next ...，然后再执行真正的insert语句，确保在主和备上这条insert对应于相同的GTID。一般情况下，GTID集合是连续的，但使用多线程复制(MTS)以及通过gtid_next进行人工干预时会导致gtid空洞。比如下面这样：继续执行事务，MySQL会分配一个最小的未使用GTID，也就是从出现空洞的地方分配GTID，最终会把空洞填上。这意味着严格来说我们即不能假设GTID集合是连续的，也不能假定GTID序号大的事务在GTID序号小的事务之后执行，事务的顺序应由事务记录在binlog中的先后顺序决定。GTID的持久化GTID相关的信息存储在binlog文件中，为此MySQL5.6新增了下面2个binlog事件。Previous_gtids_log_event在每个binlog文件的开头部分，记录在该binlog文件之前已执行的GTID集合。Gtid_log_event即前面看到的set gtid_next ...,它出现在每个事务的前面，表明下一个事务的gtid。示例如下：MySQL服务器启动时，通过读binlog文件，初始化gtid_executed和gtid_purged,使它们的值能和上次MySQL运行时一致。gtid_executed被设置为最新的binlog文件中Previous_gtids_log_event和所有Gtid_log_event的并集。gtid_purged为最老的binlog文件中Previous_gtids_log_event。由于这两个重要的变量值记录在binlog中，所以开启gtid_mode时必须同时在主库上开启log_bin在备库上开启log_slave_updates。但是，在MySQL5.7中没有这个限制。MySQL5.7中，新增加一个系统表mysql.gtid_executed用于持久化已执行的GTID集合。当主库上没有开启log_bin或在备库上没有开启log_slave_updates时，mysql.gtid_executed会跟用户事务一起每次更新。否则只在binlog日志发生rotation时更新mysql.gtid_executed。如何配置基于GTID的复制MySQL服务器的my.cnf配置文件中增加GTID相关的参数log_bin= /mysql/binlog/mysql_binlog_slave_updates= truegtid_mode= ONenforce_gtid_consistency= truerelay_log_info_repository = TABLErelay_log_recovery= ON然后在Slave上指定MASTER_AUTO_POSITION = 1执行CHANGE MASTER TO即可。比如：CHANGE MASTER TO MASTER_HOST=‘node1‘,MASTER_USER=‘repl‘,MASTER_PASSWORD=‘repl‘,MASTER_AUTO_POSITION=1;基于GTID的复制如何工作在MASTER_AUTO_POSITION = 1的情况下 ，MySQL会使用COM_BINLOG_DUMP_GTID协议进行复制。过程如下：备库发起复制连接时，将自己的已接受和已执行的gtids的并集(后面称为slave_gtid_executed)发送给主库。即下面的集合：UNION(@@global.gtid_executed, Retrieved_gtid_set - last_received_GTID)主库将自己的gtid_executed与slave_gtid_executed的差集的binlog发送给Slave。主库的binlog dump过程如下：检查slave_gtid_executed是否是主库gtid_executed的子集，如否那么主备数据可能不一致，报错。检查主库的purged_executed是否是slave_gtid_executed的子集，如否代表缺失备库需要的binlog,报错从最后一个Binlog开始扫描，获取文件头部的PREVIOUS_GTIDS_LOG_EVENT，如果它是slave_gtid_executed的子集，则这是需要发送给Slave的第一个binlog文件，否则继续向前扫描。从第3步找到的binlog文件的开头读取binlog记录，判断binlog记录是否已被包含在slave_gtid_executed中，如果已包含跳过不发送。从上面的过程可知，在指定MASTER_AUTO_POSITION = 1时，Master发送哪些binlog记录给Slave，取决于Slave的gtid_executed和Retrieved_Gtid_Set以及Master的gtid_executed，和relay_log_info以及master_log_info中保存的复制位点没有关系。如何修复复制错误在基于GTID的复制拓扑中，要想修复Slave的SQL线程错误，过去的SQL_SLAVE_SKIP_COUNTER方式不再适用。需要通过设置gtid_next或gtid_purged完成，当然前提是已经确保主从数据一致，仅仅需要跳过复制错误让复制继续下去。比如下面的场景：在从库上创建表tb1mysql> set sql_log_bin=0;Query OK, 0 rows affected (0.00 sec)mysql> create table tb1(id int primary key,c1 int);Query OK, 0 rows affected (1.06 sec)mysql> set sql_log_bin=1;Query OK, 0 rows affected (0.00 sec)在主库上创建表tb1：mysql> create table tb1(id int primary key,c1 int);Query OK, 0 rows affected (1.06 sec)由于从库上这个表已经存在，从库的复制SQL线程出错停止。上面的输出可以知道，从库已经执行过的事务是‘e10c75be-5c1b-11e6-ab7c-000c296078ae:1-5‘,执行出错的事务是‘e10c75be-5c1b-11e6-ab7c-000c296078ae:6‘，当前主备的数据其实是一致的，可以通过设置gtid_next跳过这个出错的事务。在从库上执行以下SQL：mysql> set gtid_next=‘e10c75be-5c1b-11e6-ab7c-000c296078ae:6‘;Query OK, 0 rows affected (0.00 sec)mysql> begin;Query OK, 0 rows affected (0.00 sec)mysql> commit;Query OK, 0 rows affected (0.00 sec)mysql> set gtid_next=‘AUTOMATIC‘;Query OK, 0 rows affected (0.00 sec)mysql> start slave;Query OK, 0 rows affected (0.02 sec)设置gtid_next的方法一次只能跳过一个事务，要批量的跳过事务可以通过设置gtid_purged完成。假设下面的场景：主库上已执行的事务从库上已执行的事务假设经过修复从库已经和主库的数据一致了，但由于复制错误Slave的SQL线程依然处于停止状态。现在可以通过把从库的gtid_purged设置为和主库的gtid_executed一样跳过不一致的GTID使复制继续下去，步骤如下。在从库上执行此时从库的Executed_Gtid_Set已经包含了主库上‘1-10‘的事务，再开启复制会从后面的事务开始执行，就不会出错了。mysql> start slave;Query OK, 0 rows affected (0.01 sec)使用gtid_next和gtid_purged修复复制错误的前提是，跳过那些事务后仍可以确保主备数据一致。如果做不到，就要考虑pt-table-sync或者拉备份的方式了。GTID与备份恢复在做备份恢复的时候，有时需要恢复出来的MySQL实例可以作为Slave连上原来的主库继续复制，这就要求从备份恢复出来的MySQL实例拥有和数据一致的gtid_executed值。这也是通过设置gtid_purged实现的，下面看下mysqldump做备份的例子。1、通过mysqldump进行备份通过mysqldump做一个全量备份：[root@node1 ~]# mysqldump --all-databases --single-transaction --routines --events --host=127.0.0.1 --port=3306 --user=root > dump.sql生成的dump.sql文件里包含了设置gtid_purged的语句SET @MYSQLDUMP_TEMP_LOG_BIN = @@SESSION.SQL_LOG_BIN;SET @@SESSION.SQL_LOG_BIN= 0;...SET @@GLOBAL.GTID_PURGED=‘e10c75be-5c1b-11e6-ab7c-000c296078ae:1-10‘;...SET @@SESSION.SQL_LOG_BIN = @MYSQLDUMP_TEMP_LOG_BIN;恢复数据前需要先通过reset master清空gtid_executed变量[root@node2 ~]# mysql -h127.1 -e ‘reset master‘[root@node2 ~]# mysql -h127.1 <dump.sql否则执行设置GTID_PURGED的SQL时会报下面的错误ERROR 1840 (HY000) at line 24: @@GLOBAL.GTID_PURGED can only be set when @@GLOBAL.GTID_EXECUTED is empty.此时恢复出的MySQL实例的GTID_EXECUTED和备份时点一致：由于恢复出的MySQL实例已经被设置了正确的GTID_EXECUTED，以master_auto_postion = 1的方式CHANGE MASTER到原来的主节点即可开始复制。CHANGE MASTER TO MASTER_HOST=‘node1‘, MASTER_USER=‘repl‘, MASTER_PASSWORD=‘repl‘, MASTER_AUTO_POSITION = 1如果不希望备份文件中生成设置GTID_PURGED的SQL，可以给mysqldump传入--set-gtid-purged=OFF关闭。2、通过Xtrabackup进行备份相比mysqldump，Xtrabackup是效率更高并且被广泛使用的备份方式。使用Xtrabackup进行备份的举例如下。通过Xtrabackup创一个全量备份（可以在Slave上创建备份，以避免对主库的性能冲击）innobackupex --defaults-file=/etc/my.cnf --host=127.1 --user=root --password=mysql --no-timestamp --safe-slave-backup --slave-info /mysql/bak应用日志innobackupex --apply-log /mysql/bak查看备份目录中的xtrabackup_binlog_info文件可以找到备份时已经执行过的gtids[root@node2 ~]# cat /mysql/bak/xtrabackup_binlog_infomysql_bin.000001191e10c75be-5c1b-11e6-ab7c-000c296078ae:1-10由于备份时添加了”--slave-info”选项并且从Slave节点拉取的备份，所以会生成xtrabackup_slave_info文件，也可以从这个文件里查找建立复制的SQL语句。[root@node2 ~]# cat /mysql/bak/xtrabackup_slave_infoSET GLOBAL gtid_purged=‘e10c75be-5c1b-11e6-ab7c-000c296078ae:1-10‘;CHANGE MASTER TO MASTER_AUTO_POSITION=1将备份文件传送到新的节点node3的/mysql/bak目录并恢复(如果直接把备份传输到数据目录了，这一步可以省略)。[root@node3 ~]# innobackupex --defaults-file=/etc/my.cnf --copy-back /mysql/bak启动MySQL。[root@node3 ~]# mysqld --defaults-file=/home/mysql/etc/my.cnf --skip-slave-start &如果是从Slave拉的备份，一定不能直接开启Slave复制，这时的gtid_executed是错误的。需要手动设置gtid_purged后再start slaveMASTER_HOST=‘node1‘,MASTER_USER=‘repl‘,MASTER_PASSWORD=‘repl‘,MASTER_AUTO_POSITION=1;start slave;GTID与MHAMHA是被广泛使用MySQL HA组件，MHA 0.56以后支持基于GTID的复制。 MHA在failover时会自动判断是否是GTID based failover，需要满足下面3个条件即为GTID based failover所有节点gtid_mode=1所有节点Executed_Gtid_Set不为空至少一个节点Auto_Position=1和之前的基于binlog文件位置的复制相比，基于GTID复制下，MHA在故障切换时的变化主要如下：基于binlog文件位置的复制在Master宕机后会尝试从Master上拷贝binlog日志进行补偿如果候选Master不拥有最新的relay log，会从拥有最新relay log的Slave上生成差异的binlog传送到候选Master并实施补偿新Master的日志补偿完成后，同样采用应用差异binlog的方式将其它Slave和新Master同步后再change master到新Master基于GTID的复制如果候选Master不拥有最新的relay log，让候选Master连上拥有最新relay log的Salve进行补偿。尝试从binlog server上拉取缺失的binlog并应用新Master的数据同步到最新后，让其它的Slave连上新Master并等待数据完成同步。并且可以给masterha_master_switch传入--wait_until_gtid_in_sync=1参数使其不等其它Slave完成数据同步，以加快切换速度。GTID模式下MHA不会尝试从旧Master上拷贝binlog日志进行补偿，所以在MySQL进程crash而OS仍然健康的情况下，应尽量不要做主备切换而是原地重启MySQL，除非有其

MVCC(Mutil-Version Concurrency Control)，就是多版本并发控制。这种并发控制的方法，主要应用在RC和RR隔离级别的事务当中，利用执行select操作时，访问记录版本链，使得不同事物的读写，写读可以并发执行，提高系统性能。 Innodb 有两个隐藏字段 trx_id(事务id)和roll_pointer(回滚指针)。 transaction id ： innoDB里面每个事务有一个唯一的事务ID，叫作transaction id，它是在事务开始的时候向InnoDB的事务系统申请的，是按申请顺序严格递增的。 roll_pointer ： 指向上一事务版本的指针。 版本链 ： 是一个单链表结构，对于同一行数据，每一个事务对其进行更新的时候都会产生一个新的版本，就会存储在这个链表当中。 一个存储事务id的列表。 readview的几个参数： m_ids:表示活跃事务id列表 min_trx_id:活跃事务中的最小事务id max_trx_id:已创建的最大事务id creator_trx_id:当前的事务id。 readview的生成时机： RC隔离级别：每次读取数据前，都生成一个readview； RR隔离级别：在第一次读取数据前，生成一个readview； 使用场景： [ 创建事务节点 ] 当我创建一个新的事务需要读取一行数据, 我会查询活跃的事务列表; 假设我当前的事务id是200, 当前活跃的事务id没有我的200, 因此需要去拷贝一个最新的不活跃事务并在版本链最后插入一个新节点200; mysql会去对比版本链和readView, 假设版本链数据为[1,50,100,150], 活跃列表为[100,150], 说明100和150都是未提交的活跃事务, 再向前一个节点50不在活跃事务列表说明事务50已经提交, 所以事务200拷贝事务50并插入版本链最后, 且将200追加到readView活跃列表的最后一个元素 [ 使用事务节点 ] 当我再次进行200号事务的查询或修改, 我需要读版本链的数据, 因为上一次操作已经在版本链做了200号节点, 因此我读的数据都是200号节点的数据, 这样就隔离了其他未提交的事务; 我的全部增删查改都在200号版本链上进行 [ readView实现事务隔离级别 ]以上两点都是基于隔离级别"读已提交"来进行说明的; 当mysql设置为"可重复读"时, 不同事务仍然是保存在版本链的不同节点上, 只不过新的事务创建的时候拷贝了当下的readView列表, 只要新事物不提交就一直使用这个拷贝的活跃列表; 假设此时100号数据提交了, 我在新事务执行了select 会去查活跃列表发现100号事务还是未提交状态, 因此读取到的还是50号事务提交的记录。 原子性，一致性，隔离性，持久性。 未提交读（read uncommitted）、提交读（read committed）、可重复读（repeatable read）、序列化读（serializable）

应该是：环境的

Capo on 2nd FretRiff 1E|-------------|B|-------------|G|-------------|D|-------------|A|-------------|E|-2-1-0-------|Bm F#5 Bm F#5It"s not so easy loving meRiff1 Em7It gets so complicated Em9 F#7All the things you gotta be Bm F#5Everything"s changing Bm F#5But you"re the truthRiff1 Em7I"m amazed by all your patience Em9 F#7Everything I put you throughEm9 F#7And when I"m about to fall BmSomehow you"re always waiting D9Your open arms to catch meEm9 F#7 BmYou"re gonna save me from myself D9From myself, yesEm9 F#7 Bm F#5You"re gonna save me from myself Bm F#5 Bm F#5My love is tainted by your touchRiff1 Em7Well some guys have shown me aces Em9 F#7But you"ve got that royal flush Bm F#5 Bm F#5I know it"s crazy everydayRiff1 Em7Well tomorrow maybe shaky Em9 F#7But you never turn awayEm9 F#7Don"t ask me why I"m crying Bm"Cause when I start to crumble D9You know how to keep me smilingEm9 F#7 BmYou always save me from myself D9From myself, myselfEm9 F#7 Em7You"re gonna save me from myselfI know it"s hard, it"s hardBmBut you"ve broken all my wallsEm7You"ve been my strength, so strong Em9 F#7And don"t ask me why I love you BmIt"s obvious your tenderness D9Is what I need to make meEm9 F#7A better woman to myselfBm D9To myself, myselfEm9 F#7 BmYou"re gonna save me from my myselfChords Used:BmE|-x-B|-3-G|-4-D|-4-A|-2-E|-x-F#5E|-x-B|-2-G|-2-D|-2-A|-4-E|-2-Em9E|-X-B|-3-G|-4-D|-3-A|-X-E|-3-F#7E|-X-B|-2-G|-3-D|-2-A|-X-E|-2-D9E|-X-B|-5-G|-5-D|-4-A|-5-E|-X-

NoSQL NoSQL，指的是非关系型的数据库。随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。 简介 NoSQL(NoSQL = Not Only SQL )，意即反SQL运动，是一项全新的数据库革命性运动，早期就有人提出，发展至2009年趋势越发高涨。NoSQL的拥护者们提倡运用非关系型的数据存储，相对于目前铺天盖地的关系型数据库运用，这一概念无疑是一种全新的思维的注入。 现今状况 现今的计算机体系结构在数据存储方面要求具备庞大的水平扩展性①，而NoSQL致力于改变这一现状。目前Google的 BigTable 和Amazon 的Dynamo使用的就是NoSQL型数据库。 NoSQL项目的名字上看不出什么相同之处，但是，它们通常在某些方面相同：它们可以处理超大量的数据。 这场革命目前仍然需要等待。的确，NoSQL对大型企业来说还不是主流，但是，一两年之后很可能就会变个样子。在NoSQL运动的最新一次聚会中，来自世界各地的150人挤满了CBS Interactive的一间会议室。分享他们如何推翻缓慢而昂贵的关系数据库的暴政，怎样使用更有效和更便宜的方法来管理数据。 “关系型数据库给你强加了太多东西。它们要你强行修改对象数据，以满足RDBMS （relational database management system，关系型数据库管理系统）的需要，”在NoSQL拥护者们看来，基于NoSQL的替代方案“只是给你所需要的”。 ①水平扩展性(horizontal scalability)指能够连接多个软硬件的特性，这样可以将多个服务器从逻辑上看成一个实体。 我们为什么要使用NOSQL非关系数据库？ 随着互联网web2.0网站的兴起，非关系型的数据库现在成了一个极其热门的新领域，非关系数据库产品的发展非常迅速。而传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，例如： 1、High performance - 对数据库高并发读写的需求 web2.0网站要根据用户个性化信息来实时生成动态页面和提供动态信息，所以基本上无法使用动态页面静态化技术，因此数据库并发负载非常高，往往要达到每秒上万次读写请求。关系数据库应付上万次SQL查询还勉强顶得住，但是应付上万次SQL写数据请求，硬盘IO就已经无法承受了。其实对于普通的BBS网站，往往也存在对高并发写请求的需求。 2、Huge Storage - 对海量数据的高效率存储和访问的需求 对于大型的SNS网站，每天用户产生海量的用户动态，以国外的Friendfeed为例，一个月就达到了2.5亿条用户动态，对于关系数据库来说，在一张2.5亿条记录的表里面进行SQL查询，效率是极其低下乃至不可忍受的。再例如大型web网站的用户登录系统，例如腾讯，盛大，动辄数以亿计的帐号，关系数据库也很难应付。 3、High Scalability && High Availability- 对数据库的高可扩展性和高可用性的需求 在基于web的架构当中，数据库是最难进行横向扩展的，当一个应用系统的用户量和访问量与日俱增的时候，你的数据库却没有办法像web server和app server那样简单的通过添加更多的硬件和服务节点来扩展性能和负载能力。对于很多需要提供24小时不间断服务的网站来说，对数据库系统进行升级和扩展是非常痛苦的事情，往往需要停机维护和数据迁移，为什么数据库不能通过不断的添加服务器节点来实现扩展呢？ 在上面提到的“三高”需求面前，关系数据库遇到了难以克服的障碍，而对于web2.0网站来说，关系数据库的很多主要特性却往往无用武之地，例如： 1、数据库事务一致性需求 很多web实时系统并不要求严格的数据库事务，对读一致性的要求很低，有些场合对写一致性要求也不高。因此数据库事务管理成了数据库高负载下一个沉重的负担。 2、数据库的写实时性和读实时性需求 对关系数据库来说，插入一条数据之后立刻查询，是肯定可以读出来这条数据的，但是对于很多web应用来说，并不要求这么高的实时性。 3、对复杂的SQL查询，特别是多表关联查询的需求 任何大数据量的web系统，都非常忌讳多个大表的关联查询，以及复杂的数据分析类型的复杂SQL报表查询，特别是SNS类型的网站，从需求以及产品设计角度，就避免了这种情况的产生。往往更多的只是单表的主键查询，以及单表的简单条件分页查询，SQL的功能被极大的弱化了。 因此，关系数据库在这些越来越多的应用场景下显得不那么合适了，为了解决这类问题的非关系数据库应运而生。 NoSQL 是非关系型数据存储的广义定义。它打破了长久以来关系型数据库与ACID理论大一统的局面。NoSQL 数据存储不需要固定的表结构，通常也不存在连接操作。在大数据存取上具备关系型数据库无法比拟的性能优势。该术语在 2009 年初得到了广泛认同。 当今的应用体系结构需要数据存储在横向伸缩性上能够满足需求。而 NoSQL 存储就是为了实现这个需求。Google 的BigTable与Amazon的Dynamo是非常成功的商业 NoSQL 实现。一些开源的 NoSQL 体系，如Facebook 的Cassandra， Apache 的HBase，也得到了广泛认同。从这些NoSQL项目的名字上看不出什么相同之处：Hadoop、Voldemort、Dynomite，还有其它很多。 NoSQL与关系型数据库设计理念比较 关系型数据库中的表都是存储一些格式化的数据结构，每个元组字段的组成都一样，即使不是每个元组都需要所有的字段，但数据库会为每个元组分配所有的字段，这样的结构可以便于表与表之间进行连接等操作，但从另一个角度来说它也是关系型数据库性能瓶颈的一个因素。而非关系型数据库以键值对存储，它的结构不固定，每一个元组可以有不一样的字段，每个元组可以根据需要增加一些自己的键值对，这样就不会局限于固定的结构，可以减少一些时间和空间的开销。 特点 它们可以处理超大量的数据。 它们运行在便宜的PC服务器集群上。 PC集群扩充起来非常方便并且成本很低，避免了“sharding”操作的复杂性和成本。 它们击碎了性能瓶颈。 NoSQL的支持者称，通过NoSQL架构可以省去将Web或Java应用和数据转换成SQL友好格式的时间，执行速度变得更快。 “SQL并非适用于所有的程序代码，” 对于那些繁重的重复操作的数据，SQL值得花钱。但是当数据库结构非常简单时，SQL可能没有太大用处。 没有过多的操作。 虽然NoSQL的支持者也承认关系数据库提供了无可比拟的功能集合，而且在数据完整性上也发挥绝对稳定，他们同时也表示，企业的具体需求可能没有那么多。 Bootstrap支持 因为NoSQL项目都是开源的，因此它们缺乏供应商提供的正式支持。这一点它们与大多数开源项目一样，不得不从社区中寻求支持。 缺点 但是一些人承认，没有正式的官方支持，万一出了差错会是可怕的，至少很多管理人员是这样看。 “我们确实需要做一些说服工作，但基本在他们看到我们的第一个原型运行良好之后，我们就能够说服他们，这是条正确的道路。” 此外，nosql并未形成一定标准，各种产品层出不穷，内部混乱，各种项目还需时间来检验。 NoSQL数据库开源软件 Membase Membase 是 NoSQL 家族的一个新的重量级的成员。Membase是开源项目，源代码采用了Apache2.0的使用许可。该项目托管在GitHub.Source tarballs上，目前可以 下载beta版本的Linux二进制包。该产品主要是由North Scale的memcached核心团队成员开发完成，其中还包括Zynga和NHN这两个主要贡献者的工程师，这两个组织都是很大的在线游戏和社区网络空间的供应商。 Membase容易安装、操作，可以从单节点方便的扩展到集群，而且为memcached（有线协议的兼容性）实现了即插即用功能，在应用方面为开 发者和经营者提供了一个比较低的门槛。做为缓存解决方案，Memcached已经在不同类型的领域（特别是大容量的Web应用）有了广泛的使用，其中 Memcached的部分基础代码被直接应用到了Membase服务器的前端。 通过兼容多种编程语言和框架，Membase具备了很好的复用性。在安装和配置方面，Membase提供了有效的图形化界面和编程接口，包括可配置 的告警信息。 Membase的目标是提供对外的线性扩展能力，包括为了增加集群容量，可以针对统一的节点进行复制。 另外，对存储的数据进行再分配仍然是必要的。 这方面的一个有趣的特性是NoSQL解决方案所承诺的可预测的性能，类准确性的延迟和吞吐量。通过如下方式可以获得上面提到的特性： ◆ 自动将在线数据迁移到低延迟的存储介质的技术（内存，固态硬盘，磁盘） ◆ 可选的写操作一一异步，同步（基于复制，持久化） ◆ 反向通道再平衡[未来考虑支持] ◆ 多线程低锁争用 ◆ 尽可能使用异步处理 ◆ 自动实现重复数据删除 ◆ 动态再平衡现有集群 ◆ 通过把数据复制到多个集群单元和支持快速失败转移来提供系统的高可用性。 MongoDB MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json的bjson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。它的特点是高性能、易部署、易使用，存储数据非常方便。 主要功能特性： ◆ 面向集合存储，易存储对象类型的数据 “面向集合”（Collenction-Orented），意思是数据被分组存储在数据集中，被称为一个集合（Collenction)。每个 集合在数据库中都有一个唯一的标识名，并且可以包含无限数目的文档。集合的概念类似关系型数据库（RDBMS）里的表（table），不同的是它不需要定 义任何模式（schema)。 ◆ 模式自由 模式自由（schema-free)，意味着对于存储在mongodb数据库中的文件，我们不需要知道它的任何结构定义。如果需要的话，你完全可以把不同结构的文件存储在同一个数据库里。 ◆支持动态查询 ◆支持完全索引，包含内部对象 ◆支持查询 ◆支持复制和故障恢复 ◆使用高效的二进制数据存储，包括大型对象（如视频等） ◆自动处理碎片，以支持云计算层次的扩展性 ◆支持RUBY，PYTHON，JAVA，C++，PHP等多种语言 ◆文件存储格式为BSON（一种JSON的扩展） BSON（Binary Serialized document Format）存储形式是指：存储在集合中的文档，被存储为键-值对的形式。键用于唯一标识一个文档，为字符串类型，而值则可以是各中复杂的文件类型。 ◆可通过网络访问 MongoDB服务端可运行在Linux、Windows或OS X平台，支持32位和64位应用，默认端口为27017。推荐运行在64位平台，因为MongoDB在32位模式运行时支持的最大文件尺寸为2GB。 MongoDB把数据存储在文件中（默认路径为：/data/db），为提高效率使用内存映射文件进行管理。 Hypertable Hypertable是一个开源、高性能、可伸缩的数据库，它采用与Google的Bigtable相似的模型。在过去数年中，Google为在PC集群 上运行的可伸缩计算基础设施设计建造了三个关键部分。第一个关键的基础设施是Google File System（GFS），这是一个高可用的文件系统，提供了一个全局的命名空间。它通过跨机器（和跨机架）的文件数据复制来达到高可用性，并因此免受传统 文件存储系统无法避免的许多失败的影响，比如电源、内存和网络端口等失败。第二个基础设施是名为Map-Reduce的计算框架，它与GFS紧密协作，帮 助处理收集到的海量数据。第三个基础设施是Bigtable，它是传统数据库的替代。Bigtable让你可以通过一些主键来组织海量数据，并实现高效的 查询。Hypertable是Bigtable的一个开源实现，并且根据我们的想法进行了一些改进。 Apache Cassandra Apache Cassandra是一套开源分布式Key-Value存储系统。它最初由Facebook开发，用于储存特别大的数据。Facebook目前在使用此系统。 主要特性： ◆ 分布式 ◆ 基于column的结构化 ◆ 高伸展性 Cassandra的主要特点就是它不是一个数据库，而是由一堆数据库节点共同构成的一个分布式网络服务，对Cassandra 的一个写操作，会被复制到其他节点上去，对Cassandra的读操作，也会被路由到某个节点上面去读取。对于一个Cassandra群集来说，扩展性能 是比较简单的事情，只管在群集里面添加节点就可以了。 Cassandra是一个混合型的非关系的数据库，类似于Google的BigTable。其主要功能比 Dynomite（分布式的Key-Value存 储系统）更丰富，但支持度却不如文档存储MongoDB（介于关系数据库和非关系数据库之间的开源产品，是非关系数据库当中功能最丰富，最像关系数据库 的。支持的数据结构非常松散，是类似json的bjson格式，因此可以存储比较复杂的数据类型。）Cassandra最初由Facebook开发，后转变成了开源项目。它是一个网络社交云计算方面理想的数据库。以Amazon专有的完全分布式的Dynamo为基础，结合了Google BigTable基于列族（Column Family）的数据模型。P2P去中心化的存储。很多方面都可以称之为Dynamo 2.0。 和其他数据库比较，其突出特点是： ◆ 模式灵活 ：使用Cassandra，像文档存储，你不必提前解决记录中的字段。你可以在系统运行时随意的添加或移除字段。这是一个惊人的效率提升，特别是在大型部 署上。 ◆ 真正的可扩展性 ：Cassandra是纯粹意义上的水平扩展。为给集群添加更多容量，可以指向另一台电脑。你不必重启任何进程，改变应用查询，或手动迁移任何数据。 ◆ 多数据中心识别 ：你可以调整你的节点布局来避免某一个数据中心起火，一个备用的数据中心将至少有每条记录的完全复制。 ◆ 范围查询 ：如果你不喜欢全部的键值查询，则可以设置键的范围来查询。 ◆ 列表数据结构 ：在混合模式可以将超级列添加到5维。对于每个用户的索引，这是非常方便的。 ◆ 分布式写操作 ：有可以在任何地方任何时间集中读或写任何数据。并且不会有任何单点失败。

MongoDB MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json的bjson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。它的特点是高性能、易部署、易使用，存储数据非常方便。主要功能特性有： 面向集合存储，易存储对象类型的数据。 模式自由。 支持动态查询。 支持完全索引，包含内部对象。 支持查询。 支持复制和故障恢复。 使用高效的二进制数据存储，包括大型对象（如视频等）。 自动处理碎片，以支持云计算层次的扩展性 支持RUBY，PYTHON，JAVA，C++，PHP等多种语言。 文件存储格式为BSON（一种JSON的扩展） 可通过网络访问 所谓“面向集合”（Collenction-Orented），意思是数据被分组存储在数据集中，被称为一个集合（Collenction)。每个 集合在数据库中都有一个唯一的标识名，并且可以包含无限数目的文档。集合的概念类似关系型数据库（RDBMS）里的表（table），不同的是它不需要定 义任何模式（schema)。模式自由（schema-free)，意味着对于存储在mongodb数据库中的文件，我们不需要知道它的任何结构定义。如果需要的话，你完全可以把不同结构的文件存储在同一个数据库里。存储在集合中的文档，被存储为键-值对的形式。键用于唯一标识一个文档，为字符串类型，而值则可以是各中复杂的文件类型。我们称这种存储形式为BSON（Binary Serialized dOcument Format）。MongoDB服务端可运行在Linux、Windows或OS X平台，支持32位和64位应用，默认端口为27017。推荐运行在64位平台，因为MongoDB在32位模式运行时支持的最大文件尺寸为2GB。MongoDB把数据存储在文件中（默认路径为：/data/db），为提高效率使用内存映射文件进行管理。

mysql数据库查询缓存原理是：概述查询缓存（Query Cache，简称QC），存储SELECT语句及其产生的数据结果。闲来无事，做一下这块的总结，也做个备忘！超详细的mysql数据库查询缓存总结，值得收藏工作原理缓存SELECT操作的结果集和SQL语句，key为sql，value为查询结果集；如果新的SELECT语句到了，以这个sql为key去缓存中查询，如果匹配，就把缓存的结果集返回；匹配标准：与缓存的SQL语句是否完全一样，sql中字母区分大小写以及中间的空格，简单理解为存储了一个key-value结构，key为sql，value为sql查询结果，匹配时使用Java的String的equals()，例如：select age from user 与 select AGE from user不会匹配，因为大小写不同；select age from use 与 select age from user不会匹配，因为空格不同；sql两边的空格可忽略，可以认为是对key进行过trim操作之后再进行equals比较。查看mysql设置参数执行show variables like "%query_cache%";可以看到相关参数：query_cache_type：0-不启用查询缓存；1-启用，2-启用，默认值为0； query_cache_size：设置缓存区总大小，允许设置query_cache_size的值最小为40K，默认1M，推荐设置为：64M/128M；query_cache_limit：限制缓存区最大能缓存的单条查询记录集大小，默认设置为1Mquery_cache_type为1时，只要符合查询缓存的要求，客户端的查询语句和记录集都可以缓存起来，如果SQL中加上 SQL_NO_CACHE将不缓存；query_cache_type为2时，只要SQL中添加了参数：SQL_CACHE，且符合查询缓存的要求，客户端的查询语句和记录集，则可以缓存起来。查看缓存使用情况show status like "%Qcache%%";可以看到相关参数：Qcache_hits：缓存命中次数；Qcache_inserts：缓存中插入次数，每缓存一次加1，注意这个不是缓存数量；开启查询缓存设置选项query_cache_type = 1 ，同时设置query_cache_size = 67108864；注：query_cache_size的值设置在100MB以内即可。在MySQL里查询缓存是由一个全局锁在控制，每次更新查询缓存的内存块都需要进行锁定。关闭查询缓存设置选项query_cache_type = 0，同时设置query_cache_size = 0。适用场景用于频繁提交同一个语句，并且该表数据变化不是很频繁的场景，例如一些静态页面，或者页面中的某块不经常发生变化的信息。由于查询缓存需要缓存最新数据结果，因此表数据发生任何变化（insert、update、delete或其他可能产生数据变化的操作），都会导致查询缓存被刷新。因而，对于一个更新频率非常低而只读查询频率非常高的场景下，打开查询缓存还是比较有优势的。不适用场景查询缓存严格要求2次SQL请求要完全一样，包括SQL语句，连接的数据库、协议版本、字符集等因素都会影响。下面为查询缓存不适用的几个场景：子查询；过程、函数、触发器、event中调用的SQL，或者引用到这些结果的；查询中涉及一些特殊函数时，例如：BENCHMARK()、CURDATE()、CURRENT_TIME()、CURRENT_TIMESTAMP()、NOW()、SLEEP()、CONNECTION_ID()、CURRENT_DATE()、CURRENT_USER()、PASSWORD()、RAND()、UUID()、ENCRYPT()、LAST_INSERT_ID()等等；查询涉及到mysql，information_schema或performance_schema。类似SELECT?LOCK IN SHARE MODE、SELECT?FOR UPDATE、SELECT..INTO OUTFILE/DUMPFILE、SELECT * FROM ... WHERE autoincrement_col IS NULL的查询；SELECT执行计划用到临时表；未引用任何表的查询，例如SELECT 1+2；查询产生了告警(warnings)；SELECT语句中存在SQL_NO_CACHE关键字；涉及到分区表。更多相关免费学习推荐：mysql教程(视频)

mysql数据库原理及应用 数据库原理与应用（第3版）答案《数据库原理与应用》（第三版）习题参考答案 第 1 章 数据库概述 1． 试说明数据、数据库、数据库管理系统和数据库系统的概念。答：数据是描述事物的符号记录。数据库是长期存储在计算机中的有组织的、可共享的大量数据的集合。数据库管理系统是一个专门用于实现对数据进行管理和维护的系统软件。数据库系统是指在计算机中引入数据库后的系统，一般由数据库、数据库管理系统（及相关的实用工具）、应用程序、数据库管理员组成。2． 数据管理技术的发展主要经历了哪几个阶段？答：文件管理和数据库管理。3． 与文件管理相比，数据库管理有哪些优点？ 答：与文件系统管理数据相比，数据库系统管理数据带来了如下好处：将相互关联的数据集成在一起，较少的数据冗余，程序与数据相互独立，保证数据的安全可靠，最大限度地保证数据的正确性，数据可以共享并能保证数据的一致性。4． 在数据库管理方式中，应用程序是否需要关心数据的存储位置和存储结构？为什么？ 答：不需要。因为数据库管理系统提供了逻辑独立性和物理独立性。5． 在数据库系统中，数据库的作用是什么？ 答：数据库是数据的汇集，它以一定的组织形式保存在存储介质上。6． 在数据库系统中，应用程序可以不通过数据库管理系统而直接访问数据文件吗？ 答：不能7． 数据独立性指的是什么？它能带来哪些好处？ 答：数据独立性是指应用程序不会因数据的物理表示方式和访问技术的改变而改变，即应用程序不依赖于任何特定的物理表示方式和访问技术，它包含两个方面：逻辑独立性和物理独立性。物理独立性是指当数据的存储位置或存储结构发生变化时，不影响应用程序的特性；逻辑独立性是指当表达现实世界的信息内容发生变化时，不影响应用程序的特性。8． 数据库系统由哪几部分组成，每一部分在数据库系统中的作用大致是什么？ 答：数据库系统一般包括数据库、数据库管理系统（及相应的实用工具）、应用程序和数据库管理员四个部分。数据库是数据的汇集，它以一定的组织形式保存在存储介质上；数据库管理系统是管理数据库的系统软件，它可以实现数据库系统的各种功能；应用程序专指以数据库数据为基础的程序，数据库管理员负责整个数据库系统的正常运行。第2章 数据模型与数据库结构 1． 解释数据模型的概念，为什么要将数据模型分成两个层次？ 答：答：数据模型是对现实世界数据特征的抽象。数据模型一般要满足三个条件：第一是数据模型要能够比较真实地模拟现实世界；第二是数据模型要容易被人们理解；第三是数据模型要能够很方便地在计算机上实现。由于用一种模型来同时很好地满足这三方面的要求在目前是比较困难的，因此在数据库系统中就可以针对不同的使用对象和应用目的，采用不同的数据模型。根据模型应用的不同目的，将这些模型分为两大类：概念层数据模型和组织层数据模型，以方便对信息的描述。2． 概念层数据模型和组织层数据模型分别是针对什么进行的抽象？ 答：概念层数据模型是对现实世界的抽象，形成信息世界模型，组织层数据模型是对信息世界进行抽象和转换，形成具体的DBMS支持的数据组织模型。3． 实体之间的联系有哪几种？请为每一种联系举出一个例子。答：实体之间的联系有一对一、一对多和多对多三种。例如：系和正系主任是一对一联系（假设一个系只有一个正系主任），系和教师是一对多联系（假设一个教师只在一个系工作），教师和课程是多对多联系（假设一个教师可以讲授多门课程，一门课程可由多个教师讲授）。4． 说明实体-联系模型中的实体、属性和联系的概念。5．指明下列实体间联系的种类：（1）教研室和教师（设一个教师只属于一个教研室，一个教研室可有多名教师）。（2）商品和顾客。（3）国家和首都（假设一个国家的首都可以变化）。（4）飞机和乘客。（5）银行和账户。（6）图书和借阅者。（设一个借阅者可同时借阅多本书，可在不同时间对同一本书借阅多次） 6．数据库系统包含哪三级模式？试分别说明每一级模式的作用？ 答：数据库系统包含的三级模式为：内模式、模式和外模式。外模式是对现实系统中用户感兴趣的整体数据结构的局部描述，用于满足不同数据库用户需求的数据视图，是数据库用户能够看见和使用的局部数据的逻辑结构和特征的描述，是对数据库整体数据结构的子集或局部重构。模式是数据库中全体数据的逻辑结构和特征的描述，是所有用户的公共数据视图。内模式是对整个数据库的底层表示，它描述了数据的存储结构。7． 数据库管理系统提供的两级映像的作用是什么？它带来了哪些功能？ 答：数据库系统的两级映象是模式与内描述间的映象和外模式与模式间的映象。模式／内模式的映象带来了物理独立性，即如果数据库的存储结构改变了，可通过调整模式／内模式的映象，使模式能够保持不变。外模式／概念模式间的映象带来了逻辑独立性，当概念模式的结构可发生改变时，也可通过调整外模式/模式间的映象关系，使外模式可以保持不变。8．数据库三级模式划分的优点是什么？它能带来哪些数据独立性？ 答：数据库的三级模式的划分实际上将用户、逻辑数据库与物理数据库进行了划分，使彼此之间的相互干扰减到最少。这三个模式的划分实际上带来了两个数据独立性：物理独立性和逻辑独立性。这使得底层的修改和变化尽量不影响到上层。第3章 关系数据库 1． 试述关系模型的三个组成部分。答：关系数据结构、关系操作集合和关系完整性约束。2． 解释下列术语的含义：（1） 笛卡尔积：设D1，D2，…，Dn为任意集合，定义笛卡尔积D1，D2，…，Dn为：D1×D2× …×Dn ＝{(d1，d2，…，dn) | di ∈Di，i＝1，2，…，n }（2） 主键：也称主码为或主关键字，是表中的属性或属性组，用于惟一地确定一个元组。（3） 候选键：如果一个属性或属性集的值能够惟一标识一个关系的元组而又不包含多余的属性，则称该属性或属性集为候选键。（4） 外键：设F是关系R的一个或一组属性，如果F与关系S的主键相对应，则称F是关系R的外键。（5） 关系：关系就是简单二维表。（6） 关系模式：二维表的结构称为关系模式。（7） 关系数据库：对应于一个关系模型的所有关系的集合称为关系数据库。3． 关系数据库的三个完整性约束是什么？各是什么含义？ 答：实体完整性、参照完整性和用户定义的完整性。实体完整性是保证关系中的每个元组都是可识别的和惟一的。参照完整性也称为引用完整性，用于表达现实世界中的实体之间的关联关系。用户定义的完整性也称为域完整性或语义完整性，用于保证数据库中存储的值与现实世界相符。4． 连接运算有哪些？等值连接和自然连接的区别是什么？ 答：连接运算中最重要也是最常用的连接有两个，一个是等值连接，一个是自然连接。自然连接与等值连接的差别为：l 自然连接要求相等的分量必须有共同的属性名，等值连接则不要求；l 自然连接要求把重复的属性名去掉，等值连接却不这样做。5． 对参与并、交、差运算的两个关系R、S有什么要求？ 答：必须结构相同，且相应的属性值取自同一个值域。6． 对参与除运算的两个关系（R÷S）有什么要求？除运算的结果关系中包含哪些属性？ 答：R中必须包含S的全部或部分属性，除运算的结果包含的属性是只属于R不属于S的属性。7． 对参与自然连接和等值连接操作的两个关系R、S有什么要求？答：有语义相同的属性。8． 投影操作的结果关系中是否有可能存在重复的记录？为什么？ 答：不可能，因为投影运算会自动去掉投影后重复的记录。9．利用表3-10至3-12所示的三个关系，写出实现如下查询要求的关系代数表达式。（1）查询“信息系”学生的选课情况，列出学号、姓名、课程号和成绩。∏Sno, Sname, Cno, Grade（σSdept=‘信息系"（SCStudent）） 或：∏Sno, Sname, Cno, Grade（SC σSdept=‘信息系"（Student））（2） 查询“VB”课程的考试情况，列出学生姓名、所在系和考试成绩。∏Sname, Sdept, Grade（σCname=‘VB"（CoureSCStudent）） 或：∏Sname, Sdept, Grade（σCname=‘VB"（Coure） SCStudent）（3） 查询考试成绩高于90分的学生的姓名、课程名和成绩。∏Sname, Cname, Grade（σGrade>90（CoureSCStudent）） 或：∏Sname, Cname, Grade（CoureσGrade>90（SC）Student）（4） 查询至少选修了0512号学生所选的全部课程的学生的姓名和所在系。∏Sname, Sdept（Student （SC ÷ ∏Cno（σsno="0512"（SC））))（5） 查询至少选了“C01”和“C02”两门课程的学生的姓名、所在系和所选的课程号。∏Sname, Sdept, Cno（Student （SC ÷ ∏Sno（σcno="C01" V Cno="C02"（SC））))（6） 查询没有选修第1学期开设的全部课程的学生的学号、姓名和所选的课程号。∏Sno, Sname, Cno（Student SC (∏sno（SC) - ∏sno（σsemester=1（Course)SC)))（7） 查询计算机系和信息系选了VB课程的学生姓名。∏Sname（σsdept="计算机系"V sdept="信息系"）∧ cname="vb"（StudentSC Course)) 或：∏Sname（σsdept="计算机系"V sdept="信息系"（Student）SC σcname="vb"（Course)) 第4章 SQL Server 20__基础 1． 安装SQL Server 20__对硬盘及内存的要求分别是什么？ 答：SQL Server 20__实际硬盘空间需求取决于系统配置和您决定安装的功能，一般应确保系统驱动器中是否有至少 6.0 GB 的可用磁盘空间。内存：E_press 版本：最少512 MB；其他版本：最少1 GB。2． SQL Server实例的含义是什么？实例名的作用是什么？ 答：一个实例代表一个独立的数据库管理系统。实例名是实例的标识，用户通过“计算机名/实例名”的方式可访问指定的命令实例。3． SQL Server 20__的核心引擎是什么？ 答：SQL Server（MSSQLSERVER）4． SQL Server 20__提供的设置服务启动方式的工具是哪个？ 答：配置管理器5． 在SQL Server 20__中，每个数据库至少包含几个文件？ 答：2个文件，一个数据文件，一个日志文件 6． SQL Server 20__数据库文件分为几类？每个文件有哪些属性？ 答：主要数据文件和次要数据文件，属性有：物理文件名及其位置、逻辑文件名、初始大小、增长方式、最大大小。第 5 章 数据类型及关系表创建 1． Tinyint数据类型定义的数据的取值范围是多少？ 答：0-2552． SmallDatatime类型精确到哪个时间单位？ 答：分钟3． 定点小数类型numeric中的p和q的含义分别是什么？ 答：p代表整数位数+小数位数的和值，q代表小数位数。4． Char(n)、nchar(n)的区别是什么？它们各能存放多少个字符？ 答：Char(n)中的n代表能存放n个字节的字符，如果是字母可以存放n个，如果是汉字可存放n/2个。Nchar(n)中的n代表能存放的字符个数。5． Char(n)和varchar(n)的区别是什么？答：Char(n)是定长存储，一定占n个字节的空间。Varchar(n)代表最多占n个字节的空间。6． 数据完整性约束的作用对象有哪些？ 答：表和列7． CHECK约束的作用是什么？ 答：限制列的取值范围。8． UNIQUE约束的作用是什么？ 答：限制列取值不重。9． DEFAULT约束的作用是什么？ 答：提供列的默认值。上机练习 1． 在第4章创建的Students数据库中，写出创建如下三张表的SQL语句，要求在定义表的同时定义数据的完整性约束：（1）“图书”表结构如下：书号：统一字符

原理就是硬盘容量大，硬盘容量不够大， mysql 怎么存大量数据？另外，数据库的功能不在于能存大量数据，如果只是存的话，直接存文件也行，一样可以存大量数据。数据库的主要能力是提供针对这些数据的可编程能力和快速灵活的查询功能。

1，优点分析：MYSQL短小精悍，容易上手，操作简单，免费供用的。相对其它数据库有特色又实用的语法多一些。SQL怎么也算是大型数据库，稳定，能做一般大系统的数据仓库，运行速度明显比MYSQL快N多（海量数据下这个优势显而易见）。 2，缺点分析：MYSQL难担当大系统的数据仓库，运行速度慢，不够稳定，有掉线的情况。SQLSERVER价格贵（当然没说5元盗版），使用起来比MYSQL要难一些，毕竟东西大了说道多点。 3，按你的补充（如何登录）：MySQL自己有文字界面客户端，用起来咋说也没鼠标点方便（不过习惯了也好），当然配对MYSQL有专业的客户端软件，我是用SQLYOG519版的，各种操作真的是很方便的说。SQLSERVER 就用自带的查询分析器登录了：）两者的前提是数据库服务都带打开，而且你得知道安装时的用户名密码哦：） 对于程序开发人员而言，目前使用最流行的两种后台数据库即为MySQL and SQLServer。这两者最基本的相似之处在于数据存储和属于查询系统。你可以使用SQL来访问这两种数据库的数据，因为它们都支持ANSI-SQL。还有，这两种数据库系统都支持二进制关键词和关键索引，这就大大地加快了查询速度。同时，二者也都提供支持XML的各种格式。除了在显而易见的软件价格上的区别之外，这两个产品还有什么明显的区别吗？在这二者之间你是如何选择的？让我们看看这两个产品的主要的不同之处，包括发行费用，性能以及它们的安全性。 根本的区别是它们遵循的基本原则二者所遵循的基本原则是它们的主要区别：开放vs保守。SQL服务器的狭隘的，保守的存储引擎与MySQL服务器的可扩展，开放的存储引擎绝然不同。虽然你可以使用SQL服务器的Sybase引擎，但MySQL能够提供更多种的选择，如MyISAM,Heap, InnoDB, and BerkeleyDB。MySQL不完全支持陌生的关键词，所以它比SQL服务器要少一些相关的数据库。同时，MySQL也缺乏一些存储程序的功能，比如MyISAM引擎联支持交换功能。 发行费用：MySQL不全是免费，但很便宜 当提及发行的费用，这两个产品采用两种绝然不同的决策。对于SQL服务器，获取一个免费的开发费用最常的方式是购买微软的Office或者VisualStudio的费用。但是，如果你想用于商业产品的开发，你必须还要购买SQL Server StandardEdition。学校或非赢利的企业可以不考虑这一附加的费用。 性能：先进的MySQL 纯粹就性能而言，MySQL是相当出色的，因为它包含一个缺省桌面格式MyISAM。MyISAM数据库与磁盘非常地兼容而不占用过多的CPU和内存。MySQL可以运行于Windows系统而不会发生冲突，在UNIX或类似UNIX系统上运行则更好。你还可以通过使用64位处理器来获取额外的一些性能。因为MySQL在内部里很多时候都使用64位的整数处理。Yahoo!商业网站就使用MySQL作为后台数据库。 当提及软件的性能，SQL服务器的稳定性要比它的竞争对手强很多。但是，这些特性也要付出代价的。比如，必须增加额外复杂操作，磁盘存储，内存损耗等等。如果你的硬件和软件不能充分支持SQL服务器，我建议你最好选择其他如DBMS数据库，因为这样你会得到更好的结果。 安全功能 MySQL有一个用于改变数据的二进制日志。因为它是二进制，这一日志能够快速地从主机上复制数据到客户机上。即使服务器崩溃，这一二进制日志也会保持完整，而且复制的部分也不会受到损坏。 在SQL服务器中，你也可以记录SQL的有关查询，但这需要付出很高的代价。安全性 这两个产品都有自己完整的安全机制。只要你遵循这些安全机制，一般程序都不会出现什么问题。这两者都使用缺省的IP端口，但是有时候很不幸，这些IP也会被一些黑客闯入。当然，你也可以自己设置这些IP端口。 恢复性:先进的SQL服务器 恢复性也是MySQL的一个特点，这主要表现在MyISAM配置中。这种方式有它固有的缺欠，如果你不慎损坏数据库，结果可能会导致所有的数据丢失。然而，对于SQL服务器而言就表现得很稳键。SQL服务器能够时刻监测数据交换点并能够把数据库损坏的过程保存下来。 根据需要决定你的选择 对于这两种数据库，如果非要让我说出到底哪一种更加出色，也许我会让你失望。以我的观点，任一对你的工作有帮助的数据库都是很好的数据库，没有哪一个数据库是绝对的出色，也没有哪一个数据库是绝对的差劲。我想要告诉你的是你应该多从你自己的需要出发，即你要完成什么样的任务？而不要单纯地从软件的功能出发。 如果你想建立一个.NET服务器体系，这一体系可以从多个不同平台访问数据，参与数据库的管理，那么你可以选用SQL服务器。如果你想建立一个第三方站点，这一站点可以从一些客户端读取数据，那么MySQL将是最好的选择。

sql server mysql收费 免费windows平台 多平台。。。

一、多数指令是相同的，包括创建和修正存储过程的指令。二、很多细微的指令有不同，具体如下（不仅）：1 mysql支持enum,和set类型，sql server不支持2 mysql不支持nchar,nvarchar,ntext类型3 mysql的递增语句是AUTO_INCREMENT，而mssql是identity(1,1)MYSQL：create table basic(id int key auto_increment,name varchar(20)); MSSQL: create table basic(id int identity(1,1) , name varchar(20)) 4 msms默认到处表创建语句的默认值表示是((0)),而在mysql里面是不允许带两括号的5 mysql需要为表指定存储类型6 mssql识别符是[],[type]表示他区别于关键字（可选用来包含表名、字段名），但是mysql却是 `（重音符，也就是按键1左边的那个符号）7 mssql支持getdate()方法获取当前时间日期，但是mysql里面可以分日期类型和时间类型，获取当前日期是cur_date()，当前完整时间是 now()函数8 mssql不支持replace into 语句，但是在最新的sql20008里面，也支持merge语法9 mysql支持insert into table1 set t1 = ‘", t2 = ‘" ,但是mssql不支持这样写10 mysql插入多行支持这样写 insert into tabl1 values (1,1), (1,1), (1,1), (1,1), (1,1), (1,1), (1,1) MSSQL不支持11 mssql不支持limit语句，是非常遗憾的，只能用top 取代limt 0,N，row_number() over()函数取代limit N,M12 mysql在创建表时要为每个表指定一个存储引擎类型，而mssql只支持一种存储引擎13 mysql不支持默认值为当前时间的datetime类型（mssql很容易做到），在mysql里面是用timestamp类型14 mssql里面检查是否有这个表再删除，需要这样：if exists (select * from dbo.sysobjects where id = object_id(N"uc_newpm") and OBJECTPROPERTY(id, N"IsUserTable") = 1) 但是在mysql里面只需要 DROP TABLE IF EXISTS cdb_forums;15 mysql支持无符号型的整数，那么比不支持无符号型的mssql就能多出一倍的最大数存储16 mysql不支持在mssql里面使用非常方便的varchar(max)类型，这个类型在mssql里面既可做一般数据存储，也可以做blob数据存储17 mysql创建非聚集索引只需要在创建表的时候指定为key就行，比如：KEY displayorder (fid,displayorder) 在mssql里面必须要：create unique nonclustered index index_uc_protectedmembers_username_appid on dbo.uc_protectedmembers (username asc,appid asc)18 mysql text字段类型不允许有默认值19mysql的一个表的总共字段长度不超过65XXX。20一个很表面的区别就是mysql的安装特别简单，而且文件大小才110M（非安装版），相比微软这个庞然大物，安装进度来说简直就是.....21mysql的管理工具有几个比较好的，mysql_front,和官方那个套件，不过都没有SSMS的使用方便，这是mysql很大的一个缺点。22mysql的存储过程只是出现在最新的版本中，稳定性和性能可能不如mssql。23 同样的负载压力，mysql要消耗更少的CPU和内存，mssql的确是很耗资源。24php连接mysql和mssql的方式都差不多，只需要将函数的mysql替换成mssql即可。 25mysql支持date,time,year类型，mssql到2008才支持date和time。26变量赋值MYsql：变量赋值SELECT @min_price:=MIN(price),@max_price:=MAX(price) FROM shop MSsql：变量赋值SELECT @min_price=MIN(price),@max_price=MAX(price) FROM shop三、总的来说，如果是简单的存储过程代码，要修改，不会太难。如果是复杂的系统，要移植会很难很难。

不同公司的数据库软件，SQL语言一样，但是有一些差异。

Class.forName("com.mysql.jdbc.Driver").newInstance();

歌曲名:For myself歌手:The Saturdays专辑:On Your RadarThe Saturdays - For MyselfThere"s always an I"m sorry after every outburst,another apologyThere"s always a make up after every frickin" break up,So tell me what we"re doing babeWhy oh why do we play this game,always want the last wordIt"s a war that no one can win,we just keep getting hurtIf you"re the only one that can make me this mad(Why can"t I can walk away, walk away...)If you"re the only one that can hurt me this bad(Why can"t I can walk away, walk away...)But I want you for myselfI still want you for myselfI want you for myselfBecause I want you for my selfYou creep under my skin and then you ruin my make up,You know exactly how to tick me offAnd yet I can"t resist you when you"re kissin" my face up,And everything"s forgiven and forgotI try and try to convince myself that this ain"t gonna workWhy oh why is the thought of you being gone so much worseIf you"re the only one that can make me this mad(Why can"t I can walk away, walk away...)If you"re the only one that can hurt me this bad(Why can"t I can walk away, walk away...)But I want you for myselfI still want you for myselfI want you for myselfBecause I want you for my selfWhy do we play this game, ohIf you"re the only one that can make me this mad(Why can"t I can walk away, walk away...)If you"re the only one that can hurt me this bad(Why can"t I can walk away, walk away...)But I want you for myselfI still want you for myselfI want you for myselfBecause I want you for my selfhttp://music.baidu.com/song/16034181

不是。ysmysmysm.com并不是货币支付平台，ysm属于是货币骗局的一种。因为近几年来网络虚拟货币的市场越来越热选购这种基金货币的人越来越多导致了个各国各省各地的虚拟货币产生的许多的新品种。

不是。ysmysmysm.com并不是货币支付平台，ysm属于是货币骗局的一种。因为近几年来网络虚拟货币的市场越来越热选购这种基金货币的人越来越多导致了个各国各省各地的虚拟货币产生的许多的新品种。

如果将来数据库服务也在容器中提供,建议使用link的方式,代码中使用

1. 首先创建一个目录并在目录下创建一个Dockerfile，文件内容如下[plain] view plain copy print?FROM centos:centos6 MAINTAINER Fanbin Kong "kongxx@hotmail.com" RUN yum install -y mysql-server mysql RUN /etc/init.d/mysqld start && mysql -e "grant all privileges on *.* to "root"@"%" identified by "letmein";"&& mysql -e "grant all privileges on *.* to "root"@"localhost" identified by "letmein";"&& mysql -u root -pletmein -e "show databases;" EXPOSE 3306 CMD ["/usr/bin/mysqld_safe"]-

1. 首先创建一个目录并在目录下创建一个Dockerfile，文件内容如下[plain] view plain copy print?FROM centos:centos6 MAINTAINER Fanbin Kong "kongxx@hotmail.com" RUN yum install -y mysql-server mysql RUN /etc/init.d/mysqld start && mysql -e "grant all privileges on *.* to "root"@"%" identified by "letmein";"&& mysql -e "grant all privileges on *.* to "root"@"localhost" identified by "letmein";"&& mysql -u root -pletmein -e "show databases;" EXPOSE 3306 CMD ["/usr/bin/mysqld_safe"]

配置容器(进入容器)docker exec -it your_mysql bash进入之后，要对用户进行授权，以便使用远程连接连接mysql 输入密码：ziqin666执行如下命令GRANT ALL PRIVILEGES ON *.* TO "root"@"localhost" IDENTIFIED BY "ziqin666";GRANT ALL PRIVILEGES ON *.* TO "root"@"%" IDENTIFIED BY "ziqin666";GRANT ALL PRIVILEGES ON *.* TO "root"@"127.0.0.1" IDENTIFIED BY "ziqin666";FLUSH PRIVILEGES;此时可以使用客户端连接一下看看。(一定要把安全组规则对应端口打开)二、构建php-fpm容器准备工作php.ini 默认是不存在的在/home/app/phpfile文件夹下创建 php.ini文件和conf.d文件夹创建容器 docker run -p 9000:9000 --name your_phpfpm -v /home/app/html:/var/www/html -v /home/app/phpfile:/usr/local/etc/php --link your_mysql:mysql -d php:5.6-fpm命令说明：--name your_phpfpm: 将容器命名为 your_phpfpm。-v /home/app/html:/var/www/html: 将主机中项目的目录 /home/app/html 挂载到容器的 /var/www/html安装 pdo 以便后边测试数据库连接，在docker的php容器中可以这样来安装docker-php-ext-install pdo_mysql安装其他插件也可以使用这种办法并加入到php.iniextension=php_curl.dllextension=php_gd2.dllextension=php_mysql.dllextension=php_mysqli.dllextension=php_pdo_mysql.dllextension=php_pdo_odbc.dllextension=php_pdo.dll如果插件还不够就需要自己定制镜像FROM php:7.0.12-fpmMAINTAINER Tairy <tairyguo@gmail.com>WORKDIR /workingRUN apt-get update --fix-missing && apt-get install -y g++ autoconf bash git apt-utils libxml2-dev libcurl3-dev pkg-config && ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo "Asia/Shanghai" > /etc/timezone && docker-php-ext-install iconv curl mbstring xml json mcrypt mysqli pdo pdo_mysql zip && docker-php-ext-configure gd --with-gd --with-freetype-dir=/usr/include/ --with-png-dir=/usr/include/ --with-jpeg-dir=/usr/include/ && docker-php-ext-install gd && docker-php-ext-enable gd && pecl install /pecl/redis-3.0.0.tgz && docker-php-ext-enable redis && apt-get purge -y --auto-remove && rm -rf /var/cache/apt/* && rm -rf /var/lib/apt/lists/* && rm -rf /pecl三、安装nginx配置文件目录：/home/app/nginx/conf.d(注释：没有的文件自主创建哈)在配置文件目录新建 default.confserver{listen 80;server_name localhost;location / { root /usr/share/nginx/html; index index.html index.htm; }location ~ .php$ { fastcgi_pass your_phpfpm:9000; #此处写docker里边php 的名称: your_phpfpmfastcgi_index index.php; fastcgi_param SCRIPT_FILENAME /var/www/html/$fastcgi_script_name;include fastcgi_params; } error_page 500 502 503 504 /50x.html;location = /50x.html {root /usr/share/nginx/html;}}创建容器docker run -p 81:80 --name your_nginx -v /home/app/nginx/www:/usr/share/nginx/html -v /home/app/nginx/conf.d:/etc/nginx/conf.d --link your_phpfpm:phpfpm -d nginx:latest映射容器中的phpfpm和mysql都为固定，不能修改！这里需要配置nginx使用用户，即把/etc/nginx/nginx.conf里的nginx用户修改为www-data，同时把/home/app/nginx/www下的文件所有者改为www-data：www_data，否则访问会有权限问题chown -R www-data:www-data www四 、 测试1、查看服务docker ps -aSTATUS 皆为up ，即运行中2、测试 php解析在宿主机/home/app/nginx/www/目录下修改 index.php 文件。<?php echo phpinfo();3、测试mysql 链接修改 index.php<?php//echo phpinfo();$dbms="mysql"; //数据库类型$host="your_mysql"; //数据库主机名,此处写mysql 容器的名字$dbport = "3306";$dbName="mysql"; //使用的数据库$user="root"; //数据库连接用户名$pass="123456"; //对应的密码$dsn="$dbms:host=$host;port=$dbport;dbname=$dbName";try { $dbh = new PDO($dsn, $user, $pass); //初始化一个PDO对象 echo "successful<br/>"; //你还可以进行一次搜索操作 // foreach ($dbh->query("SELECT * from user") as $row) { // print_r($row); //你可以用 echo($GLOBAL); 来看到这些值 // } $dbh = null;} catch (PDOException $e) { die ("Error!: " . $e->getMessage() . "<br/>");}访问ip , 到正确的输出，就证明我们的配置成功了。最后注意：很多人在学Java高级过程中难免会遇到各种问题解决不了。为此我建了个裙 783802103，里面很多架构师一起交流解答，没基础勿进哦！本文的文字及图片来源于网络加上自己的想法,仅供学习、交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理docker下如何搭建MySQL+php-fpm+nginx容器环境，本文详解标签：名称-name测试数据csharpcatch题解fastcgidata-目的

MySQL 检查约束（CHECK）可以通过 CREATE TABLE 或 ALTER TABLE 语句实现，根据用户实际的完整性要求来定义。它可以分别对列或表实施 CHECK 约束。但是mysql手册里写的很清楚：“所有的存储引擎均对CHECK子句进行分析，但是忽略CHECK子句。”所以虽然可以这样写可并不会起到约束作用。推荐教程：MySQL教程。检查约束使用 CHECK 关键字，具体的语法格式如下：CHECK <表达式>其中：<表达式>指的就是 SQL 表达式，用于指定需要检查的限定条件。若将 CHECK 约束子句置于表中某个列的定义之后，则这种约束也称为基于列的 CHECK 约束。在更新表数据的时候，系统会检查更新后的数据行是否满足 CHECK 约束中的限定条件。MySQL 可以使用简单的表达式来实现 CHECK 约束，也允许使用复杂的表达式作为限定条件，例如在限定条件中加入子查询。注意：若将 CHECK 约束子句置于所有列的定义以及主键约束和外键定义之后，则这种约束也称为基于表的 CHECK 约束。该约束可以同时对表中多个列设置限定条件。在创建表时设置检查约束创建表时设置检查约束的语法规则如下：CHECK(<检查约束>)在 test_db 数据库中创建 tb_emp7 数据表，要求 salary 字段值大于 0 且小于 10000，输入的 SQL 语句和运行结果如下所示。mysql> CREATE TABLE tb_emp7-> ( -> id INT(11) PRIMARY KEY, -> name VARCHAR(25), -> deptId INT(11), -> salary FLOAT, -> CHECK(salary>0 AND salary<100), -> FOREIGN KEY(deptId) REFERENCES tb_dept1(id) -> );Query OK, 0 rows affected (0.37 sec)在修改表时添加检查约束修改表时设置检查约束的语法规则如下：ALTER TABLE tb_emp7 ADD CONSTRAINT <检查约束名> CHECK(<检查约束>)修改 tb_dept 数据表，要求 id 字段值大于 0，输入的 SQL 语句和运行结果如下所示。mysql> ALTER TABLE tb_emp7 -> ADD CONSTRAINT check_id -> CHECK(id>0);Query OK, 0 rows affected (0.19 sec)Records: 0 Duplicates: 0 Warnings: 0解决方法：使用触发器实现CHECK检查约束的功能。（1）创建tb_student（学生信息表）。-- 创建学生信息表CREATE TABLE tb_student( id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(30), age INT NOT NULL);（2）创建检查年龄（age）字段是否有效的触发器。 -- 创建触发器 CREATE TRIGGER trg_tb_student_insert_check BEFORE INSERTON tb_student FOR EACH ROWBEGIN DECLARE msg varchar(100); IF NEW.age <= 0 OR NEW.age >= 100 THEN SET msg = CONCAT("您输入的年龄值：",NEW.age," 为无效的年龄，请输入0到100以内的有效数字。"); SIGNAL SQLSTATE "HY000" SET MESSAGE_TEXT = msg; END IF;END;（3）编写测试语句。INSERT INTO tb_student(name,age) VALUES("Kevin",120);

group_concat 是把同一列的数据穿起来，跟group 没关系的，不用也可以

先建立2个测试表，在id列上创建unique约束。 mysql> create table test1(id int,name varchar(5),type int,primary key(id)); Query OK, 0 rows affected (0.01 sec) mysql> create table test2(id int,name varchar(5),type int,primary key(id)); Query OK, 0 rows affected (0.01 sec) mysql> select * from test1; +-----+------+------+ | id | name | type | +-----+------+------+ | 101 | aaa | 1 | | 102 | bbb | 2 | | 103 | ccc | 3 | +-----+------+------+ 3 rows in set (0.00 sec) mysql> select * from test2; +-----+------+------+ | id | name | type | +-----+------+------+ | 201 | aaa | 1 | | 202 | bbb | 2 | | 203 | ccc | 3 | | 101 | xxx | 5 | +-----+------+------+ 4 rows in set (0.00 sec) 1、REPLACE INTO 发现重复的先删除再插入，如果记录有多个字段，在插入的时候如果有的字段没有赋值，那么新插入的记录这些字段为空。 mysql> replace into test1(id,name)(select id,name from test2); Query OK, 5 rows affected (0.04 sec) Records: 4 Duplicates: 1 Warnings: 0 mysql> select * from test1; +-----+------+------+ | id | name | type | +-----+------+------+ | 101 | xxx | NULL | | 102 | bbb | 2 | | 103 | ccc | 3 | | 201 | aaa | NULL | | 202 | bbb | NULL | | 203 | ccc | NULL | +-----+------+------+ 6 rows in set (0.00 sec) 需要注意的是，当你replace的时候，如果被插入的表如果没有指定列，会用NULL表示，而不是这个表原来的内容。如果插入的内容列和被插入的表列一样，则不会出现NULL。例如 mysql> replace into test1(id,name,type)(select id,name,type from test2); Query OK, 8 rows affected (0.04 sec) Records: 4 Duplicates: 4 Warnings: 0 mysql> select * from test1; +-----+------+------+ | id | name | type | +-----+------+------+ | 101 | xxx | 5 | | 102 | bbb | 2 | | 103 | ccc | 3 | | 201 | aaa | 1 | | 202 | bbb | 2 | | 203 | ccc | 3 | +-----+------+------+ 6 rows in set (0.00 sec) 如果INSERT的时候，需要保留被插入表的列，只更新指定列，那么就可以使用第二种方法。 2、INSERT INTO ON DUPLICATE KEY UPDATE 发现重复的是更新操作。在原有记录基础上，更新指定字段内容，其它字段内容保留。例如我只想插入test2表的id,name字段，但是要保留test1表的type字段： mysql> insert into test1(id,name,type)(select id,name,type from test2) on DUPLICATE KEY UPDATE test1.name=test2.name; Query OK, 5 rows affected (0.04 sec) Records: 4 Duplicates: 1 Warnings: 0 mysql> select * from test1; +-----+------+------+ | id | name | type | +-----+------+------+ | 101 | xxx | 1 | | 102 | bbb | 2 | | 103 | ccc | 3 | | 203 | ccc | 3 | | 202 | bbb | 2 | | 201 | aaa | 1 | +-----+------+------+ 6 rows in set (0.00 sec) 如果INSERT的时候，只想插入原表没有的数据，那么可以使用第三种方法。 3、IGNORE INTO 判断是否存在，存在不插入，否则插入。很容易理解，当插入的时候，违反唯一性约束，MySQL不会尝试去执行这条语句。例如： mysql> insert ignore into test1(id,name,type)(select id,name,type from test2); Query OK, 3 rows affected (0.01 sec) Records: 4 Duplicates: 1 Warnings: 0 mysql> select * from test1; +-----+------+------+ | id | name | type | +-----+------+------+ | 101 | aaa | 1 | | 102 | bbb | 2 | | 103 | ccc | 3 | | 203 | ccc | 3 | | 202 | bbb | 2 | | 201 | aaa | 1 | +-----+------+------+ 6 rows in set (0.00 sec)您可能感兴趣的文章:MySql避免重复插入记录的几种方法分享MYSQL插入数据时忽略重复数据的方法MySQL 处理插入过程中的主键唯一键重复值的解决方法防止mysql重复插入记录的方法MYSQL实现添加购物车时防止重复添加示例代码

外键引用的列必须是键列，目测emp的name列没有定义为键列。将emp的name列定义为键列吧

。。。 Mysql 里面就是这么设定的 number的范围 你能怎么改 换类型又不会怎么样 程序取到数之后你再方法里面强转一下就是了

可以拿出来的 ，找到备份的文件夹 和文件名 使用FTP 下载就可以了

这是执行结果啊，0代表正常执行了。

我的书包在哪里？

My schoolbag is an essential item for me to go to school. It accompanies me through every day of learning. Every morning, I put the necessary books and stationery into my schoolbag, put it on my back, and head towards the school gate. In the campus, my schoolbag is not only a tool for storing books but also my companion. It can hold my water bottle, snacks, keys, and other items. During the break between classes, I can take out my small snacks from my schoolbag, enjoy the delicious taste, and be more energetic to immerse myself in learning.My schoolbag is produced by the brand myschoolbag. Its quality is excellent and very durable. Once, I accidentally left my schoolbag on the ground, and it rained heavily. However, the items inside my schoolbag were not damaged at all. This gives me great confidence in the quality of myschoolbag. I believe that even if I use it every day, it can accompany me for a long time.In conclusion, my schoolbag is not only my learning tool but also my companion. Its brand is myschoolbag, and its quality is excellent and very durable. I believe that my schoolbag will always accompany me through my learning journey.

【 #小学英语# 导语】作文是英语学习的重要内容之一，也是学生综合能力的体现。它与学生的词汇量、语法、句法能力和逻辑思维能力等有密不可分的关系，在考试中比重也不小。而许多学生在此方面丢分甚多，以致影响最后总分，因此培养学生写作能力是非常有意义的。以下是 考 网整理的《小学四年级myschoolbag英语作文》相关资料，希望帮助到您。 【篇一】小学四年级myschoolbag英语作文 　　Hello! My name is Yuan Xiaoshan. I"m a girl. I"m in Class 2, Grade 4.I have a beautiful schoolbag. It"s pink and black. There are many books in it. Look, I have a red pencil-box .There is a blue pencil and a green ruler in it. There are many crayons in my schoolbag, too. I love my schoolbag.　　 【篇二】小学四年级myschoolbag英语作文 　　Myu2002schoolbagu2002isu2002pinku2002andu2002heavy.u2002Iu2002haveu2002manyu2002books,u2002anu2002Englishu2002book,u2002au2002Chineseu2002book,u2002au2002mathu2002book,u2002au2002notebooku2002andu2002twou2002story-books.u2002Becauseu2002Iu2002likeu2002drawingu2002veryu2002much,u2002so,u2002Iu2002haveu2002au2002veryu2002beautifulu2002pictureu2002booku2002inu2002myu2002schoolbag.u2002u2002Itu2002hasu2002twou2002sideu2002pockets,u2002Iu2002canu2002putu2002myu2002pens,pencils,erasers,andu2002rulers.u2002u2002Iu2002likeu2002myu2002schoolbagu2002veryu2002much,u2002becauseu2002itu2002helpsu2002meu2002everyu2002dayu2002whenu2002Iu2002gou2002tou2002school. 【篇三】小学四年级myschoolbag英语作文 　　Look, this is my schoolbag. It"s pink and gray. It"s big and beautiful. It has three floors. There is a beautiful girl on my schoolbag. There are three story-books, ten notebooks, a Chinese book, a math book and an English book in my schoolbag. 　　There is a pencil-case in my schoolbag, too. There is a fat cat on the pencil-case, it"s lovely. There are many pink flowers on my pencil-case. There are two erasers, four pencils, one sharpener, one ruler and three pens in my pencil-case. 　　I like my pencil-case. I like my schoolbag. 　　Do you have a nice schoolbag, too? 【篇四】小学四年级myschoolbag英语作文 　　I have a good friend. Her name is school bag. She is a very beautiful girl. Look! There is a picture on her face. It"s a picture of a lovely girl. She wears a red coat. There are some books, some copybooks and a pencil case in her stomach. From Monday to Friday, I go to school with her. She helps me a lot. And I like her very much. 【篇五】小学四年级myschoolbag英语作文 　　My schoolbag is large. It is blue and black. The schoolbag with apicture of a talkative sheep and a panda is nice. And there are four parts in it. One part is big and the others are small. 　　Myschoolbag is heavy. There are many things in it. They are Chinese book,math book, English book, computer book, story books, some notebooks,four rulers and pencilcase. In my pencilcase, there is a blue pen, a black pen, a red pen, a eraser, a pencil and so on. 　　I like my schoolbag and it is popular.

-- 使用数据库hruse hr;-- 在数据库中创建表-- ------------------------------------JOBS表------------------------------------------------------------ 判断数据库中是否存在表JOBSdrop table if exists JOBS;-- 创建表JOBScreate table JOBS ( JOB_ID VARCHAR(10) not null,-- 职位编号，主键 JOB_TITLE NVARCHAR(20) not null,-- 职位名称 MIN_SALARY float not null, -- 职位最低薪资，不小于1000元 mysql中没有money类型的数据类型 MAX_SALARY float not null -- 职位最高薪资，不小于最低薪资 );-- 给JOBS表创建约束-- 添加主键约束alter table JOBS add constraint primary key(JOB_ID);-- 职位最低薪资，不小于1000元alter table JOBS add constraint check(MIN_SALARY>=1000);-- 职位最高薪资，不小于最低薪资alter table JOBS add check(MAX_SALARY>=MIN_SALARY);-- 插入测试数据-- insert into JOBS values(‘100‘,‘经理‘,12000,19990),(‘101‘,‘主管‘,6200,8999);-- select * from JOBS; -- ------------------------------------------------DEPARTMENTS部门表的结构--------------------------------------------------------------- 判断数据库中是否存在表DEPARTMENTS drop table if exists DEPARTMENTS;-- 创建表DEPARTMENTScreate table DEPARTMENTS ( DEPARTMENT_ID INT not null, -- 部门编号，主键，自增。 DEPARTMENT_NAME NVARCHAR(30) not null, -- 部门名称 MANAGER_ID INT -- 部门主管编号，外键，引用EMPLOYEES表的EMPLOYEE_ID );-- 创建表DEPARTMENTS的约束-- 创建主键的约束alter table DEPARTMENTS add constraint primary key(DEPARTMENT_ID);-- 为主键添加自动增长alter table DEPARTMENTS modify DEPARTMENT_ID int auto_increment;-- 部门主管编号，外键，引用EMPLOYEES表的EMPLOYEE_ID-- alter table DEPARTMENTS -- add constraint FK_MANAGER_ID foreign key(MANAGER_ID) references EMPLOYEES(EMPLOYEE_ID);-- 插入测试数据-- insert into DEPARTMENTS values(null,‘财务部‘,200),(null,‘采购部‘,300);-- select * from DEPARTMENTS;-- ----------------------------------------------EMPLOYEES职员表的结构------------------------------------------------------------------------- 判断数据库中是否存在表EMPLOYEESdrop table if exists EMPLOYEES;-- 创建表EMPLOYEEScreate table EMPLOYEES ( EMPLOYEE_ID INT not null, -- 职员编号，主键，自增（起始值为100，每次增1） FIRST_NAME NVARCHAR(4) not null, -- 职员名称 LAST_NAME NVARCHAR(4) not null, -- 职员姓氏 EMAIL VARCHAR(25) not null, -- 职员邮件 PHONE_NUMBER VARCHAR(20) not null, -- 职员电话 HIRE_DATE TIMESTAMP not null, -- getdate() 职员入职时间 JOB_ID VARCHAR(10) not null, -- 职员职位编号，外键，引用JOBS表的JOB_ID SALARY float , -- 职员薪资，大于0； MANAGER_ID INT , -- 职员主管编号，外键，引用EMPLOYEES表的EMPLOYEE_ID DEPARTMENT_ID INT -- 职员部门编号，外键，引用DEPARTMENTS表的DEPARTMENT_ID )auto_increment=100; -- 添加约束-- 添加 主键约束alter table EMPLOYEES add primary key(EMPLOYEE_ID);-- 为主键添加自增alter table EMPLOYEES modify EMPLOYEE_ID int auto_increment;-- getdate() 职员入职时间alter table EMPLOYEES modify HIRE_DATE TIMESTAMP default ‘2016-7-23‘;-- 添加约束 职员职位编号，外键，引用JOBS表的JOB_ID----------------------------添加外键约束时要加上constraint -- alter table EMPLOYEES -- add constraint FK_JOB_ID foreign key(JOB_ID) references JBOS(JOB_ID);-- 职员薪资，大于0alter table EMPLOYEES add check(SALARY>0);-- 职员主管编号，外键，引用EMPLOYEES表的EMPLOYEE_IDalter table EMPLOYEES add constraint FK_EMPLOYEE_ID foreign key(EMPLOYEE_ID) references EMPLOYEES(EMPLOYEE_ID);-- 职员部门编号，外键，引用DEPARTMENTS表的DEPARTMENT_IDalter table EMPLOYEES add constraint FK_DEPARTMENT_ID foreign key(DEPARTMENT_ID) references DEPARTMENTS(DEPARTMENT_ID);mysql中如何创表以及添加各种约束条件标签：

bitsCN.com MYSQL中如何设置列默认值的介绍MySQL目前不支持列的Default为函数的形式，如达到你某列的默认值为当前更新日期与时间的功能，你可以使用TIMESTAMP列类型，下面就详细说明TIMESTAMP列类型。TIMESTAMP列类型TIMESTAMP值可以从1970的某时的开始一直到2037年，精度为一秒，其值作为数字显示。TIMESTAMP值显示尺寸的格式如下表所示：+---------------+----------------+| 列类型| 显示格式 || TIMESTAMP(14) | YYYYMMDDHHMMSS || TIMESTAMP(12) | YYMMDDHHMMSS || TIMESTAMP(10) | YYMMDDHHMM || TIMESTAMP(8)| YYYYMMDD || TIMESTAMP(6)| YYMMDD || TIMESTAMP(4)| YYMM || TIMESTAMP(2)| YY |+---------------+----------------+“完整”TIMESTAMP格式是14位，但TIMESTAMP列也可以用更短的显示尺寸创造，最常见的显示尺寸是6、8、12、和14。你可以在创建表时指定一个任意的显示尺寸，但是定义列长为0或比14大均会被强制定义为列长14。列长在从1～13范围的奇数值尺寸均被强制为下一个更大的偶数。所有的TIMESTAMP列都有同样的存储大小，使用被指定的时期时间值的完整精度（14位）存储合法的值不考虑显示尺寸。不合法的日期，将会被强制为0存储。这有几个含意： 1、虽然你建表时定义了列TIMESTAMP(8)，但在你进行数据插入与更新时TIMESTAMP列实际上保存了14位的数据（包括年月日时分秒），只不过在你进行查询时MySQL返回给你的是8位的年月日数据。如果你使用ALTER TABLE拓宽一个狭窄的TIMESTAMP列，以前被“隐蔽”的信息将被显示。 2、同样，缩小一个TIMESTAMP列不会导致信息失去，除了感觉上值在显示时，较少的信息被显示出。 3、尽管TIMESTAMP值被存储为完整精度，直接操作存储值的唯一函数是UNIX_TIMESTAMP()；由于MySQL返回TIMESTAMP列的列值是进过格式化后的检索的值，这意味着你可能不能使用某些函数来操作TIMESTAMP列（例如HOUR()或SECOND()），除非TIMESTAMP值的相关部分被包含在格式化的值中。例如，一个TIMESTAMP列只有被定义为TIMESTAMP(10)以上时，TIMESTAMP列的HH部分才会被显示，因此在更短的TIMESTAMP值上使用HOUR()会产生一个不可预知的结果。4、不合法TIMESTAMP值被变换到适当类型的“零”值(00000000000000)。（DATETIME,DATE亦然）你可以使用下列语句来验证：CREATE TABLE test ("id" INT (3) UNSIGNED AUTO_INCREMENT, "date1" TIMESTAMP (8) PRIMARY KEY("id"));INSERT INTO test SET id = 1;SELECT * FROM test;+----+----------------+| id | date1|+----+----------------+|1 | 20021114 |+----+----------------+ALTER TABLE test CHANGE "date1" "date1" TIMESTAMP(14);SELECT * FROM test;+----+----------------+| id | date1|+----+----------------+|1 | 20021114093723 |+----+----------------+你可以使用TIMESTAMP列类型自动地用当前的日期和时间标记INSERT或UPDATE的操作。如果你有多个TIMESTAMP列，只有第一个自动更新。自动更新第一个TIMESTAMP列在下列任何条件下发生： 1、列值没有明确地在一个INSERT或LOAD DATA INFILE语句中指定。 2、列值没有明确地在一个UPDATE语句中指定且另外一些的列改变值。（注意一个UPDATE设置一个列为它已经有的值，这将不引起TIMESTAMP列被更新，因为如果你设置一个列为它当前的值，MySQL为了效率而忽略更改。） 3、你明确地设定TIMESTAMP列为NULL. |4、除第一个以外的TIMESTAMP列也可以设置到当前的日期和时间，只要将列设为NULL，或NOW()。CREATE TABLE test ( "id" INT (3) UNSIGNED AUTO_INCREMENT, "date1" TIMESTAMP (14), "date2" TIMESTAMP (14),PRIMARY KEY("id"));INSERT INTO test (id, date1, date2) VALUES (1, NULL, NULL);INSERT INTO test SET id= 2;+----+----------------+----------------+| id | date1| date2|+----+----------------+----------------+|1 | 20021114093723 | 20021114093723 ||2 | 20021114093724 | 00000000000000 |+----+----------------+----------------+ 第一条指令因设date1、date2为NULL,所以date1、date2值均为当前时间，第二条指令因没有设date1、date2列值，第一个TIMESTAMP列date1为更新为当前时间，而二个TIMESTAMP列date2因日期不合法而变为“00000000000000”UPDATE test SET id= 3 WHERE id=1;+----+----------------+----------------+| id | date1| date2|+----+----------------+----------------+|3 | 20021114094009 | 20021114093723 ||2 | 20021114093724 | 00000000000000 |+----+----------------+----------------+ 这条指令没有明确地设定date2的列值，所以第一个TIMESTAMP列date1将被更新为当前时间。UPDATE test SET id= 1,date1=date1,date2=NOW() WHERE id=3;+----+----------------+----------------+| id | date1| date2|+----+----------------+----------------+|1 | 20021114094009 | 20021114094320 ||2 | 20021114093724 | 00000000000000 |+----+----------------+----------------+ 这条指令因设定date1=date1，所以在更新数据时date1列值并不会发生改变，而因设定date2=NOW()，所以在更新数据时date2列值会被更新为当前时间。此指令等效为：UPDATE test SET id= 1,date1=date1,date2=NULL WHERE id=3;因MySQL返回的 TIMESTAMP 列为数字显示形式，你可以用DATE_FROMAT()函数来格式化 TIMESTAMP 列。SELECT id,DATE_FORMAT(date1,"%Y-%m-%d %H:%i:%s") As date1, DATE_FORMAT(date2,"%Y-%m-%d %H:%i:%s") As date2 FROM test;+----+---------------------+---------------------+| id | date1 | date2 |+----+---------------------+---------------------+|1 | 2002-11-14 09:40:09 | 2002-11-14 09:43:20 ||2 | 2002-11-14 09:37:24 | 0000-00-00 00:00:00 |+----+---------------------+---------------------+SELECT id,DATE_FORMAT(date1,"%Y-%m-%d") As date1, DATE_FORMAT(date2,"%Y-%m-%d") As date2 FROM test;+----+-------------+-------------+| id | date1 | date2 |+----+-------------+-------------+|1 | 2002-11-14| 2002-11-14||2 | 2002-11-14| 0000-00-00|+----+-------------+-------------+在某种程度上，你可以把一种日期类型的值赋给一个不同的日期类型的对象。然而，而尤其注意的是：值有可能发生一些改变或信息的损失： 1、如果你将一个DATE值赋给一个DATETIME或TIMESTAMP对象，结果值的时间部分被设置为"00:00:00"，因为DATE值中不包含有时间信息。2、如果你将一个DATETIME或TIMESTAMP值赋给一个DATE对象，结果值的时间部分被删除，因为DATE类型不存储时间信息。 3、尽管DATETIME, DATE和TIMESTAMP值全都可以用同样的格式集来指定，但所有类型不都有同样的值范围。例如，TIMESTAMP值不能比1970早，也不能比2037晚，这意味着，一个日期例如"1968-01-01"，当作为一个DATETIME或DATE值时它是合法的，但它不是一个正确TIMESTAMP值！并且如果将这样的一个对象赋值给TIMESTAMP列，它将被变换为0。 当指定日期值时，当心某些缺陷： 1、允许作为字符串指定值的宽松格式能被欺骗。例如，，因为“:”分隔符的使用，值"10:11:12"可能看起来像时间值，但是如果在一个日期中使用，上下文将作为年份被解释成"2010-11-12"。值"10:45:15"将被变换到"0000-00-00"，因为"45"不是一个合法的月份。 2、以2位数字指定的年值是模糊的，因为世纪是未知的。MySQL使用下列规则解释2位年值： 在00-69范围的年值被变换到2000-2069。 在范围70-99的年值被变换到1970-1999。 bitsCN.com

索引相关1. 查询（或更新，删除，可以转换为查询）没有用到索引这是最基础的步骤，需要对sql执行explain查看执行计划中是否用到了索引，需要重点关注type=ALL, key=NULL的字段。2. 在索引字段上施加函数to_char(gmt_created, ‘mmdd") = "0101′正确的写法gmt_created between to_date(“20090101″, “yyyymmdd”) and to_date(“20090102″, “yyyymmdd”)3. 在索引字段上使用全模糊member_id like ‘%alibab%"B树无法解决此类问题，可以考虑搜索引擎。但是member_id like ‘alibab%"可以用到索引。其实，对任何一个字段使用 like ‘%xxxx%"都是一种不规范的做法，需要能检查到这种错误用法。4. 多列字段的索引，没有用到前导索引索引：(memeber_id, group_id)where group_id=9234，实际上，这个条件是没有办法用到上面的索引的。这是一个很常见的误用。要理解为什么不能用到这个索引，需要理解mysql如何构造多列索引的。索引是一棵B树，问题是，对于多列索引，mysql将索引字段按照索引建立的顺序进行拼装，组成一个新的字符串，这个字符串被用来做为构建B树的键。所以，在查询条件里，如果没有用到前导列，就没办法访问多列索引的B树。应该建立索引：(group_id, member_id)5. 访问到了索引之外的字段索引(member_id, subject)select subject from offer where member_id=234在member_id=234记录数很多的情况下，会优于select subject, gmt_created from offer where member_id=234原因是第二条sql会根据索引查找到的rowid访问表里的记录。第一条sql使用索引范围扫描就可以得到结果。如果某个sql执行次数很多，但是读取的字段没有被索引覆盖，那么，可能需要建立覆盖性索引。6. 计数count(id)有时比count(*)慢count(id) === count(1) where id is not null如果没有(id)索引，那么会用全表扫描，而count(*)会使用最优的索引进行用索引快速全扫描计数统一使用count(*)7. 正确使用stop机制判断member_id在offer表中是否存在记录：select count(*) from offer where member_id=234 limit 1优于select count(*) from offer where member_id=234原因是第一条sql会在得到第一条符合条件的记录后停止。高效分页1. 高效的分页使用join技术，利用索引查找到符合条件的id，构造成临时表，用这个小的临时表与原表做joinselect *from(select t.*, rownum AS rnfrom(select * from blog.blog_articlewhere domain_id=1and draft=0order by domain_id, draft, gmt_created desc) twhere rownum >= 2) awhere a.rn 应该改写成select blog_article.*from(select rid, rownum as rnfrom(select rowid as id from blog.blog_articlewhere domain_id=1and draft=0order by domain_id, draft, gmt_created desc) twhere rownum >= 2) a, blog_articlewhere a.rn >= 3and a.rid = blog_article.rowid2. order by没有用到索引有索引（a, b,c ）混合排序规则ORDER BY a ASC, b DESC, c DESC /* mixed sort direction */缺失了前导列WHERE g = const ORDER BY b, c /* a prefix is missing */缺失了中间列WHERE a = const ORDER BY c /* b is missing */使用了不在索引中的列进行排序WHERE a = const ORDER BY a, d /* d is not part of index */高效地利用primary key随机查询一个错误的做法：select * from title where kind_id=1 order by rand() limit 1;create index k on title(kind_id);这个sql执行过程中需要全表扫描，并且将数据保存到临时表，这是一个非常耗时的操作。改进的做法，利用偏移量。select round(rand() * count(*)) from title where kind_id=1;select * from title where kind_id=1 limit 1 offset $random;create index k on title(kind_id);相比上面的做法，这种写法能够利用到kind_id上的索引，减少了需要扫描的数据块。但是，如果offset非常大，那么需要扫描的数据块也非常大，极端情况是扫描索引k的所有数据块。最优的做法，利用主键进行范围查找select round(rand() * count(*)) from title where kind_id=1;select * from title where kind_id = and id > $random limit 1;这个sql利用primary key进行范围查询，完全走索引，并且只读取一条记录，速度非常快。但是，这种用法的限制是primary key必须是int型，并且是连续自增长的。高效join1. 小表驱动大表进行join2. 避免子查询子查询是一个影响性能的隐患。应该使用join改写sql。数据类型1. 避免隐式转换CREATE TABLE `user` (`id` smallint(5) unsigned NOT NULL AUTO_INCREMENT,`account` char(11) NOT NULL COMMENT ”,`email` varchar(128),PRIMARY KEY (`id`),UNIQUE KEY `username` (`account`)) ENGINE=InnoDB CHARSET=utf8;mysql> explain select * from user where account=123 G*************************** 1. row ***************************id: 1select_type: SIMPLEtable: usertype: ALLpossible_keys: usernamekey: NULLkey_len: NULLref: NULLrows: 2Extra: Using where1 row in set (0.00 sec)可以看到，account=123的条件并没有用到唯一索引`username`。mysql的server从storage engine中读取所有的记录，使用to_number()函数，将记录中的account转换成数字，被转换后的数字用来和参数比较。我们的测试表里有2条记录，而执行计划中rows的值也是2，并且type的值为ALL，这也说明索引`username`并没有被用到。 代码如下:mysql> explain select * from user where account="123′ G*************************** 1. row ***************************id: 1select_type: SIMPLEtable: usertype: constpossible_keys: usernamekey: usernamekey_len: 33ref: constrows: 1Extra:1 row in set (0.00 sec)参数为字符串类型，我们可以看到索引`username`，被使用到了。这是一个经常被误用的做法。2. 主键不是自增列自增列的主键有多个好处： 插入性能高。 减小page的碎片。 提供二级索引的性能，降低二级索引的空间，因为二级索引存储的是主键的值，并不是page中的行id。

索引相关1. 查询（或更新，删除，可以转换为查询）没有用到索引这是最基础的步骤，需要对sql执行explain查看执行计划中是否用到了索引，需要重点关注type=ALL, key=NULL的字段。2. 在索引字段上施加函数to_char(gmt_created, ‘mmdd") = "0101′正确的写法gmt_created between to_date(“20090101″, “yyyymmdd”) and to_date(“20090102″, “yyyymmdd”)3. 在索引字段上使用全模糊member_id like ‘%alibab%"B树无法解决此类问题，可以考虑搜索引擎。但是member_id like ‘alibab%"可以用到索引。其实，对任何一个字段使用 like ‘%xxxx%"都是一种不规范的做法，需要能检查到这种错误用法。4. 多列字段的索引，没有用到前导索引索引：(memeber_id, group_id)where group_id=9234，实际上，这个条件是没有办法用到上面的索引的。这是一个很常见的误用。要理解为什么不能用到这个索引，需要理解mysql如何构造多列索引的。索引是一棵B树，问题是，对于多列索引，mysql将索引字段按照索引建立的顺序进行拼装，组成一个新的字符串，这个字符串被用来做为构建B树的键。所以，在查询条件里，如果没有用到前导列，就没办法访问多列索引的B树。应该建立索引：(group_id, member_id)5. 访问到了索引之外的字段索引(member_id, subject)select subject from offer where member_id=234在member_id=234记录数很多的情况下，会优于select subject, gmt_created from offer where member_id=234原因是第二条sql会根据索引查找到的rowid访问表里的记录。第一条sql使用索引范围扫描就可以得到结果。如果某个sql执行次数很多，但是读取的字段没有被索引覆盖，那么，可能需要建立覆盖性索引。6. 计数count(id)有时比count(*)慢count(id) === count(1) where id is not null如果没有(id)索引，那么会用全表扫描，而count(*)会使用最优的索引进行用索引快速全扫描计数统一使用count(*)7. 正确使用stop机制判断member_id在offer表中是否存在记录：select count(*) from offer where member_id=234 limit 1优于select count(*) from offer where member_id=234原因是第一条sql会在得到第一条符合条件的记录后停止。高效分页1. 高效的分页使用join技术，利用索引查找到符合条件的id，构造成临时表，用这个小的临时表与原表做joinselect *from(select t.*, rownum AS rnfrom(select * from blog.blog_articlewhere domain_id=1and draft=0order by domain_id, draft, gmt_created desc) twhere rownum >= 2) awhere a.rn <= 3应该改写成select blog_article.*from(select rid, rownum as rnfrom(select rowid as id from blog.blog_articlewhere domain_id=1and draft=0order by domain_id, draft, gmt_created desc) twhere rownum >= 2) a, blog_articlewhere a.rn >= 3and a.rid = blog_article.rowid2. order by没有用到索引有索引（a, b,c ）混合排序规则ORDER BY a ASC, b DESC, c DESC /* mixed sort direction */缺失了前导列WHERE g = const ORDER BY b, c /* a prefix is missing */缺失了中间列WHERE a = const ORDER BY c /* b is missing */使用了不在索引中的列进行排序WHERE a = const ORDER BY a, d /* d is not part of index */高效地利用primary key随机查询一个错误的做法：select * from title where kind_id=1 order by rand() limit 1;create index k on title(kind_id);这个sql执行过程中需要全表扫描，并且将数据保存到临时表，这是一个非常耗时的操作。改进的做法，利用偏移量。select round(rand() * count(*)) from title where kind_id=1;select * from title where kind_id=1 limit 1 offset $random;create index k on title(kind_id);相比上面的做法，这种写法能够利用到kind_id上的索引，减少了需要扫描的数据块。但是，如果offset非常大，那么需要扫描的数据块也非常大，极端情况是扫描索引k的所有数据块。最优的做法，利用主键进行范围查找select round(rand() * count(*)) from title where kind_id=1;select * from title where kind_id = and id > $random limit 1;这个sql利用primary key进行范围查询，完全走索引，并且只读取一条记录，速度非常快。但是，这种用法的限制是primary key必须是int型，并且是连续自增长的。高效join1. 小表驱动大表进行join2. 避免子查询子查询是一个影响性能的隐患。应该使用join改写sql。数据类型1. 避免隐式转换CREATE TABLE `user` (`id` smallint(5) unsigned NOT NULL AUTO_INCREMENT,`account` char(11) NOT NULL COMMENT ”,`email` varchar(128),PRIMARY KEY (`id`),UNIQUE KEY `username` (`account`)) ENGINE=InnoDB CHARSET=utf8;mysql> explain select * from user where account=123 G*************************** 1. row ***************************id: 1select_type: SIMPLEtable: usertype: ALLpossible_keys: usernamekey: NULLkey_len: NULLref: NULLrows: 2Extra: Using where1 row in set (0.00 sec)可以看到，account=123的条件并没有用到唯一索引`username`。mysql的server从storage engine中读取所有的记录，使用to_number()函数，将记录中的account转换成数字，被转换后的数字用来和参数比较。我们的测试表里有2条记录，而执行计划中rows的值也是2，并且type的值为ALL，这也说明索引`username`并没有被用到。 代码如下:mysql> explain select * from user where account="123′ G*************************** 1. row ***************************id: 1select_type: SIMPLEtable: usertype: constpossible_keys: usernamekey: usernamekey_len: 33ref: constrows: 1Extra:1 row in set (0.00 sec)参数为字符串类型，我们可以看到索引`username`，被使用到了。这是一个经常被误用的做法。2. 主键不是自增列自增列的主键有多个好处： 插入性能高。 减小page的碎片。 提供二级索引的性能，降低二级索引的空间，因为二级索引存储的是主键的值，并不是page中的行id。您可能感兴趣的文章:用C++封装MySQL的API的教程C#连接mysql数据库完整实例浅谈MySQL中的触发器

err

这篇文章主要为大家详解Python如何读取MySQL数据库表数据，具有一定的参考价值，感兴趣的小伙伴们可以参考一下本文实例为大家分享了Python读取MySQL数据库表数据的具体代码，供大家参考，具体内容如下环境：Python 3.6 ,Window 64bit目的：从MySQL数据库读取目标表数据，并处理代码：# -*- coding: utf-8 -*-import pandas as pdimport pymysql## 加上字符集参数，防止中文乱码dbconn=pymysql.connect( host="**********", database="kimbo", user="kimbo_test", password="******", port=3306, charset="utf8" )#sql语句sqlcmd="select col_name,col_type,col_desc from itf_datadic_dtl_d limit 10"#利用pandas 模块导入mysql数据a=pd.read_sql(sqlcmd,dbconn)#取前5行数据b=a.head()print(b)# 读取csv数据# pd.read_csv()# 读取excel数据#pd.read_excel()# 读取txt数据#pd.read_table()结果如图：

基本用不上

etConnection(DBDRIVER, UDBURL去哪了？

我是你的……

I was so lonely though there was so many someone"s waitingI"m so glad that this ain"t thatGirl you"re the only reason I can make it through the long long day, and that"s a factBaby, I can"t wait to get next to you, oh I can"t wait to wrap my arms around your bodyBaby I can"t help but to tell the truthOh it"s so hard to wait till no one else is aroundI"m gonna try to keep myself togethertill I find myself in youBaby no noBefore they take you back to heavenGonna find myself in you, no noI hate to keep you waitingBut there are some things that need my attention before I can get back to youAnticipating my hands all over your body, baby you knowI know just what to doAnd baby I can"t wait to get next to you, oh I can"t wait to wrap my arms around your bodyBaby I can"t help but to tell the truthOh it"s so hard to wait till no one else is aroundI"m gonna try to keep myself togethertill I find myself in youBaby no noBefore they take you back to heavenGonna find myself in you, no no, no no babyThe only place I want to be is right here with youLoving you down and youYou can take what you want from melong as you let meHang aroundI"m gonna try to keep myself togetherTill I find myself in youOh BabyBefore they take you back to heavenGonna find myself in you, oh babyI"m gonna keep myself togetherTill I find myself in youOh, baby, babyBefore they take you back to heavenGonna find myself in youListen, listen

butterfliesinmystomach的读音是：。butterfliesinmystomach的读音是：。butterfliesinmystomach的例句是Ihadafewbutterfliesinmystomach.我心里七上八下的。Onthefirstdayofmyfirstgrade,Istoodbythedoorwithbutterfliesinmystomach.上一年级的第一天，我站在门口，心里七上八下。IfeelthatIgetbutterfliesinmystomach!我觉得我得到的蝴蝶在我的肚子。butterfliesinmystomach的意思是n.因害怕而引起的紧张。一、网络释义点此查看butterfliesinmystomach的详细内容 七上八下JolinTsai蔡依林-------七上八下（Butterfliesinmystomach）,MancyPaeng,videos,funnyvideos,celebrity,musicvideos... 肚里有只蝴蝶...butterfingers奶油手指（抓不稳东西的人）butterfliesinmystomach肚里有只蝴蝶（心里紧张，七上八下）callitanight一日事毕，可以睡觉了... 感到紧张...Butterfliesinmystomach感到紧张Hightime怎么说"早该这件事了"?Close-knit紧密的... 心里紧张心里紧张(butterfliesinmystomach),此释义来源于网络辞典。二、例句Ihadafewbutterfliesinmystomach.我心里七上八下的。Onthefirstdayofmyfirstgrade,Istoodbythedoorwithbutterfliesinmystomach.上一年级的第一天，我站在门口，心里七上八下。IfeelthatIgetbutterfliesinmystomach!我觉得我得到的蝴蝶在我的肚子！butterfliesinmystomach的相关临近词butter、butterfat点此查看更多关于butterfliesinmystomach的详细信息

52.使用完错误代码之后， 应该随手清空它，以免造成下次错误捕获不正确，我们使用一uju error变量() 53.为了防止多次数据库操作导致数据库不完整（ ）我们可以使用(colse) 54. connection 对象为我们提供了三个与事务相关的方法，请写上它们：开启事务：（connedtion.begintrans ），结束事务并保有更改：connection(.committrans )，结束事务并却小更改：connection(.rollbacktrans ) 55．如果我们查得到数据表中某个字段的信息需要用recordset对象的（fields ）集合中的（name ）对象。 56．取得field对象的方法是：set field=recordset.fields.item(i),我们可以通过field对象的（name）属性得到字段名，还可以通过（ type）属性得到字段的类型。 57．我们可以在记录集内移动指针，以便操作不同的数据记录，如果我们要将指针移到最后一条记录，可以使用（recordset.movelast ）方法，将指针移到首记录使用（recordset.movefirst ）方法，移动到上一条记录使用（recordset.previous ）方法，移动到下一条记录可使用（recordset.movenext ）方法。 58．删除记录，我们可以直接使用SQL语句中的delete语句，也可以将记录查询到之后使用recordset对象的（ delete）方法来删除当前记录。虽然直接使用Delete语句删除记录非常方便，但有时对于一些需要进行复杂判断才决定是否删除记录的情况下，我们还是要使用recordset对象的（delete ）方法来删除记录。 59．更新一条记录除可以使用update语句外，还可以将记录查询到之后，改变各字段的值，然后使用recordset对象的（ addnew ）方法来更新数据。虽然直接使用update语句更新数据十分方便，但有时对于需要进行一些不规则更新的时候还是要使用到recordset对象的（addnew ）方法来更新数据记录。

隔离级别（推荐教程：mysql教程）数据库事务的隔离级别有4个，由低到高依次为Read uncommitted(读未提交)、Read committed（读提交）、Repeatable read（可重复读取）、Serializable（可串行化），这四个级别可以逐个解决脏读、不可重复读、幻象读这几类问题。隔离级别的实现：未提交读（RU：read-uncommitted）：在RU级别中，事务读到的所有数据都是最新的数据，可能是事务提交后的数据，也可能是事务执行中的数据（可能会被回滚）。当隔离级别为RU时：所有的读不加锁，读到的数据都是最新的数据，性能最好。所有的写加行级锁，写完释放。提交读（RC：read-committed）：使用MVCC技术，在每一行加入隐藏的字段（DB_TRX_ID：修改该行的最后一个事务的id，DB_ROLL_PTR：指向当前行的undo log日志，DB_ROW_ID：行标识，DELETE_BIT：删除标志），它实现了不加锁的读操作。当隔离级别为RC时：写操作：加行级锁。事务开始后，会在UNDO日志中写入修改记录，数据行中的隐藏列DATA_POLL_PTR存储指向该行的UNDO记录的指针。读操作：不加锁。在读取时，如果该行被其它事务锁定，则顺着隐藏列DATA_POLL_PTR指针，找到上一个有效的历史记录（有效的记录：该记录对当前事务可见，且DELETE_BIT=0）。可重复读（RR：repeatable-read）：使用MVCC技术来实现不加锁的读操作。当隔离级别为RR时：写操作：加行级锁。事务开始后，会在UNDO日志中写入修改记录，数据行中的隐藏列DATA_POLL_PTR存储指向该行的UNDO记录的指针。读操作：不加锁。在读取时，如果该行被其它事务锁定，则顺着隐藏列DATA_POLL_PTR指针，找到上一个有效的历史记录（有效的记录：该记录对当前事务可见，且DELETE_BIT=0）。从上面可以知道：实际上RC和RR级别的操作基本相同，而不同之处在于：行记录对于当前事务的可见性（可见性：即哪个版本的行记录对这个事务是可见的）。RC级别对数据的可见性是该数据的最新记录，RR基本对数据的可见性是事务开始时，该数据的记录。（1）行记录的可见性（read_view）的实现在innodb中，创建一个事务的时候，会将当前系统中的活跃事务列表创建一个副本（read_view），里面存储着的都是在当前事务开始时，还没commit的事务，这些事务里的值对当前事务不可见。read_view中有两个关键值 up_limit_id（当前未提交事务的最小版本号-1，在up_limit_id之前的事务都已经提交，在up_limit_id之后的事务可能提交，可能还没提交） 和 low_limit_id（当前系统尚未分配的下一个事务id，也就是目前已出现过的事务id的最大值+1。注意：low_limit_id不是最大的活跃事务的id。）注意：当前事务和正在commit的事务是不在read_view中的。（2）无论是RC级别还是RR级别，其判断行记录的可见性的逻辑是一样的。当该事务要读取undo中的行记录时，会将行记录的版本号（DB_TRX_ID）与read_view进行比较：1、如果DB_TRX_ID小于up_limit_id，表示该行记录在当前事务开始前就已经提交了，并且DELETE_BIT=0，则该行记录对当前事务是可见的。2、如果DB_TRX_ID大于low_limit_id，表示该行记录在所在的事务在本次事务创建后才启动的，所以该行记录的当前值不可见。3、如果up_limit_id< = DB_TRX_ID <= low_limit_id，判断DB_TRX_ID是否在活跃事务链中，如果在就是不可见，如果不在就是可见的。4、如果上面判断都是不可见的，则读取undo中该行记录的上一条行记录，继续进行判断。而对于RC级别的语句级快照和RR级别的事务级快照的之间的区别，其实是由read_view生成的时机来实现的。RC级别在执行语句时，会先关闭原来的read_view，重新生成新的read_view。而RR级别的read_view则只在事务开始时创建的。所以RU级别每次获取到的都是最新的数据，而RR级别获取到的是事务开始时的数据。（3）值得注意的是： 在上面的可见性判断中，虽然逻辑是一样的，但是实际意义上是有区别的：在第二步中，对于RC级别来说，low_limit_id是执行语句时已出现的最大事务id+1，可以认为在执行语句时，是不存在事务会比low_limit_id要大，所以大于low_limit_id的事务都是不可见的。而对于RR级别来说，low_limit_id是当前事务开始时已出现的最大事务+1（也可以认为是当前事务的id+1，因为在创建当前事务时，当前事务的id最大），大于low_limit_id的事务表示是在该事务开始后创建的，所以对RR级别是不可见。在第三步中，对于RC级别来说，只要DB_TRX_ID不在活跃链表中，则无论DB_TRX_ID是否大于事务id，RC都是可见的。而对于RR级别来说，因为low_limit_id就是当前事务id+1，可以认为小于low_limit_id的事务都是在当前事务创建前出现的，所以也只需要简单判断DB_TRX_ID是否在活跃链表中。串行化（serializable）：读写都会加锁

输出如下+---+| b |+---+| 3 |+---+1 row in set但是，你在此时在从(slave)上执行该语句，得出输出如下Empty set这样，你就出现了主从不一致性的问题！原因其实很简单，就是在master上执行的顺序为先删后插！而此时binlog为STATEMENT格式，它记录的顺序为先插后删！从(slave)同步的是binglog，因此从机执行的顺序和主机不一致！就会出现主从不一致！如何解决？解决方案有两种！(1)隔离级别设为可重复读(Repeatable Read),在该隔离级别下引入间隙锁。当Session 1执行delete语句时，会锁住间隙。那么，Ssession 2执行插入语句就会阻塞住！(2)将binglog的格式修改为row格式，此时是基于行的复制，自然就不会出现sql执行顺序不一样的问题！奈何这个格式在mysql5.1版本开始才引入。因此由于历史原因，mysql将默认的隔离级别设为可重复读(Repeatable Read)，保证主从复制不出问题！那么，当我们了解完mysql选可重复读(Repeatable Read)作为默认隔离级别的原因后，接下来我们将其和读已提交(Read Commited)进行对比，来说明为什么在互联网项目为什么将隔离级别设为读已提交(Read Commited)！对比ok，我们先明白一点！项目中是不用读未提交(Read UnCommitted)和串行化(Serializable)两个隔离级别，原因有二采用读未提交(Read UnCommitted),一个事务读到另一个事务未提交读数据，这个不用多说吧，从逻辑上都说不过去！采用串行化(Serializable)，每个次读操作都会加锁，快照读失效，一般是使用mysql自带分布式事务功能时才使用该隔离级别！(笔者从未用过mysql自带的这个功能，因为这是XA事务，是强一致性事务，性能不佳！互联网的分布式方案，多采用最终一致性的事务解决方案！)也就是说，我们该纠结都只有一个问题，究竟隔离级别是用读已经提交呢还是可重复读？接下来对这两种级别进行对比，讲讲我们为什么选读已提交(Read Commited)作为事务隔离级别！假设表结构如下 CREATE TABLE `test` (`id` int(11) NOT NULL,`color` varchar(20) NOT NULL,PRIMARY KEY (`id`)) ENGINE=InnoDB数据如下+----+-------+| id | color |+----+-------+| 1 | red || 2 | white || 5 | red || 7 | white |+----+-------+为了便于描述，下面将可重复读(Repeatable Read)，简称为RR；读已提交(Read Commited)，简称为RC；缘由一：在RR隔离级别下，存在间隙锁，导致出现死锁的几率比RC大的多！此时执行语句select * from test where id <3 for update;在RR隔离级别下，存在间隙锁，可以锁住(2,5)这个间隙，防止其他事务插入数据！而在RC隔离级别下，不存在间隙锁，其他事务是可以插入数据！ps:在RC隔离级别下并不是不会出现死锁，只是出现几率比RR低而已！缘由二：在RR隔离级别下，条件列未命中索引会锁表！而在RC隔离级别下，只锁行此时执行语句update test set color = ‘blue‘ where color = ‘white‘; 在RC隔离级别下，其先走聚簇索引，进行全部扫描。加锁如下：但在实际中，MySQL做了优化，在MySQL Server过滤条件，发现不满足后，会调用unlock_row方法，把不满足条件的记录放锁。实际加锁如下然而，在RR隔离级别下，走聚簇索引，进行全部扫描，最后会将整个表锁上，如下所示缘由三：在RC隔离级别下，半一致性读(semi-consistent)特性增加了update操作的并发性！在5.1.15的时候，innodb引入了一个概念叫做“semi-consistent”，减少了更新同一行记录时的冲突，减少锁等待。所谓半一致性读就是，一个update语句，如果读到一行已经加锁的记录，此时InnoDB返回记录最近提交的版本，由MySQL上层判断此版本是否满足update的where条件。若满足(需要更新)，则MySQL会重新发起一次读操作，此时会读取行的最新版本(并加锁)！具体表现如下:此时有两个Session，Session1和Session2！Session1执行update test set color = ‘blue‘ where color = ‘red‘; 先不Commit事务！与此同时Ssession2执行update test set color = ‘blue‘ where color = ‘white‘; session 2尝试加锁的时候，发现行上已经存在锁，InnoDB会开启semi-consistent read，返回最新的committed版本(1,red),(2，white),(5,red),(7,white)。MySQL会重新发起一次读操作，此时会读取行的最新版本(并加锁)!而在RR隔离级别下，Session2只能等待！两个疑问在RC级别下，不可重复读问题需要解决么？不用解决，这个问题是可以接受的！毕竟你数据都已经提交了，读出来本身就没有太大问题！Oracle的默认隔离级别就是RC，你们改过Oracle的默认隔离级别么？在RC级别下，主从复制用什么binlog格式？OK,在该隔离级别下，用的binlog为row格式，是基于行的复制！Innodb的创始人也是建议binlog使用该格式！总结本文_里八嗦了一篇文章只是为了说明一件事，互联网项目请用：读已提交(Read Commited)这个隔离级别！【转】互联网项目中mysql应该选什么事务隔离级别标签：主从简单重复div提交阅读就是imagebug

1、MySQL InnoDB事务隔离级别脏读、可重复读、幻读MySQL InnoDB事务的隔离级别有四级，默认是“可重复读”（REPEATABLE READ）。· 1）.未提交读（READUNCOMMITTED）。另一个事务修改了数据，但尚未提交，而本事务中的SELECT会读到这些未被提交的数据（脏读）( 隔离级别最低，并发性能高 )。· 2）.提交读（READCOMMITTED）。本事务读取到的是最新的数据（其他事务提交后的）。问题是，在同一个事务里，前后两次相同的SELECT会读到不同的结果（不重复读）。会出现不可重复读、幻读问题（锁定正在读取的行）· 3）.可重复读（REPEATABLEREAD）。在同一个事务里，SELECT的结果是事务开始时时间点的状态，因此，同样的SELECT操作读到的结果会是一致的。但是，会有幻读现象（稍后解释）。会出幻读（锁定所读取的所有行）。· 4）.串行化（SERIALIZABLE）。读操作会隐式获取共享锁，可以保证不同事务间的互斥（锁表）。‘四个级别逐渐增强，每个级别解决一个问题。· 1）.脏读。另一个事务修改了数据，但尚未提交，而本事务中的SELECT会读到这些未被提交的数据。· 2）.不重复读。解决了脏读后，会遇到，同一个事务执行过程中，另外一个事务提交了新数据，因此本事务先后两次读到的数据结果会不一致。· 3）.幻读。解决了不重复读，保证了同一个事务里，查询的结果都是事务开始时的状态（一致性）。但是，如果另一个事务同时提交了新数据，本事务再更新时，就会“惊奇的”发现了这些新数据，貌似之前读到的数据是“鬼影”一样的幻觉。 具体地： 1). 脏读 首先区分脏页和脏数据 脏页是内存的缓冲池中已经修改的page，未及时flush到硬盘，但已经写到redo log中。读取和修改缓冲池的page很正常，可以提高效率，flush即可同步。脏数据是指事务对缓冲池中的行记录record进行了修改，但是还没提交！！！，如果这时读取缓冲池中未提交的行数据就叫脏读，违反了事务的隔离性。脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。 2). 不可重复读 是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，第二个事务已经提交。那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。例如，一个编辑人员两次读取同一文档，但在两次读取之间，作者重写了该文档。当编辑人员第二次读取文档时，文档已更改。原始读取不可重复。如果只有在作者全部完成编写后编辑人员才可以读取文档，则可以避免该问题 3). 幻读 : 是指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。例如，一个编辑人员更改作者提交的文档，但当生产部门将其更改内容合并到该文档的主复本时，发现作者已将未编辑的新材料添加到该文档中。如果在编辑人员和生产部门完成对原始文档的处理之前，任何人都不能将新材料添加到文档中，则可以避免该问题。2、隔离级别实验 以下实验基于博主MySQL Server 5.6 首先创建一个表，如下：USE test; CREATE TABLE `t` ( `a` int(11) NOT NULL PRIMARY KEY ) ENGINE=InnoDB DEFAULT CHARSET=utf8;2.1、实验一：解释脏读、可重复读问题 事务A READ-UNCOMMITTED事务B READ-COMMITTED,事务C-1 REPEATABLE-READ事务C-2 REPEATABLE-READ事务D SERIALIZABLEset autocommit =0;start transaction ;start transaction; insert into t(a)values(4);select * from t;1,2,3,4(脏读：读取到了未提交的事务中的数据)select * from t;1,2,3（解决脏读）select * from t;1,2,3select * from t;1,2,3select * from t;1,2,3commit;select * from t:1,2,3,4select * from t:1,2,3,4select * from t:1,2,3,4 (与上面的不在一个事务中，所以读到为事务提交后最新的，所以可读到4)select * from t:1,2,3（重复读：由于与上面的在一个事务中，所以只读到事务开始事务的数据，也就是重复读）select * from t:1,2,3,4 commit（提交事务，下面的就是一个新的事务，所以可以读到事务提交以后的最新数据）select * from t:1,2,3,4 READ-UNCOMMITTED 会产生脏读，基本很少适用于实际场景，所以基本不使用。2.2、实验二：测试READ-COMMITTED与REPEATABLE-READ事务A事务B READ-COMMITTED事务C REPEATABLE-READset autocommit =0;start transaction ;start transaction;start transaction;insert into t(a)values(4);select * from t;1,2,3select * from t;1,2,3commit;select * from t:1,2,3,4select * from t:1,2,3（重复读：由于与上面的在一个事务中，所以只读到事务开始事务的数据，也就是重复读）commit（提交事务，下面的就是一个新的事务，所以可以读到事务提交以后的最新数据）select * from t:1,2,3,4REPEATABLE-READ可以确保一个事务中读取的数据是可重复的，也就是相同的读取（第一次读取以后，即使其他事务已经提交新的数据，同一个事务中再次select也并不会被读取）。READ-COMMITTED只是确保读取最新事务已经提交的数据。当然数据的可见性都是对不同事务来说的，同一个事务，都是可以读到此事务中最新数据的。如下，start transaction; insert into t(a)values(4); select *from t; 1,2,3,4; insert into t(a)values(5); select *from t; 1,2,3,4,5;2.3、实验三：测试SERIALIZABLE事务对其他的影响事务A SERIALIZABLE事务B READ-UNCOMMITTED事务C READ-COMMITTED,事务D REPEATABLE-READ事务E SERIALIZABLEset autocommit =0; start transaction ;start transaction; select a from t union all select sleep(1000) from dual;insert into t(a)values(5);insert into t(a)values(5);insert into t(a)values(5);insert into t(a)values(5); ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transactionERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transactionERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transactionERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction SERIALIZABLE 串行化执行，导致所有其他事务不得不等待事务A结束才行可以执行，这里特意使用了sleep函数，直接导致事务B,C,D,E等待事务A持有释放的锁。由于我sleep了1000秒，而innodb_lock_wait_timeout为120s。所以120s到了就报错HY000错误。SERIALIZABLE是相当严格的串行化执行模式，不管是读还是写，都会影响其他读取相同的表的事务。是严格的表级读写排他锁。也就失去了innodb引擎的优点。实际应用很少。2.4、实验四：幻读一些文章写到InnoDB的可重复读避免了“幻读”（phantom read），这个说法并不准确。做个实验：(以下所有试验要注意存储引擎和隔离级别)CREATE TABLE `t_bitfly` ( `id` bigint(20) NOT NULL default "0", `value` varchar(32) default NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; select @@global.tx_isolation, @@tx_isolation; +-----------------------+-----------------+ | @@global.tx_isolation | @@tx_isolation | +-----------------------+-----------------+ | REPEATABLE-READ | REPEATABLE-READ | +-----------------------+-----------------+ 实验4-1：Session ASession Bstart transaction ;start transaction ;SELECT * FROM t_bitfly;empty setINSERT INTO t_bitfly VALUES (1, "a");COMMIT;SELECT * FROM t_bitfly;| empty setINSERT INTO t_bitfly VALUES (1, "a");|ERROR 1062 (23000):|Duplicate entry "1" for key 1(刚刚明明告诉我没有这条记录的)I如此就出现了幻读，以为表里没有数据，其实数据已经存在了，提交后，才发现数据冲突了。实验4-2：Session ASession Bstart transaction ;start transaction ;SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+INSERT INTO t_bitfly VALUES (2, "b");SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+COMMIT;SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+ UPDATE t_bitfly SET value="z";| Rows matched: 2 Changed:2 Warnings: 0(怎么多出来一行)SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |z || | 2 |z || +------+-------+本事务中第一次读取出一行，做了一次更新后，另一个事务里提交的数据就出现了。也可以看做是一种幻读。附说明那么，InnoDB指出的可以避免幻读是怎么回事呢？http://dev.mysql.com/doc/refman/5.0/en/innodb-record-level-locks.htmlBy default, InnoDB operatesin REPEATABLE READ transaction isolation level and with the innodb_locks_unsafe_for_binlog system variable disabled. In this case, InnoDB uses next-key locks for searches and index scans, which prevents phantom rows (see Section 13.6.8.5, “Avoidingthe Phantom Problem Using Next-Key Locking”).准备的理解是，当隔离级别是可重复读，且禁用innodb_locks_unsafe_for_binlog的情况下，在搜索和扫描index的时候使用的next-keylocks可以避免幻读。关键点在于，是InnoDB默认对一个普通的查询也会加next-key locks，还是说需要应用自己来加锁呢？如果单看这一句，可能会以为InnoDB对普通的查询也加了锁，如果是，那和序列化（SERIALIZABLE）的区别又在哪里呢？MySQL manual里还有一段：13.2.8.5. Avoiding the PhantomProblem Using Next-Key Locking (http://dev.mysql.com/doc/refman/5.0/en/innodb-next-key-locking.html)Toprevent phantoms, InnoDB usesan algorithm called next-key locking that combinesindex-row locking with gap locking.Youcan use next-key locking to implement a uniqueness check in your application:If you read your data in share mode and do not see a duplicate for a row you are going to insert, then you can safely insert your row and know that the next-key lock set on the success or of your row during the read prevents anyone mean while inserting a duplicate for your row. Thus, the next-key locking enables you to “lock” the nonexistence of something in your table.我的理解是说，InnoDB提供了next-key locks，但需要应用程序自己去加锁。manual里提供一个例子：SELECT * FROM child WHERE id> 100 FOR UPDATE;这样，InnoDB会给id大于100的行（假如child表里有一行id为102），以及100-102，102+的gap都加上锁。可以使用show engine innodb status来查看是否给表加上了锁。再看一个实验，要注意，表t_bitfly里的id为主键字段。实验4-3：Session ASession Bstart transaction ;start transaction ;SELECT * FROM t_bitfly WHERE id<=1 FOR UPDATE;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+INSERT INTO t_bitfly VALUES (2, "b");| Query OK, 1 row affectedSELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+INSERT INTO t_bitfly VALUES (0, "0");| (waiting for lock ...| then timeout) ERROR 1205 (HY000):Lock wait timeout exceeded;|try restarting transactionSELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+COMMIT;SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+可以看到，用id<=1加的锁，只锁住了id<=1的范围，可以成功添加id为2的记录，添加id为0的记录时就会等待锁的释放。附说明：MySQL manual里对可重复读里的锁的详细解释：http://dev.mysql.com/doc/refman/5.0/en/set-transaction.html#isolevel_repeatable-readFor locking reads (SELECT with FOR UPDATE or LOCK IN SHARE MODE),UPDATE, and DELETE statements, locking depends on whether the statement uses a unique index with a unique search condition, or a range-type search condition. For a unique index with a unique search condition, InnoDB locks only the index record found, not the gap before it. For other search conditions, InnoDB locks the index range scanned, using gap locks or next-key (gap plus index-record)locks to block insertions by other sessions into the gaps covered by the range.一致性读和提交读，先看实验，实验4-4：Session ASession Bstart transaction ;start transaction ;SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+INSERT INTO t_bitfly VALUES (2, "b"); COMMIT;SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+SELECT * FROM t_bitfly LOCK IN SHARE MODE;| +----+-------+| | id | value || +----+-------+| | 1 |a || | 2 |b || +----+----

（推荐教程：mysql教程）Mysql的四种隔离级别SQL标准定义了4类隔离级别，包括了一些具体规则，用来限定事务内外的哪些改变是可见的，哪些是不可见的。低级别的隔离级一般支持更高的并发处理，并拥有更低的系统开销。1、Read Uncommitted（读取未提交内容）在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用，因为它的性能也不比其他级别好多少。读取未提交的数据，也被称之为脏读（Dirty Read）。2、Read Committed（读取提交内容）这是大多数数据库系统的默认隔离级别（但不是MySQL默认的）。它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。这种隔离级别 也支持所谓的不可重复读（Nonrepeatable Read），因为同一事务的其他实例在该实例处理其间可能会有新的commit，所以同一select可能返回不同结果。3、Repeatable Read（可重读）这是MySQL的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。不过理论上，这会导致另一个棘手的问题：幻读 （Phantom Read）。简单的说，幻读指当用户读取某一范围的数据行时，另一个事务又在该范围内插入了新行，当用户再读取该范围的数据行时，会发现有新的“幻影” 行。InnoDB和Falcon存储引擎通过多版本并发控制（MVCC，Multiversion Concurrency Control）机制解决了该问题。4、Serializable（可串行化）这是最高的隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。简言之，它是在每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争。问题这四种隔离级别采取不同的锁类型来实现，若读取的是同一个数据的话，就容易发生问题。例如：1、脏读(Drity Read)：某个事务已更新一份数据，另一个事务在此时读取了同一份数据，由于某些原因，前一个RollBack了操作，则后一个事务所读取的数据就会是不正确的。2、不可重复读(Non-repeatable read)：在一个事务的两次查询之中数据不一致，这可能是两次查询过程中间插入了一个事务更新的原有的数据。3、幻读(Phantom Read)：在一个事务的两次查询中数据笔数不一致，例如有一个事务查询了几列(Row)数据，而另一个事务却在此时插入了新的几列数据，先前的事务在接下来的查询中，就会发现有几列数据是它先前所没有的。

在read uncommitted(未提交读)级别中，事务中的修改，即使没有提交，对其他事务也是可见的。事务可以读取未提交的数据，这种也可以叫脏读，这个级别其实会导致很多问题，从性能上讲，未提交读不会比其他级别好太多，但却缺乏其他级别的好处，除非真的非常有必要，在实际中一般不使用的。mysql有个多版本控制MVCC，可以认为MVCC是行级锁的一个变种，但他在很多情况下避免了加锁操作，因此开销更低。MVCC实际上是乐观并发控制的，通过每行的记录后面保存两个隐藏的列实现，一个是创建时间，一个是删除时间，当然实际存储的不是时间值，而是版本号。MVCC只在repeatable read和read committed两个级别下工作，其他隔离级别都和MVCC不兼容，因为read uncommitted总是读到最新数据，而不是符合当前事务版本的数据行。综上所述，乐观锁是和读已提交搭配使用是可以的

隔离级别事务的隔离级别分为：未提交读(read uncommitted)、已提交读(read committed)、可重复读(repeatable read)、串行化(serializable)。（视频教程推荐：mysql视频教程）未提交读A事务已执行，但未提交；B事务查询到A事务的更新后数据；A事务回滚；---出现脏数据已提交读A事务执行更新；B事务查询；A事务又执行更新；B事务再次查询时，前后两次数据不一致；---不可重复读可重复读A事务无论执行多少次，只要不提交，B事务查询值都不变；B事务仅查询B事务开始时那一瞬间的数据快照；串行化不允许读写并发操作，写执行时，读必须等待；（相关教程推荐：mysql教程）具体命令：//设置mysql的隔离级别：set session transaction isolation level 事务隔离级别//设置read uncommitted级别：set session transaction isolation level read uncommitted;//设置read committed级别：set session transaction isolation level read committed;//设置repeatable read级别：set session transaction isolation level repeatable read;//设置serializable级别：set session transaction isolation level serializable;

MySQL 中的 VARCHAR(255) 可以存放 1 - 255 个 UTF-8 格式的汉字 ...latin1 字符集最多可以存放 85 个 UTF-8 格式的汉字 ...utf-8 字符集最多可以存放 255 个 UTF-8 格式的汉字 ...如果哪个大神可以找到一个占用两字节或者占用四字节的汉字那么我的这个答案就错了 ...

本文介绍 MySQL 8.0 shell 子模块 Util 的两个导入特性 importTable/import_table(JS和python 版本的命名差异)、importJson/import_json的使用方法。其中 import_table 是通过传统 MySQL 协议来通信，Import_json 是通过 X 插件协议来通信。MySQL 一直以来提供导入文件 SQL 命令 load data infile（单线程）以及对应的可执行文件 mysqlimport（多线程）。比如我导入 100W 行示例数据到表 ytt.tl1，花了 24 秒。这个已经是 MySQL 默认导入来的最快的。分析那我们现在看下 mysqlimport 工具的升级版，mysqlshell 的 util 工具集。使用这两个工具之前，必须得临时开启 local_infile 选项。1. import_table建立 3306 端口的新连接我这里切换为 python 模式清空掉示例表 Ytt.tl1import_table 有两个参数，第一个参数定义导入文件的路径，第二个定义相关选项，比如导入的格式，并发的数量等。定义文件路径（参数1）定义选项（参数2）执行导入：只花了不到 17 秒，比传统 mysqlimport 快了不少。我们上面指定了显式指定了字段分隔符，那有没有已经定义好的组合格式呢？ 答案是有的，选项 dialect 可以指定以下格式：csv，tsv，json，csv-unix那么上面的导入，我们可以更简单，改下变量 y_options1 的定义导入时间差不多。这里要说明下，dialect 选项的优先级比较低，比如添加了"linesTerminatedBy":" "， 则覆盖他自己的" "。选项 diaelect 还有一个可选值为 json，可以直接把 json 结果导入到文档表里。比如我新建一张表 tl1_json重新定义文件以及导入选项。导入 JSON 数据速度也还可以，不到 24 秒。那导入 json 数据，就必须得提到以 X 插件协议通信的工具 import_json了。2. imort_json我们切换到 mysqlx 端口import_json 参数和 Import_table 参数类似，这里我改下选项我在手册上没有看到多线程的选项，所以单线程跑 35 秒慢了些。查看刚刚导入的数据import_json 不仅仅可以导入 Json 数据，更重要的是可以在 BSON 和 JSON 之间平滑的转换，有兴趣的同学可以去 TRY 下。

摘要： Hi! I am a happy and cute boy. I am from China.I am fourteen years old, I am a pupil, I am in Class Three，Gread Four.I have many good friends.I like many pet,the peacock ，panda， rabbit and bird,th 初中英语期中考试复习 初中英语期中考试专题为您提供初中英语期中考试题及期中英语考试总结，包括初三英语期……[详细] 中考英语交际运用 36个考试热点总结 提升中考阅读的十四法 | 新初三秋季学习规划 轻松记忆单词的四种方法 | 趣味学初中语法 中考重点句型错误分析 | 逐题型多技巧答好试卷 Hi! I am a happy and cute boy. I am from China.I am fourteen years old, I am a pupil, I am in Class Three，Gread Four.I have many good friends.I like many pet,the peacock ，panda， rabbit and bird,they are lovely.I am tall ,I have a around face, big eyes ,a small mouth and a small nose. I have black and short hair.I like eatting apple, banana , chicken and so on.I like music very much. I often say: book is my good friend,I like it a lot! Who am I?Yes,my name is Tom. Do you like me? 课程名称 课时 课程价格 视频解读 在线选课 秋季班初一年级英语目标人大附四中班 15 2495 秋季班初一年级英语尖子班 15 2495 秋季班初二年级英语目标人大附四中班 15 2495 秋季班初二年级英语尖子班 15 2495 秋季班初三年级英语目标人大附四中班 15 2495 咨询电话: 010-52926678 （每天早10点至晚7点） 《初中英语作文:初中英语作文 我自己 Myself》由liuxue86.com我整理

说明 : string1,string2代表字符串,concat函数在连接字符串的时候，只要其中一个是NULL,那么将返回NULL 结果： 说明：将多个字符串连接成一个字符串，但是可以一次性指定分隔符～（concat_ws就是concat with separator） GROUP_CONCAT([DISTINCT] expr [,expr ...] [ORDER BY {unsigned_integer | col_name | expr} [ASC | DESC] [,col_name ...]] [SEPARATOR str_val]) 说明： DISTINCT：去除重复值 expr [,expr ...]：一个或多个字段（或表达式） ORDER BY {unsigned_integer | col_name | expr} [ASC | DESC] [,col_name ...]：根据字段或表达式进行排序，可多个 SEPARATOR str_val：分隔符（默认为英文逗号） group_concat()函数在处理大数据的时候，会发现内容被截取了 其实MYSQL内部对这个是有设置的，默认不设置的长度是1024，如果我们需要更大，就需要手工去修改配置文件

在mysql中，一个TEXT列，最大长度为65535(2^16-1)个字符，也就是64K的数据。MEDIUMBLOBMEDIUMTEXT一个BLOB或TEXT列，最大长度为16777215(2^24-1)个字符。LONGBLOBLONGTEXT一个BLOB或TEXT列，最大长度为4294967295(2^32-1)个字符。

abandon oneself to指使放纵，使听任abandon myself指自我放纵， 或者说放任自流

在建设网站的过程中，经常要处理一些数据的导入及导出．在Mysql数据库中，有两种方法来处理数据的导出（一般）． 1. 使用select * from table_name into outfile “file_name”; 2. 使用mysqldump实用程序 下面我们来举例说明： 假设我们的数据库中有一个库为samp_db,一个表为samp_table．现在要把samp_table的数据导出．则我们可以利用以下方法来实现： 在Mysql提示符下打入select * from samp_table into outfile “file_name”; 在系统命令提示符下打入mysqldump –u root samp_db samp_table >samp.sql (当然mysqldump有很多选项．如 －d 表示只导出表结构；　－t 表示只导入表数据) 如何来处理数据的导入：一般我们在系统命令提示符下打入mysqlimport –u root samp_db samp_table.txt（注意：这个TXT文件名必须以表的名字命名）．对于mysqldump导出的数据我们还可以用mysql –u root samp_db < file_name来导入．在Mysql提示符下我们用Load data infile “file_name” into table samp_table. 另外除了以上方法，对于移动后的数据库系统与原系统一致的前提下，我们可以通过文件的拷贝来实现数据的导入与导出．首先我们用mysqladmin –u root variables（在系统命令提示符下）或者用show variables;（在Mysql提示符下）来找到datadir．如在我的环境下，此目录在c:mysqldata．然后对其中的一些文件进行拷贝．一切ok! 有了以上知识后，我们进入正题：如何把ACCESS的数据导入到Mysql中． 首先我们把数据从ACCESS中导出为文本文件．在导出过程中注意选择好字段分隔符和文本标识符,且查看一下文本文件,确定一个记录是否在同一行上,如不是,则手工把回车键除掉.假如我们导出的文本文件为c:samp_table.txt．其内容如下： 1,张新化,男 2,江先进,女 接下来我们用mysqlimport –u root –fields-terminated-by=”,” samp_db samp_table.txt 或者用load data infile “c:\samp_table.txt” into table samp_table fields terminated by “,”; 去试一下(注意转义字符)，是不是一切ok！如果还不行，请仔细看一下具体命令的帮助．下面列出一些选项： --fields-enclosed-by=char 指明列值应包括在指定的字符中．通常用引号．缺省时，假定列值不包括在任何字符中． --fields-escaped-by=char 表示用于转义特殊字符的转义符．缺省时表示无转义符 --fields-terminated-by=char 指定分隔列的字符．缺省时假定列值由制表符分隔． --lines-terminated-by=str 指定结束输入行的串（可以是多字符的）．缺省时假定由换行符终止行．

MySQL SUM()函数介绍SUM()函数用于计算一组值或表达式的总和，SUM()函数的语法如下：SUM(DISTINCT expression)SUM()函数是如何工作的？如果在没有返回匹配行SELECT语句中使用SUM函数，则SUM函数返回NULL，而不是0。DISTINCT运算符允许计算集合中的不同值。SUM函数忽略计算中的NULL值。MySQL SUM()函数示例我们来看看示例数据库(yiibaidb)中的orderdetails表。可以使用SUM()函数来计算订单编号10100的总金额，如下查询所示：SELECT FORMAT(SUM(quantityOrdered * priceEach),2) total FROM orderdetails WHERE orderNumber = 10100;执行上面查询语句，得到以下结果 mysql> SELECT FORMAT(SUM(quantityOrdered * priceEach),2) total FROM orderdetails WHERE orderNumber = 10100;+-----------+| total |+-----------+| 10,223.83 |+-----------+1 row in setSQL请注意，FORMAT()函数用于格式化SUM()函数的返回值。

优化SQL查询：如何写出高性能SQL语句 1、首先要搞明白什么叫执行计划？ 执行计划是数据库根据SQL语句和相关表的统计信息作出的一个查询方案，这个方案是由查询优化器自动分析产生_如一条SQL语句如果用来从一个10万条记录的表中查1条记录，那查询优化器会选择“索引查找”方式，如果该表进行了归档，当前只剩下5000条记录了，那查询优化器就会改变方案，采用 “全表扫描”方式。 可见，执行计划并不是固定的，它是“个性化的”。产生一个正确的“执行计划”有两点很重要： (1) SQL语句是否清晰地告诉查询优化器它想干什么？ (2) 查询优化器得到的数据库统计信息是否是最新的、正确的？ 2、统一SQL语句的写法 对于以下两句SQL语句，程序员认为是相同的，数据库查询优化器认为是不同的。 select * from dual select * From dual 其实就是大小写不同，查询分析器就认为是两句不同的SQL语句，必须进行两次解析。生成2个执行计划。 所以作为程序员，应该保证相同的查询语句在任何地方都一致，多一个空格都不行！ 3、不要把SQL语句写得太复杂 我经常看到，从数据库中捕捉到的一条SQL语句打印出来有2张A4纸这么长。一般来说这么复杂的语句通常都是有问题的。我拿着这2页长的SQL语句去请教原作者，结果他说时间太长，他一时也看不懂了。可想而知，连原作者都有可能看糊涂的SQL语句，数据库也一样会看糊涂。 一般，将一个Select语句的结果作为子集，然后从该子集中再进行查询，这种一层嵌套语句还是比较常见的，但是根据经验，超过3层嵌套，查询优化器就很容易给出错误的执行计划。因为它被绕晕了。像这种类似人工智能的东西，终究比人的分辨力要差些，如果人都看晕了，我可以保证数据库也会晕的。 另外，执行计划是可以被重用的，越简单的SQL语句被重用的可能性越高。而复杂的SQL语句只要有一个字符发生变化就必须重新解析，然后再把这一大堆垃圾塞在内存里。可想而知，数据库的效率会何等低下。 4、使用“临时表”暂存中间结果 简化SQL语句的重要方法就是采用临时表暂存中间结果，但是，临时表的好处远远不止这些，将临时结果暂存在临时表，后面的查询就在tempdb中了，这可以避免程序中多次扫描主表，也大大减少了程序执行中“共享锁”阻塞“更新锁”，减少了阻塞，提高了并发性能。 5、 OLTP系统SQL语句必须采用绑定变量 select * from orderheader where changetime > u20192010-10-20 00:00:01u2032 select * from orderheader where changetime > u20192010-09-22 00:00:01u2032 以上两句语句，查询优化器认为是不同的SQL语句，需要解析两次。 如果采用绑定变量 select * from orderheader where changetime > @chgtime @chgtime变量可以传入任何值，这样大量的类似查询可以重用该执行计划了，这可以大大降低数据库解析SQL语句的负担。一次解析，多次重用，是提高数据库效率的原则。 6、绑定变量窥测 事物都存在两面性，绑定变量对大多数OLTP处理是适用的，但是也有例外。 比如在where条件中的字段是“倾斜字段”的时候。 “倾斜字段”指该列中的绝大多数的值都是相同的，一张人口调查表，其中“民族”这列，90%以上都是汉族。那么如果一个SQL语句要查询30岁的汉族人口有多少，那“民族”这列必然要被放在where条件中。这个时候如果采用绑定变量@nation会存在很大问题。 试想如果@nation传入的第一个值是“汉族”，那整个执行计划必然会选择表扫描。然后，第二个值传入的是“布依族”，按理说“布依族”占的比例可能只有万分之一，应该采用索引查找。但是，由于重用了第一次解析的“汉族”的那个执行计划，那么第二次也将采用表扫描方式。这个问题就是著名的“绑定变量窥测”，建议对于“倾斜字段”不要采用绑定变量。 7、 只在必要的情况下才使用begin tran SQL Server中一句SQL语句默认就是一个事务，在该语句执行完成后也是默认commit的。其实，这就是begin tran的一个最小化的形式，好比在每句语句开头隐含了一个begin tran，结束时隐含了一个commit。 有些情况下，我们需要显式声明begin tran，比如做“插、删、改”操作需要同时修改几个表，要求要么几个表都修改成功，要么都不成功。begin tran 可以起到这样的作用，它可以把若干SQL语句套在一起执行，最后再一起commit。好处是保证了数据的一致性，但任何事情都不是完美无缺的。Begin tran付出的代价是在提交之前，所有SQL语句锁住的资源都不能释放，直到commit掉。 可见，如果Begin tran套住的SQL语句太多，那数据库的性能就糟糕了。在该大事务提交之前，必然会阻塞别的语句，造成block很多。 Begin tran使用的原则是，在保证数据一致性的前提下，begin tran 套住的SQL语句越少越好！有些情况下可以采用触发器同步数据，不一定要用begin tran。 8、一些SQL查询语句应加上nolock 在SQL语句中加nolock是提高SQL Server并发性能的重要手段，在oracle中并不需要这样做，因为oracle的结构更为合理，有undo表空间保存“数据前影”，该数据如果在修改中还未commit，那么你读到的是它修改之前的副本，该副本放在undo表空间中。这样，oracle的读、写可以做到互不影响，这也是oracle 广受称赞的地方。 SQL Server 的读、写是会相互阻塞的，为了提高并发性能，对于一些查询，可以加上nolock，这样读的时候可以允许写，但缺点是可能读到未提交的脏数据。 使用 nolock有3条原则。 (1) 查询的结果用于“插、删、改”的不能加nolock ！ (2) 查询的表属于频繁发生页分裂的，慎用nolock ！ (3) 使用临时表一样可以保存“数据前影”，起到类似oracle的undo表空间的功能， 能采用临时表提高并发性能的，不要用nolock 。 9、聚集索引没有建在表的顺序字段上，该表容易发生页分裂 比如订单表，有订单编号orderid，也有客户编号contactid，那么聚集索引应该加在哪个字段上呢？对于该表，订单编号是顺序添加的，如果在orderid上加聚集索引，新增的行都是添加在末尾，这样不容易经常产生页分裂。然而，由于大多数查询都是根据客户编号来查的，因此，将聚集索引加在contactid上才有意义。而contactid对于订单表而言，并非顺序字段。 比如“张三”的“contactid”是001，那么“张三”的订单信息必须都放在这张表的第一个数据页上，如果今天“张三”新下了一个订单，那该订单信息不能放在表的最后一页，而是第一页！如果第一页放满了呢？很抱歉，该表所有数据都要往后移动为这条记录腾地方。 SQL Server的索引和Oracle的索引是不同的，SQL Server的聚集索引实际上是对表按照聚集索引字段的顺序进行了排序，相当于oracle的索引组织表。SQL Server的聚集索引就是表本身的一种组织形式，所以它的效率是非常高的。也正因为此，插入一条记录，它的位置不是随便放的，而是要按照顺序放在该放的数据页，如果那个数据页没有空间了，就引起了页分裂。所以很显然，聚集索引没有建在表的顺序字段上，该表容易发生页分裂。 曾经碰到过一个情况，一位哥们的某张表重建索引后，插入的效率大幅下降了。估计情况大概是这样的。该表的聚集索引可能没有建在表的顺序字段上，该表经常被归档，所以该表的数据是以一种稀疏状态存在的。比如张三下过20张订单，而最近3个月的订单只有5张，归档策略是保留3个月数据，那么张三过去的 15张订单已经被归档，留下15个空位，可以在insert发生时重新被利用。在这种情况下由于有空位可以利用，就不会发生页分裂。但是查询性能会比较低，因为查询时必须扫描那些没有数据的空位。 重建聚集索引后情况改变了，因为重建聚集索引就是把表中的数据重新排列一遍，原来的空位没有了，而页的填充率又很高，插入数据经常要发生页分裂，所以性能大幅下降。 对于聚集索引没有建在顺序字段上的表，是否要给与比较低的页填充率？是否要避免重建聚集索引？是一个值得考虑的问题！ 10、加nolock后查询经常发生页分裂的表，容易产生跳读或重复读 加nolock后可以在“插、删、改”的同时进行查询，但是由于同时发生“插、删、改”，在某些情况下，一旦该数据页满了，那么页分裂不可避免，而此时nolock的查询正在发生，比如在第100页已经读过的记录，可能会因为页分裂而分到第101页，这有可能使得nolock查询在读101页时重复读到该条数据，产生“重复读”。同理，如果在100页上的数据还没被读到就分到99页去了，那nolock查询有可能会漏过该记录，产生“跳读”。 上面提到的哥们，在加了nolock后一些操作出现报错，估计有可能因为nolock查询产生了重复读，2条相同的记录去插入别的表，当然会发生主键冲突。 11、使用like进行模糊查询时应注意 有的时候会需要进行一些模糊查询比如 select * from contact where username like u2018%yue%u2019 关键词%yue%，由于yue前面用到了“%”，因此该查询必然走全表扫描，除非必要，否则不要在关键词前加%， 12、数据类型的隐式转换对查询效率的影响 sql server2000的数据库一的程序在提交sql语句的时候，没有使用强类型提交这个字段的值，由sql server 2000自动转换数据类型，会导致传入的参数与主键字段类型不一致，这个时候sql server 2000可能就会使用全表扫描。Sql2005上没有发现这种问题，但是还是应该注意一下。 13、SQL Server 表连接的三种方式 (1) Merge Join (2) Nested Loop Join (3) Hash Join SQL Server 2000只有一种join方式——Nested Loop Join，如果A结果集较小，那就默认作为外表，A中每条记录都要去B中扫描一遍，实际扫过的行数相当于A结果集行数x B结果集行数。所以如果两个结果集都很大，那Join的结果很糟糕。 SQL Server 2005新增了Merge Join，如果A表和B表的连接字段正好是聚集索引所在字段，那么表的顺序已经排好，只要两边拼上去就行了，这种join的开销相当于A表的结果集行数加上B表的结果集行数，一个是加，一个是乘，可见merge join 的效果要比Nested Loop Join好多了。 如果连接的字段上没有索引，那SQL2000的效率是相当低的，而SQL2005提供了Hash join，相当于临时给A，B表的结果集加上索引，因此SQL2005的效率比SQL2000有很大提高，我认为，这是一个重要的原因。 总结一下，在表连接时要注意以下几点： (1) 连接字段尽量选择聚集索引所在的字段 (2) 仔细考虑where条件，尽量减小A、B表的结果集 (3) 如果很多join的连接字段都缺少索引，而你还在用SQL Server 2000，赶紧升级吧。

PL/SQL Developer是一个集成开发环境，专门面向Oracle数据库存储程序单元的开发。不是mysql；MySQL是一个开放源码的小型关联式数据库管理系统SQL Server是由Microsoft开发和推广的关系数据库管理系统（DBMS）这三个的驱动不一样

plsql developer 能连mysql的，具体方法步骤如下：1、首先打开PLSQL界面，在弹出的登录框内这个输入正确的用户名密码，以及ip地址端口号，然后单击确定。2、单击确定后，在弹出的提示窗口内单击“ok”。3、单击后在图下界面内找到“工具”选项并单击，再在工具选项栏内单击“首选项”选项。4、进入首选项界面后，在界面内加入一个配设文件路径。5、文件路劲地址复制进去后，在弹出的窗口内单击确定，然后关闭PLSQL程序，重新打开PLSQL。6、重新打开PLSQL程序时，如果发现界面内出现了一个“连接为”的选项，plsql developer 就成功连接上了mysql了。

歌曲名:Talking To Myself歌手:Maggie Reilly专辑:StarcrossedChiddy Bang - Talking to MyselfIf you ever see me talking to myselfI"m just running through the words I have to say to youIs it over, or is it too soon to tell?I"m just trying not push myself away from youI know we arguing, I know we fight a lotYou always think I"m wrong, I think I"m right a lotAnd when you see me don"t I always make your dayYou from BK, but you can"t always have it your wayShe wanna hit the city, ripping the mallI always seem to be busy, she expecting my callThe fast life could make us happiest, upsettin" us allCause all the anniversaries, forgettin" "em allBut don"t be mad, love, I know where it"s at loveShe Jolie but it"s pitiful, that"s that Brad loveWhat happens when it all goes wrong, we was nice, generosityAnd impossibly enough, it"s animosityI think I gotta just change up my game planCause she and gone fall back in love with the same manBut no matter the weather or what the rain bringIn the end I"m coming back for the same thingIf you ever see me talking to myselfI"m just running through the words I have to say to youIs it over, or is it too soon to tell?I"m just trying not push myself away from youYeah, shorty just vanished on meShe disappeared and yet I do not have no damage on meSometimes I feel she"s a burden I can"t manage on meShe say I"m cocky cause I got all of the cameras on meBut is it my fault, or is it your self-esteem?And got you feelin like you"re a prisoner to my dreamParents just don"t understand, and neither do y"allYou wanna hype me up to leave me there but I don"t blue ballAnd I say move on,used to tell you what them guys will teach you any dayAnd then you left but f*ck it I don"t need you anywayThe mentality of love gone wrong, yeahTo work it out but we just don"t get along, yeahI know it"s messed up, we all, affectedTryin" to get through, and the call, rejectedAnd that has changed, if I was ever close to your fragile frameI"d be looking for the words, playing Scrabble gamesIf you ever see me talking to myselfI"m just running through the words I have to say to youIs it over, or is it too soon to tell?I"m just trying not push myself away from youNow everybody say x2Round and round we go babyNow everybody sayIf you ever see me talking to myselfI"m just running through the words I have to say to youIs it over, or is it too soon to tell?I"m just trying not push myself away from youhttp://music.baidu.com/song/2629318

trim函数可以过滤指定的字符串：完整格式：TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str)简化格式：TRIM([remstr FROM] str)返回字符串 str ， 其中所有remstr前缀和/或后缀都已被删除。若分类符BOTH、LEADIN或TRAILING中没有一个是给定的,则假设为BOTH。remstr为可选项，在未指定情况下，可删除空格。mysql> SELECT TRIM(" bar "); -> "bar"mysql> SELECT TRIM(LEADING "x" FROM "xxxbarxxx"); --删除指定的首字符 x -> "barxxx"mysql> SELECT TRIM(BOTH "x" FROM "xxxbarxxx"); --删除指定的首尾字符 x -> "bar"mysql> SELECT TRIM(TRAILING "xyz" FROM "barxxyz"); --删除指定的尾字符 x -> "barx"mysql中的去除左空格函数:LTRIM(str);mysql> SELECT LTRIM(" barbar"); -> "barbar"mysql中的去除右空格函数：RTRIM(str):mysql> SELECT RTRIM("barbar ");-> "barbar"更多相关免费学习推荐：mysql教程(视频)

一、MySQL-Proxy基础MySQL Proxy是一个处于你的Client端和MySQL server端之间的简单程序，它可以监测、分析或改变它们的通信。它使用灵活，没有限制，常见的用途包括：负载平衡，故障、查询分析，查询过滤和修改等等。（Figure1：MySQL Proxy）MySQL-Proxy,announced in June, is a binary application that sits between your MySQL client and server, and supports the embedded scripting languageLua. The proxy can be used to analyze, monitor and transform communication, and supports a wide range of scenarios including:load balancing and fail over handling query analysis and logging SQL macros query rewriting executing shell commands One of the more powerful features of MySQL Proxy is the ability to do "Read/Write Splitting". The basic concept is to have a master database handle transactional queries while slaves handle SELECT queries. Replication is used to synchronize the changes due to transactional queries with the slaves in the cluster.MySQL-Proxy是处在你的MySQL数据库客户和服务端之间的程序，它还支持嵌入性脚本语言Lua。这个代理可以用来分析、监控和变换（transform）通信数据，它支持非常广泛的使用场景：负载平衡和故障转移处理 查询分析和日志 SQL宏（SQL macros） 查询重写（query rewriting） 执行shell命令 MySQL Proxy更强大的一项功能是实现“读写分离（Read/Write Splitting）”。基本的原理是让主数据库处理事务性查询，而从数据库处理SELECT查询。数据库复制被用来把事务性查询导致的变更同步到集群中的从数据库。二、实战过程测试环境：Ubuntu 10.04.2 LTS + MySQL5.1.41-3ubuntu12.10-log192.168.1.147proxy 代理 入口192.168.1.126master主机 只写192.168.1.145slaver从机 只读程序上只需要链接到192.168.1.147，而192.168.1.126和192.168.1.145对于程序来说是透明的，你完全不需要理会，也不需要知道192.168.1.126和192.168.1.145，你对数据库的所有操作都只对192.168.1.147进行操作。1.安装脚本lua#apt-get install lua5.1MySQL-Proxy的读写分离主要是通过rw-splitting.lua脚本实现的，因此需要安装lua。2.安装配置MySQL-Proxy#apt-getmysql-proxy当前获取到的版本是：mysql-proxy 0.8.0（查看版本命令：#mysql-proxy -V）3.修改rw-splitting.lua#vim /usr/share/mysql-proxy/rw-splitting.lua配置并使用rw-splitting.lua读写分离脚本，脚本目录是 /usr/share/mysql-proxy，修改读写分离脚本rw-splitting.lua，修改默认连接数，进行快速测试，如果不修改连接数的话要达到连接数为4时才会启用读写分离。-- connection poolif not proxy.global.config.rwsplit thenproxy.global.config.rwsplit = {min_idle_connections = 1, //默认为4max_idle_connections = 1, //默认为8is_debug = false}end这是因为mysql-proxy会检测客户端连接，当连接没有超过min_idle_connections预设值时, 不会进行读写分离, 即查询操作会发生到Master上。4.新建文件夹/var/log/mysql-proxy/和文件mysql-proxy.log#mkdir /var/log/mysql-proxy#vi mysql-proxy.log5.执行读写分离#sudo mysql-proxy --proxy-read-only-backend-addresses=192.168.1.145:3306 --proxy-backend-addresses=192.168.1.126:3306 --proxy-lua-script=/usr/share/mysql-proxy/rw-splitting.lua >/var/log/mysql-proxy/mysql-proxy.log &参数说明：192.168.1.147proxy 代理 入口192.168.1.126master主机 只写192.168.1.145slaver从机 只读当运行sudo mysql-proxy 上面语句后，查询进程没有4040的时候，需要重启mysql ( sudo /etc/init.d/mysql restart) 之后再输入proxy设置。6.查看进程端口#netstat -ant#netstat _ntl（Figure2：端口）tcp00 0.0.0.0:40400.0.0.0:*LISTENtcp00 0.0.0.0:40410.0.0.0:*LISTEN7.查看数据库链接mysql> show processlistG;（Figure3：进程）可以看到，产生了一个新连接。如果想杀掉某个链接，可以使用mysql>help kill查看kill的帮助信息，杀掉36进程的命令：mysql>kill 36;8.测试读写分离1)在mysql-proxy机子进入MySQL#mysql -u gaizai -p -P4040 -h 192.168.1.147必须指定-h参数，不然报下面错误：（Figure4：出错）2)显示数据库列表：mysql> show databases;如果你是搭建MySQL-Proxy成功的话，你上面查看到的数据库列表应该是192.168.1.145服务器上的数据库列表。（可以在145和126分别创建不同的数据库进行测试）3)进入测试数据库：mysql> use weibo;4)查询表记录：mysql>select * from blog;5)插入一条记录：mysql> INSERT INTO `blog` (`TaskID`, `Content`, `Quote`, `Author`, `Time`, `Url`, `ImageUrl`, `Transmits`, `Comments`, `Hash`, `AddOn`) VALUES("10","fefef","fefef","efef",NOW(),"http://www.cnblogs.com/zgx/archive/2011/09/13/2174823.html",NULL,"0","0","33333333",NOW());6)查询表记录：mysql>select * from blog;对比两次查询表的记录，看记录是否有变化，我们插入了数据（确认插入成功），但两次的数据是没有变化的，这就对了，这就是读写分离了（我们读的是145的数据库，插入的是126的数据库，而我们的145与126又没有设置Replication；如果之前设置了，请先停止后进行测试）注：有时候mysql_proxy(38)库里会显示出数据，重启系统系统，重新启动mysql后就没有此现象了。7)进入主写服务器(192.168.1.126) 查看数据#mysql-u gaizai -p -h 192.168.1.126mysql> use weibo;mysql>select * from blog;可以查看已经写入了一条记录。8)进入从读服务器(192.168.1.145)#mysql-u gaizai -p -h 192.168.1.145mysql> use weibo;mysql>select * from blog;因为没有数据显示，说明只能读，不能写。在使用工具SQLyog执行查询时，在Proxy服务器上会自动显示下面的信息：（Figure5：信息）9.MySQL-Proxy+Replication上面的测试只是测试了插入数据后，在没有进行Master与Slave的Replication设置的情况下，读取Master与Slave的数据是不同，如果想达到Figure1的效果，我们还需要设置Master与Slave之间的数据复制（Replication），详情请参考：Ubuntu10下MySQL搭建Master Slave三、MySQL-Proxy命令帮助命令：$mysql-proxy --help-all查看下MySQL Proxy的版本：$mysql-proxy -V编译启动脚本：$vi /etc/init.d/mysql-proxy启动命令：$ /etc/init.d/mysql-proxy start停止命令：$ /etc/init.d/mysql-proxy stop重启命令：$ /etc/init.d/mysql-proxy restart四、注意事项1.在启动mysql-proxy的时候，可以把启动命令保存为文件：建议使用配置文件的形式启动,注意配置文件必须是660权限,否则无法启动.如果有多个Slave的话,proxy-read-only-backend-addresses参数可以配置多个以逗号分隔的IP:Port从库列表。杀掉mysql-proxy进程：#killallmysql-proxy新建一个文件：#vi/etc/mysql-proxy.cnf在文件中输入两个分隔符中间的内容：------------------------------------------------------[mysql-proxy]admin-username=viajarchenadmin-password=123123admin-lua-script=/usr/share/mysql-proxy//admin-sql.luaproxy-backend-addresses=192.168.1.126:3306proxy-read-only-backend-addresses=192.168.1.145:3306proxy-lua-script=/usr/share/mysql-proxy/rw-splitting.lualog-file=/var/tmp/mysql-proxy.loglog-level=debugdaemon=truekeepalive=truemax-open-files=1024------------------------------------------------------设置权限：#chmod660/etc/mysql-proxy.cnf或者#chmod +x /etc/init.d/mysql-proxy设置启动文件：#mysql-proxy--defaults-file=/etc/mysql-proxy.cnf查看信息：#ps-ef|grepmysql-proxy|grep-vgreproot18691018:16?00:00:00/usr/local/mysql-proxy/libexec/mysql-proxy--defaults-file=/etc/mysql-proxy.cnfroot18701869018:16?00:00:00/usr/local/mysql-proxy/libexec/mysql-proxy--defaults-file=/etc/mysql-proxy.cnf查看日志：#tail-50f/var/tmp/mysql-proxy.log2.mysql-proxy参数--admin-address=host:port指定一个mysqo-proxy的管理端口,缺省是4041;-P,--proxy-address=<host:port>是mysql-proxy服务器端的监听端口,缺省是4040;-r,--proxy-read-only-backend-addresses=<host:port>只读Slave的地址和端口,缺省为不设置;-b,--proxy-backend-addresses=<host:port>远程Master地址和端口,可设置多个做failover和loadbalance,缺省是127.0.0.1:3306;--defaults-file=<file>配置文件,可以把mysql-proxy的参数信息置入一个配置文件里;--daemonmysql-proxy以守护进程方式运行--keepalivetrytorestarttheproxyifitcrashed,保持连接启动进程会有2个,一号进程用来监视二号进程,如果二号进程死掉自动重启proxy。_log-level=debug定义log日志级别，由高到低分别有(error|warning|info|message|debug)--proxy-lua-script=file指定一个Lua脚本程序来控制mysql-proxy的运行和设置，这个脚本在每次新建连接和脚本发生修改的的时候将重新调用。--max-open-files：指定最大档案开启数为1024，否则会有【could not raise RLIMIT_NOFILE to 8192, Invalid argument (22). Current limit still 1024.】的log讯息出现。3.当MySQL主从复制在 show slave statusG 时出现Slave_IO_Running或Slave_SQL_Running 的值不为YES时，，需要首先通过 stop slave 来停止从服务器，然后再进行测试读写分离。4.MySQL-Proxy的rw-splitting.lua脚本在网上有很多版本，但是最准确无误的版本仍然是源码包中所附带的lib/rw-splitting.lua脚本，如果有lua脚本编程基础的话，可以在这个脚本的基础上再进行优化；5.MySQL-Proxy实际上非常不稳定，在高并发或有错误连接的情况下，进程很容易自动关闭，因此打开_keepalive参数让进程自动恢复是个比较好的办法，但还是不能从根本上解决问题，因此通常最稳妥的做法是在每个从服务器上安装一个MySQL-Proxy供自身使用，虽然比较低效但却能保证稳定性；6.一主多从的架构并不是最好的架构，通常比较优的做法是通过程序代码和中间件等方面，来规划，比如单双server-id号分开写入等方式来实现两个或多个主服务器；7.MySQL-Cluster 的稳定性也不是太好；8.Amoeba for MySQL 是一款优秀的中间件软件，同样可以实现读写分离，负载均衡等功能，并且稳定性要大大超过MySQL-Proxy，建议大家用来替代MySQL-Proxy，甚至MySQL-Cluster。9.mysql proxy不支持old_password。另外也可以通过查看密码长度的方式来判断:select length(password) from mysql.user如果长度为16位则是old_password无疑。10. 安装了mysql-proxy实现读写分离，有master x 1, slave x 2。为了测试failover，停掉了一个slave，然后mysql-proxy会一直报错，提示无法连接。这个情况比单点的mysql还糟糕，挂掉一个就全挂掉！mysql的工程师给提供了一段代码，替换掉：src/network-mysqld-proxy.c的NETWORK_MYSQLD_PLUGIN_PROTO函数可以解决这个问题。network-mysqld-proxy-function.c文件。（经过测试：我停止掉slave数据库，proxy的查询就会转移到master上，当把slave启动后，proxy依然在读master，当有新的链接进来的时候才会去读取slave的数据）11. 如果在mysql-proxy的机器上也安装了mysql的话，新手就会在这个时候混乱了，到底要如何进行测试和链接呢？比如使用命令：#mysql -u gaizai -p -P4040 -h 192.168.1.147是表示登陆本机的4040端口，使用gaizai帐号，这个帐号可以不是本地mysql的帐号，这样就比较容易区分了。12. 在上述环境中，mysql-proxy、mysql-master、mysql-slave三台服务器均存在单点故障。为了避免mysql-proxy单点隐患有两种方法：一种方法是mysql-proxy配合keepalived做双机，另一种方法是将mysql-proxy和应用服务安装到同一台服务器上；为了避免mysql-master单点故障可以使用DRBD+heartbear做双机；为了避免mysql-slave单点故障可以添加多台mysql-slave，mysql-proxy会自动屏蔽后端发生故障的mysql-slave。13. 用sysbench (或者super-smack）测试mysql性能：#sysbench --test=oltp --mysql-table-engine=innodb --oltp-table-size=1000 --mysql-socket=/tmp/mysql.sock --mysql-password=123456 --mysql-user=gaizai --mysql-host=192.168.1.126 --mysql-db=weibo --num-threads=15 prepare#sysbench --test=oltp --mysql-table-engine=innodb --oltp-table-size=1000 --mysql-socket=/tmp/mysql.sock --mysql-password=123456 --mysql-user=gaizai --mysql-host=192.168.1.126 --mysql-db=weibo --oltp-test-mode=complex run14. 关于mysql-proxy的启动和关闭的shell脚本的编写：15. 读写分离不能回避的问题之一就是延迟，可以考虑Google提供的SemiSyncReplicationDesign补丁。16. MySQL-Proxy缺省使用的是4040端口，如果你想透明的把3306端口的请求转发给4040的话，那么可以：iptables -t nat -I PREROUTING -s ! 127.0.0.1 -p tcp --dport 3306 -j REDIRECT --to-ports 4040如果想删除这条规则，可以把上面例子中的-I换成-D。参考链接17. 当使用bigint 时，mysql_insert_id()存在问题，详情见手册，不过对于大多数人而言，bigint基本不会遇到，所以你可以无视这个问题）注：对于这两个问题，官方BUG库里有人给出了相应的补丁。五、错误在执行命令的时候出现了下面的错误：（Figure6：错误信息）could not raise RLIMIT_NOFILE to 8192这个一个警告级别的错误,意思是MySQL Proxy在你的系统上不能把open files limit提升到8192，不过没关系的，MySQL Proxy依然好好的运行在你的电脑上。可以通过设置启动--max-open-files参数解决。MySQL Proxy安装和使用(一)mysql proxy master and slave test加入--max-open-files=8192后报下面的错误：（Figure7：错误信息）六、疑问与解答1.当slave宕机后，mysql-proxy是如何读取的？（经过测试：我停止掉slave数据库，proxy的查询就会转移到master上，当把slave启动后，proxy依然在读master，当有新的链接进来的时候才会重新去读取slave的数据。有时可能需要重启下mysql-proxy）2.如何知道mysql-proxy当前执行的select是在哪台机器上执行的？3.当slave宕机一段时间后，如果再次同步master的缺失的数据？4.当配置中设置了proxy-read-only-backend-addresses=192.168.1.145:3306,192.168.1.147:3306类似这样的两个slave，如果两个slave的数据不同步，那么是怎么读取数据的

Ubuntu bitsCN.com一、MySQL-Proxy基础MySQL Proxy是一个处于你的Client端和MySQL server端之间的简单程序，它可以监测、分析或改变它们的通信。它使用灵活，没有限制，常见的用途包括：负载平衡，故障、查询分析，查询过滤和修改等等。（Figure1：MySQL Proxy）MySQL-Proxy, announced in June, is a binary application that sits between your MySQL client and server, and supports the embedded scripting language Lua. The proxy can be used to analyze, monitor and transform communication, and supports a wide range of scenarios including:load balancing and fail over handling query analysis and logging SQL macros query rewriting executing shell commands One of the more powerful features of MySQL Proxy is the ability to do "Read/Write Splitting". The basic concept is to have a master database handle transactional queries while slaves handle SELECT queries. Replication is used to synchronize the changes due to transactional queries with the slaves in the cluster. MySQL-Proxy是处在你的MySQL数据库客户和服务端之间的程序，它还支持嵌入性脚本语言Lua。这个代理可以用来分析、监控和变换（transform）通信数据，它支持非常广泛的使用场景：负载平衡和故障转移处理 查询分析和日志 SQL宏（SQL macros） 查询重写（query rewriting） 执行shell命令 MySQL Proxy更强大的一项功能是实现“读写分离（Read/Write Splitting）”。基本的原理是让主数据库处理事务性查询，而从数据库处理SELECT查询。数据库复制被用来把事务性查询导致的变更同步到集群中的从数据库。 二、实战过程测试环境：Ubuntu 10.04.2 LTS + MySQL5.1.41-3ubuntu12.10-log192.168.1.147 proxy 代理 入口192.168.1.126 master 主机 只写192.168.1.145 slaver 从机 只读程序上只需要链接到192.168.1.147，而192.168.1.126和192.168.1.145对于程序来说是透明的，你完全不需要理会，也不需要知道192.168.1.126和192.168.1.145，你对数据库的所有操作都只对192.168.1.147进行操作。1.安装脚本lua#apt-get install lua5.1MySQL-Proxy的读写分离主要是通过rw-splitting.lua脚本实现的，因此需要安装lua。2.安装配置MySQL-Proxy#apt-get mysql-proxy当前获取到的版本是：mysql-proxy 0.8.0（查看版本命令：#mysql-proxy -V）3.修改rw-splitting.lua #vim /usr/share/mysql-proxy/rw-splitting.lua配置并使用rw-splitting.lua读写分离脚本，脚本目录是 /usr/share/mysql-proxy，修改读写分离脚本rw-splitting.lua，修改默认连接数，进行快速测试，如果不修改连接数的话要达到连接数为4时才会启用读写分离。-- connection poolif not proxy.global.config.rwsplit thenproxy.global.config.rwsplit = {min_idle_connections = 1, //默认为4max_idle_connections = 1, //默认为8is_debug = false}end这是因为mysql-proxy会检测客户端连接，当连接没有超过min_idle_connections预设值时, 不会进行读写分离, 即查询操作会发生到Master上。4.新建文件夹/var/log/mysql-proxy/和文件mysql-proxy.log #mkdir /var/log/mysql-proxy #vi mysql-proxy.log5.执行读写分离#sudo mysql-proxy --proxy-read-only-backend-addresses=192.168.1.145:3306 --proxy-backend-addresses=192.168.1.126:3306 --proxy-lua-script=/usr/share/mysql-proxy/rw-splitting.lua >/var/log/mysql-proxy/mysql-proxy.log &参数说明：192.168.1.147 proxy 代理 入口192.168.1.126 master 主机 只写192.168.1.145 slaver 从机 只读 当运行sudo mysql-proxy 上面语句后，查询进程没有4040的时候，需要重启mysql ( sudo /etc/init.d/mysql restart) 之后再输入proxy设置。6.查看进程端口#netstat -ant#netstat

所有的努力都是vain.how可以拯救我自己。

mysql5.5 部署在ubuntu上面, mysql 像着魔一样, 每次不到10天就有人报告说网站访问不了. 没去去看,就是mysql停止了. 查看日志: 都是这种, 这是最近的, 说因为内存用完. Aug 3 00:26:19 AY130303163110291612 kernel: [8986665.345763] Out of memory: Kill p mysql5.5 部署在ubuntu上面, mysql 像着魔一样, 每次不到10天就有人报告说网站访问不了. 没去去看,就是mysql停止了. 查看日志: 都是这种, 这是最近的, 说因为内存用完. Aug 3 00:26:19 AY130303163110291612 kernel: [8986665.345763] Out of memory: Kill process 10356 (mysqld) score 173 or sacrifice child512的内存, 难道一下子就用完了? 每次去top命令看一下. 还剩下啊. Mem: 501892k total, 319980k used, 181912k free, 17640k buffers但是没隔几天又挂掉了.今天在v2ex上面看到一哥们跟我的一样. 而且他还发现另外两个人也有这种问题. http://www.v2ex.com/t/78160#reply18 不知道大家部署遇到这种问题么/ 原文地址：为什么部署在阿里云上 MySQL 老是因为内存而挂掉,不是个例., 感谢原作者分享。

union 重复数据只显示一次Union All 重复数据全部显示

my读音： [maɪ]。释义：adj. 我的（I的所有格形式）。int. 啊呀； 天啊。style，发音：[英][stail][美][staɪl]，中文释义为：文体；风格；式样；时尚；类型。通常被口语化为范（儿），比如《江南style》就常被译为《江南范》。现在生活中指风格品位还有合胃口的意思，比如，你不是我的STYLE；用于时装的风格流派，如巴洛克风格、米兰风格、古典风格等，与用于其他艺术时相同。style的衍生词stylist，是指"创造风格的人"，可以是时装设计师，可以是化妆师或美发师，也可以是时装表演时负责发式、化妆、服饰整体效果的专家，现在多译为形象设计师。

灯塔飞向太空之后会降落在一个神秘的地方，这个地方充满了各种神秘的现象，尤其是这里的蘑菇看起来非常的鲜艳，还有多种颜色，有些地方就会用到蘑菇斑点的颜色来破解。攻略上1．向下走，打开书桌抽屉。2．点击抽屉查看提示。3．向下走，点击墙上的挂画，露出保险箱。4．根据提示解锁保险箱。5．拿到保险箱里的信和软盘。6．回到顶层，将软盘插入灯下的插槽。7．坠落月球，点击绿蘑菇，看到斑点是黄色的。8．往右走，拿到树上的绳子，点击红蘑菇，看到斑点是蓝色的。9．走到最左山崖边，点击紫蘑菇，看到斑点是绿色的。10．将绳子系在左边断掉的梯子上。1011．下去，看到山崖上有机关。将蘑菇斑点颜色与外圈颜色匹配，调整圈内蘑菇图案颜色，解锁获得矿井钥匙。12．上去，一直往右走到有矿井和紫色飞虫的场景，对矿井旁的钥匙孔使用矿井钥匙。13．下去，捡起玻璃瓶。14．上来，往左来到有黄金楼梯的场景，在左侧的环形山放出奇怪气体时，对气体使用玻璃瓶。15．回到矿井口，对紫色飞虫使用气体。16．向右，向上，拿到镐子。17．进入矿井，对岩壁上的蓝色宝石使用镐子，获得蓝色宝石。18．来到有黄金楼梯的场景，向上将蓝色宝石安装在石头人的眼睛上，获得金属盘。19．回到拿镐子的地方，将金属盘装在传送器的门上。20．进入，点击右边的星球，传送至土星。2021．出来，往左，捡起帐篷前的眼镜。22．进入帐篷，获得信和砍刀。23．通过传送器返回月球。24．出来，向下，用砍刀砍下夹夹草。25．向左来到红色的树前，对树上的爆炸果使用夹夹草，获得爆炸果。攻略·上攻略·下