sql

SQL Server有免费版。SQL Server Express 是免费的，可以再分发（受制于协议），还可以充当客户端数据库以及基本服务器数据库。SQL Server Express 是独立软件供应商 ISV、服务器用户、非专业开发人员、Web 应用程序开发人员、网站主机和创建客户端应用程序的编程爱好者的理想选择。扩展资料：SQL Server 2005 Express仅适用于 32 位，数据库平台基于 SQL Server 2005。它也可以替换 Microsoft Desktop Engine (MSDE)。通过与 Microsoft Visual Studio 2005 集成，SQL Server Express 简化了功能丰富、存储安全且部署快速的数据驱动应用程序的开发过程。如果需要使用更高级的数据库功能，则可以将 SQL Server Express 无缝升级到更复杂的 SQL Server 版本。

sql server 是Microsoft公司推出的关系型数据库管理系统。具有使用方便可伸缩性好与相关软件集成程度高等优点。 sql serveru2002优点有哪些u2002 易用性、适合分布式组织的可伸缩性、用于决策支持的数据仓库功能、与许多其他服务器软件紧密关联的集成性、良好的性价比等;u2002 为数据管理与分析带来了灵活性，允许单位在快速变化的环境中从容响应，从而获得竞争优势。从数据管理和分析角度看，将原始数据转化为商业智能和充分利用Web带来的机会非常重要。 作为一个完备的数据库和数据分析包，sql server为快速开发新一代企业级商业应用程序、为企业赢得核心竞争优势打开了胜利之门。作为重要的基准测试可伸缩性和速度奖的记录保持者，sql server是一个具备完全Web支持的数据库产品，提供了对可扩展标记语言u2002(XML)的核心支持以及在Internet上和防火墙外进行查询的能力。 sql server缺点有哪些u2002 开放性：sql serveru2002只能windows上运行没有丝毫开放性操作系统系统稳定对数据库十分重要Windows9X系列产品偏重于桌面应用NTu2002server只适合小型企业而且windows平台靠性安全性和伸缩性非常有限象unix样久经考验尤其处理大数据库;u2002 伸缩性并行性：sql serveru2002并行实施和共存模型并成熟难处理日益增多用户数和数据卷伸缩性有限;u2002 安全性：没有获得任何安全证书。u2002性能：sql serveru2002多用户时性能佳;u2002 客户端支持及应用模式：客户端支持及应用模式。只支持C/S模式，sql serveru2002C/S结构只支持windows客户用ADO、DAO、OLEDB、ODBC连接;u2002 使用风险：sql serveru2002完全重写代码经历了长期测试断延迟许多功能需要时间来证明并十分兼容。

管理SQL Server服务和数据库的，如果是在数据库服务器的本机，建议不要删除。如果是客户机，你有不是数据库管理员，哪就可以删除。方法：执行sqlserver的安装程序，会提示安装、修复、删除等选项，选择安装，进入后选择自定义模式，在自定义窗口中可以将管理组件类、以及帮助等（凡是你不需要的）都不选择（不能删除客户端，我想你至少要使用sqlserver的驱动访问数据库吧！），下一步就可以了。SQL Server 服务管理器用于启动、停止和暂停服务器上的 Microsoft SQL Serveru2122 2000 组件。这些组件在 Microsoft Windows NT 或 Microsoft Windows 2000 上作为服务运行，并可在 Microsoft Windows 95 和 Microsoft Windows 98 上作为单独的可执行程序运行：◆SQL Server服务实现 SQL Server 数据库引擎。在计算机上运行的每个 SQL Server 实例，电脑系统都有一个 SQL Server 服务。◆SQL Server 代理服务实现运行调度的 SQL Server 管理任务的代理程序。在计算机上运行的每个 SQL Server 实例都有一个 SQL Server 代理服务。◆Microsoft 搜索服务(仅用于 Windows NT 和 Windows 2000)实现全文本检索引擎。不论计算机上有多少个 SQL Server 实例，真正运行的都只有一个服务。◆MSDTC 服务(仅用于 Windows NT 和 Windows 2000)管理分布式事务。计算机上创建了多个SQL Server 实例，都只有一个服务。◆MSSQLServerOlAPService 服务(仅用于 Windows NT 和 Windows 2000)实现 SQL Server 2000 Analysis Services。不论计算机上有多少个 SQL Server 实例，都只有一个服务。SQL Server 服务管理器SQL Server 服务管理器是一个任务栏应用程序，它遵从任务栏应用程序的标准行为。当 SQL Server 服务管理器图标最小化时，将显示在任务栏右边的任务栏时钟区域。若要获得包含 SQL Server 服务管理器所支持的所有任务的菜单，请右击任务栏项。

SQL Server 是Microsoft 公司推出的关系型数据库管理系统。具有使用方便可伸缩性好与相关软件集成程度高等优点。可跨越从运行Microsoft Windows 98 的膝上型电脑到运行Microsoft Windows 2012 的大型多处理器的服务器等多种平台使用。SQL Server数据库的作用：可以面向数据库执行查询、存储和检索数据、可以通过SQL语句 从数据库写入或者是取回数据、可以更新数据库中的数据。SQL语句可以用来执行各种各样的操作，例如更新数据库中的数据，从数据库中提取数据等。目前，绝大多数流行的关系型数据库管理系统，如Oracle,Sybase,Microsoft SQL Server,Access等都采用了SQL语言标准。扩展资料：主要特性1、高性能设计，可充分利用WindowsNT的优势。2、系统管理先进，支持Windows图形化管理工具，支持本地和远程的系统管理和配置。3、强壮的事务处理功能，采用各种方法保证数据的完整性。4、支持对称多处理器结构、存储过程、ODBC，并具有自主的SQL语言。 SQLServer以其内置的数据复制功能、强大的管理工具、与Internet的紧密集成和开放的系统结构为广大的用户、开发人员和系统集成商提供了一个出众的数据库平台。参考资料来源：百度百科--SQLserver数据库

SQL Server是一款关系型数据库管理系统（RDBMS），由微软公司（Microsoft）开发。它用于存储、检索、管理和分析数据。SQL Server提供了多种工具和功能，支持事务处理、数据仓库、报表和分析等应用。作为一款企业级数据库管理系统，SQL Server被广泛应用于各种规模的业务系统和应用程序中。SQL Server的读音为：“S-Q-L Server”。其中，“SQL”是“Structured Query Language”的缩写，读作“S-Q-L”或“sequel”。而“Server”保持其常规发音。所以，整个术语可以读作：“S-Q-L Server”或“sequel Server”。

SQL Server是由Microsoft开发和销售的关系数据库管理系统或RDBMS。下面是我整理的详细内容，希望对大家有所帮助！ sql server是什么 SQL是英文Structured Query Language的缩写，意思为结构化查询语言。SQL语言的主要功能就是同各种数据库建立联系，进行沟通。按照ANSI(美国国家标准协会)的规定，SQL被作为关系型数据库管理系统的标准语言。SQL Server是由Microsoft开发和推广的关系数据库管理系统（RDBMS）。 SQL Server最初是由Microsoft、Sybase和Ashton-Tate三家公司共同开发的，并于1988年推出了第一个OS/2版本。Microsoft SQL Server近年来不断更新版本，1996年，Microsoft推出了SQL Server6.5版本；1998年，SQL Server 7.0版本和用户见面；SQL Server 2000是Microsoft公司于2000年推出，目前最新版本是2017年份推出的SQL SERVER 2017。 sql server特点 1．真正的客户机/服务器体系结构。 2．图形化用户界面，使系统管理和数据库管理更加直观、简单。 3．丰富的编程接口工具，为用户进行程序设计提供了更大的选择余地。 4．SQL Server与Windows NT完全集成，利用了NT的许多功能，如发送和接受消息，管理登录安全性等。SQL Server也可以很好地与Microsoft BackOffice产品集成。 5．具有很好的伸缩性，可跨越从运行Windows 95/98的小型电脑到运行Windows 2000的大型多处理器等多种平台使用。 6．对Web技术的支持，使用户能够很容易地将数据库中的数据发布到Web页面上。 7．SQL Server提供数据仓库功能，这个功能只在Oracle和其他更昂贵的DBMS中才有。 SQL Server 2000与以前版本相比较，又具有以下新特性 ： 1．支持XML(Extensive Markup Language，扩展标记语言) 2．强大的基于Web的分析 3．支持OLE DB和多种查询 4．支持分布式的分区视图

这样写就没问题了：select distinct ptcn (select a.ptcn as ptcname from ProductTypeC a, BrandDisplay b where a.ptcid=b.ptcid and b.bdFirstHead>0 order by b.bdFirstHead desc) c;

SELECT查询语句的语法：SELECT[DISTINCT](column[{,column}])|*FROMtable[{,table}][ORDERBYcolumn[ASC]|[DESC[{,column[ASC]|[DESC}]]WHEREpredicate[{logical-connectorpredicate}];其中DISTINCT用于消除重复行，ORDERBY用于显示行的排序（ASC为升序，DESC为降序）UPDATE更新语句语法：UPDATEtableSETcolumn=value[{,column=value}][WHEREpredicate[{logical-connectorpredicate}]];DELETE删除语句语法：DELETEFROMtable[WHEREpredicate[{logical-connectorpredicate}]];INSERT插入语句语法：INSERTINTOtable[(column{,column})]VALUES(columnvalue[{,columnvalue}]);

path = @"D:/test.txt";//读取文件txtusing (FileStream fs = new FileStream(path, FileMode.Open)){using (StreamReader sr = new StreamReader(fs)){while (!sr.EndOfStream){string sLine = sr.ReadLine();if (sLine.Length < 1){continue;}string[] sRecordKbn = sLine.split(" ");//过滤空格forach(string s in sRecordKbn ){//s是取出的数据，可以插入数据库}}

这里只介绍动态SQL的使用。关于动态SQL语句的语法，参见：http://blog.csdn.NET/chiclewu/article/details/160971331.什么是时候需要使用动态SQL？SQL文本在编译时是未知的。例如，SELECT语句包含的标识符(如表名)在编译时是未知的，或者WHERE子句的条件数量在编译时是未知。静态SQL不支持例如，在PL/SQL中用静态SQL只能执行查询以及DML语句。如果想要执行DDL语句，只能使用动态SQL。当让使用静态SQL，也有它的好处：编译成功验证了静态SQL语句引用有效的数据库对象和访问这些对象的权限编译成功创建了模式对象的依赖关系2.EXECUTE IMMEDIATE语句EXECUTE IMMEDIATE语句的意思是使用本地动态SQL处理大多数动态SQL语句。如果动态SQL语句是自包含的（也就是说，它的绑定参数没有占位符，并且结果不可能返回错误），则EXECUTE IMMEDIATE语句不需要子句。如果动态SQL语句包行占位符绑定参数，每个占位符在EXECUTE IMMEDIATE语句的子句中必须有一个相应的绑定参数，具体如下：如果动态SQL语句是一个最多只能返回一行的SELECT语句，OUT绑定参数放置在INTO子句，IN绑定参数放置在USING子句。如果动态SQL语句是一个可以返回多行的SELECT语句，OUT绑定参数放置在BULK COLLECT INTO子句，IN绑定参数放置在USING子句。如果动态SQL语句是一个除了SELECT以外的其他DML语句，且没有RETURNING INTO子句，所有的绑定参数放置在USING子句中。如果动态SQL还语句一个匿名PL/SQL块或CALL语句，把所有的绑定参数放置在USING子句中。如果动态SQL语句调用一个子程序，请确保：每个对应子程序参数占位符的绑定参数与子程序参数具有相同的参数模式和兼容的数据类型。绑定参数不要有SQL不支持的数据类型（例如，布尔类型,关联数组，以及用户自定的记录类型） USING子句不能包含NULL字面量。如果想要在USING子句中使用NULL值，可以使用位初始化的变量或者函数显示将NULL转换成一个有类型的值。 2.1动态SQL语句是一个最多只能返回一行的SELECT语句使用动态SQL语句返回单列，查询SCOTT的薪水：declare v_sql_text varchar2(1000); v_sal number; v_ename emp.ename%type := "SCOTT"; begin v_sql_text := "select e.sal from emp e where e.ename = :ename"; execute immediate v_sql_text into v_sal using v_ename; dbms_output.put_line(v_ename || ":" || v_sal);end; 使用动态SQL返回一条记录，查询SCOTT的基本信息：declare v_sql_text varchar2(1000); v_ename emp.ename%type := "SCOTT"; vrt_emp emp%rowtype; begin v_sql_text := "select * from emp e where e.ename = :ename"; execute immediate v_sql_text into vrt_emp using v_ename; dbms_output.put_line(v_ename || "的基本信息:"); dbms_output.put_line("工号:" || vrt_emp.empno); dbms_output.put_line("工资:" || vrt_emp.sal); dbms_output.put_line("入职日期:" || vrt_emp.hiredate);end; 2.2动态SQL语句是一个可以返回多行的SELECT语句2.2.1只有一个占位符使用动态SQL语句返回多行记录，查询30部门的员工基本信息：declare v_sql_text varchar2(1000); v_deptno emp.deptno%type := 30; type nt_emp is table of emp%rowtype; vnt_emp nt_emp; begin v_sql_text := "select * from emp e where e.deptno = :deptno"; execute immediate v_sql_text bulk collect into vnt_emp using v_deptno; for i in 1 .. vnt_emp.count loop dbms_output.put_line(vnt_emp(i).ename || "的基本信息:"); dbms_output.put_line("工号:" || vnt_emp(i).empno); dbms_output.put_line("工资:" || vnt_emp(i).sal); dbms_output.put_line("入职日期:" || vnt_emp(i).hiredate); dbms_output.put_line(""); end loop;end 2.2.2多个占位符查询20部门工资大于2000的员工基本信息：declare v_sql_text varchar2(1000); v_deptno emp.deptno%type := 20; v_sal number := 2000; type nt_emp is table of emp%rowtype; vnt_emp nt_emp; begin v_sql_text := "select * from emp e where e.sal>:sal and e.deptno = :deptno"; execute immediate v_sql_text bulk collect into vnt_emp using v_sal, v_deptno; --注意绑定多个变量时，绑定变量只与占位符位置有关，与占位符名称无关， for i in 1 .. vnt_emp.count loop dbms_output.put_line(vnt_emp(i).ename || "的基本信息:"); dbms_output.put_line("工号:" || vnt_emp(i).empno); dbms_output.put_line("工资:" || vnt_emp(i).sal); dbms_output.put_line("入职日期:" || vnt_emp(i).hiredate); dbms_output.put_line(""); end loop;注意：对于SQL文本，占位符名称是没有意义的，绑定变量与占位符名称无关，只与占位符的配置有关。即使有多个相同名称占位符，也需要每个占位符对应一个绑定变量。对于PL/SQL块，占位符名称是有意义的，相同名称的占位符，只需要第一个占位符绑定变量。 2.3动态SQL语句是一个带有RETURNING子句的DML语句KING的工资增长20%，返回增长后的工资：eclare v_sql_text varchar2(1000); v_sal number; v_ename emp.ename%type := "KING"; begin v_sql_text := "update emp e set e.sal= e.sal*1.2 where e.ename = :ename returning e.sal into :sal"; execute immediate v_sql_text using v_ename returning into v_sal; dbms_output.put_line(v_ename || ":" || v_sal);end; 注意：只有当v_sql_text语句有returning into子句时,动态SQL语句才能使用returning into子句。 2.4给占位符传递NULL值2.4.1通过未初始化变量传递NULL值declare v_sql_text varchar2(1000); v_deptno emp.ename%type := "ALLEN"; v_comm emp.comm%type;begin v_sql_text := "update emp e set e.comm = :comm where e.ename =:ename"; execute immediate v_sql_text using v_comm, v_deptno; end;2.4.2通过函数将NULL值显式的转换成一个有类型的值declare v_sql_text varchar2(1000); v_deptno emp.ename%type := "ALLEN"; begin v_sql_text := "update emp e set e.comm = :comm where e.ename =:ename"; execute immediate v_sql_text using to_number(null), v_deptno; end; 3.OPEN FOR语句PL/SQL引入OPEN FOR语句实际上并不是为了支持本地动态SQL，而是为了支持游标变量。现在它以一种极其优雅的方式实现了多行的动态查询。使用OPEN FOR语句来关联动态SQL语句的游标变量，在OPEN FOR语句的USING子句中，指定动态SQL语句每个占位符的绑定参数。使用FETCH语句获取运行时结果集。使用CLOSE语句关闭游标变量使用OPEN FOR语句查询出10部门的员工的基本信息：declare type rc_emp is ref cursor; vrc_emp rc_emp; v_sql_text varchar2(1000); v_deptno emp.deptno%type := 10; vrt_emp emp%rowtype;begin v_sql_text := "select * from emp e where e.deptno=:deptno"; open vrc_emp for v_sql_text using v_deptno; loop exit when vrc_emp%notfound; fetch vrc_emp into vrt_emp; dbms_output.put_line(vrt_emp.ename || "的基本信息:"); dbms_output.put_line("工号:" || vrt_emp.empno); dbms_output.put_line("工资:" || vrt_emp.sal); dbms_output.put_line("入职日期:" || vrt_emp.hiredate); dbms_output.put_line(""); end loop; close vrc_emp;end; 4.重复的占位符名称如果在动态SQL语句重复占位符名称，要知道占位符关联绑定参数的方式依赖于动态语句的类型。如果执行的是一个动态SQL字符串，则必须为每一个占位符提供一个绑定参数，即使这些占位符是重复的。如果执行的是一个动态PL/SQL块，则必须为每一个唯一占位符提供一个绑定参数，即重复的占位符只需要提供一个绑定参数。4.1重复占位符的动态SQL字符串declare v_sql_text varchar2(1000); v_sal emp.sal%type := 4000; v_comm emp.comm%type; v_ename emp.ename%type := "SCOTT"; begin v_sql_text := "update emp e set e.sal=:sal , e.comm = :sal*0.1 where e.ename =:ename returning e.comm into :comm "; execute immediate v_sql_text using v_sal, v_sal, in v_ename returning into v_comm; dbms_output.put_line(v_ename || "分红:" || v_comm);end;4.2重复占位符的动态PL/SQL块declare v_sql_text varchar2(1000); v_sal number; v_ename emp.ename%type := "KING"; begin v_sql_text := " begin select e.sal,e.ename into :sal,:ename from emp e where e.ename =:ename; end;"; execute immediate v_sql_text using out v_sal, in out v_ename; dbms_output.put_line(v_ename || ":" || v_sal);end;

select 其他列,case Tolerance when 0 then "百分比" else "数值" end as 误差类型,case when CanDown="True" and Canup then "±" "+" when CanDown="True" then "-" when Canup="True" then "+" end as 浮动情况from 表 ------------关于CanDown和Canup如果其中一个为"True"另一个必为"False"的情况:case Canup+CanDown when "TrueTrue" then "±" when "TrueFalse" then "+" else "-" end as 浮动情况

你telnet一下1433端口，看看通吗？可能是防火墙阻止了

前言: MYSQL 应该是最流行了 WEB 后端数据库。虽然 NOSQL 最近越来越多的被提到，但是相信大部分架构师还是会选择 MYSQL 来做数据存储。本文作者总结梳理MySQL性能调优的15个重要变量，又不足需要补充的还望大佬指出。 1.DEFAULT_STORAGE_ENGINE 如果你已经在用MySQL 5.6或者5.7，并且你的数据表都是InnoDB，那么表示你已经设置好了。如果没有，确保把你的表转换为InnoDB并且设置default_storage_engine为InnoDB。 为什么？简而言之，因为InnoDB是MySQL(包括Percona Server和MariaDB)最好的存储引擎 – 它支持事务，高并发，有着非常好的性能表现(当配置正确时)。这里有详细的版本介绍为什么 2.INNODB_BUFFER_POOL_SIZE 这个是InnoDB最重要变量。实际上，如果你的主要存储引擎是InnoDB，那么对于你，这个变量对于MySQL是最重要的。 基本上，innodb_buffer_pool_size指定了MySQL应该分配给InnoDB缓冲池多少内存，InnoDB缓冲池用来存储缓存的数据，二级索引，脏数据(已经被更改但没有刷新到硬盘的数据)以及各种内部结构如自适应哈希索引。 根据经验，在一个独立的MySQL服务器应该分配给MySQL整个机器总内存的80%。如果你的MySQL运行在一个共享服务器，或者你想知道InnoDB缓冲池大小是否正确设置，详细请看这里。 3.INNODB_LOG_FILE_SIZE InnoDB重做日志文件的设置在MySQL社区也叫做事务日志。直到MySQL 5.6.8事务日志默认值innodb_log_file_size=5M是唯一最大的InnoDB性能杀手。从MySQL 5.6.8开始，默认值提升到48M,但对于许多稍繁忙的系统，还远远要低。 根据经验，你应该设置的日志大小能在你服务器繁忙时能存储1-2小时的写入量。如果不想这么麻烦，那么设置1-2G的大小会让你的性能有一个不错的表现。这个变量也相当重要，更详细的介绍请看这里。 当然，如果你有大量的大事务更改，那么，更改比默认innodb日志缓冲大小更大的值会对你的性能有一定的提高，但是你使用的是autocommit，或者你的事务更改小于几k，那还是保持默认的值吧。 4.INNODB_FLUSH_LOG_AT_TRX_COMMIT 默认下，innodb_flush_log_at_trx_commit设置为1表示InnoDB在每次事务提交后立即刷新同步数据到硬盘。如果你使用autocommit，那么你的每一个INSERT, UPDATE或DELETE语句都是一个事务提交。 同步是一个昂贵的操作(特别是当你没有写回缓存时)，因为它涉及对硬盘的实际同步物理写入。所以如果可能，并不建议使用默认值。 两个可选的值是0和2: * 0表示刷新到硬盘，但不同步(提交事务时没有实际的IO操作) * 2表示不刷新和不同步(也没有实际的IO操作) 所以你如果设置它为0或2，则同步操作每秒执行一次。所以明显的缺点是你可能会丢失上一秒的提交数据。具体来说，你的事务已经提交了，但服务器马上断电了，那么你的提交相当于没有发生过。 显示的，对于金融机构，如银行，这是无法忍受的。不过对于大多数网站，可以设置为innodb_flush_log_at_trx_commit=0|2，即使服务器最终崩溃也没有什么大问题。毕竟，仅仅在几年前有许多网站还是用MyISAM，当崩溃时会丢失30s的数据(更不要提那令人抓狂的慢修复进程)。 那么，0和2之间的实际区别是什么？性能明显的差异是可以忽略不计，因为刷新到操作系统缓存的操作是非常快的。所以很明显应该设置为0，万一MySQL崩溃(不是整个机器)，你不会丢失任何数据，因为数据已经在OS缓存，最终还是会同步到硬盘的。 5.SYNC_BINLOG 已经有大量的文档写到sync_binlog，以及它和innodb_flush_log_at_trx_commit的关系，下面我们来简单的介绍下： a) 如果你的服务器没有设置从服务器，而且你不做备份，那么设置sync_binlog=0将对性能有好处。 b) 如果你有从服务器并且做备份，但你不介意当主服务器崩溃时在二进制日志丢失一些事件，那么为了更好的性能还是设置为sync_binlog=0. c) 如果你有从服务器并且备份，你非常在意从服务器的一致性，以及能及时恢复到一个时间点(通过使用最新的一致性备份和二进制日志将数据库恢复到特定时间点的能力)，那么你应该设置innodb_flush_log_at_trx_commit=1，并且需要认真考虑使用sync_binlog=1。 问题是sync_binlog=1代价比较高 – 现在每个事务也要同步一次到硬盘。你可能会想为什么不把两次同步合并成一次，想法正确 – 新版本的MySQL(5.6和5.7，MariaDB和Percona Server)已经能合并提交，那么在这种情况下sync_binlog=1的操作也不是这么昂贵了，但在旧的mysql版本中仍然会对性能有很大影响。 6.INNODB_FLUSH_METHOD 将innodb_flush_method设置为O_DIRECT以避免双重缓冲.唯一一种情况你不应该使用O_DIRECT是当你操作系统不支持时。但如果你运行的是Linux，使用O_DIRECT来激活直接IO。 不用直接IO，双重缓冲将会发生，因为所有的数据库更改首先会写入到OS缓存然后才同步到硬盘 – 所以InnoDB缓冲池和OS缓存会同时持有一份相同的数据。特别是如果你的缓冲池限制为总内存的50%，那意味着在写密集的环境中你可能会浪费高达50%的内存。如果没有限制为50%，服务器可能由于OS缓存的高压力会使用到swap。 简单地说，设置为innodb_flush_method=O_DIRECT。 7.INNODB_BUFFER_POOL_INSTANCES MySQL 5.5引入了缓冲实例作为减小内部锁争用来提高MySQL吞吐量的手段。 在5.5版本这个对提升吞吐量帮助很小，然后在MySQL 5.6版本这个提升就非常大了，所以在MySQL5.5中你可能会保守地设置innodb_buffer_pool_instances=4，在MySQL 5.6和5.7中你可以设置为8-16个缓冲池实例。 你设置后观察会觉得性能提高不大，但在大多数高负载情况下，它应该会有不错的表现。 对了，不要指望这个设置能减少你单个查询的响应时间。这个是在高并发负载的服务器上才看得出区别。比如多个线程同时做许多事情。 8.INNODB_THREAD_CONCURRENCY InnoDB有一种方法来控制并行执行的线程数 – 我们称为并发控制机制。大部分是由innodb_thread_concurrency值来控制的。如果设置为0，并发控制就关闭了，因此InnoDB会立即处理所有进来的请求(尽可能多的)。 在你有32CPU核心且只有4个请求时会没什么问题。不过想像下你只有4CPU核心和32个请求时 – 如果你让32个请求同时处理，你这个自找麻烦。因为这些32个请求只有4 CPU核心，显然地会比平常慢至少8倍(实际上是大于8倍)，而然这些请求每个都有自己的外部和内部锁，这有很大可能堆积请求。 下面介绍如何更改这个变量，在mysql命令行提示符执行： 对于大多数工作负载和服务器，设置为8是一个好开端，然后你可以根据服务器达到了这个限制而资源使用率利用不足时逐渐增加。可以通过show engine innodb statusG来查看目前查询处理情况，查找类似如下行： 9.SKIP_NAME_RESOLVE 这一项不得不提及，因为仍然有很多人没有添加这一项。你应该添加skip_name_resolve来避免连接时DNS解析。 大多数情况下你更改这个会没有什么感觉，因为大多数情况下DNS服务器解析会非常快。不过当DNS服务器失败时，它会出现在你服务器上出现“unauthenticated connections” ，而就是为什么所有的请求都突然开始慢下来了。 所以不要等到这种事情发生才更改。现在添加这个变量并且避免基于主机名的授权。 10.INNODB_IO_CAPACITY, INNODB_IO_CAPACITY_MAX * innodb_io_capacity：用来当刷新脏数据时，控制MySQL每秒执行的写IO量。 * innodb_io_capacity_max: 在压力下，控制当刷新脏数据时MySQL每秒执行的写IO量 首先，这与读取无关 – SELECT查询执行的操作。对于读操作，MySQL会尽最大可能处理并返回结果。至于写操作，MySQL在后台会循环刷新，在每一个循环会检查有多少数据需要刷新，并且不会用超过innodb_io_capacity指定的数来做刷新操作。这也包括更改缓冲区合并（在它们刷新到磁盘之前，更改缓冲区是辅助脏页存储的关键）。 第二，我需要解释一下什么叫“在压力下”，MySQL中称为”紧急情况”，是当MySQL在后台刷新时，它需要刷新一些数据为了让新的写操作进来。然后，MySQL会用到innodb_io_capacity_max。 那么，应该设置innodb_io_capacity和innodb_io_capacity_max为什么呢？ 最好的方法是测量你的存储设置的随机写吞吐量，然后给innodb_io_capacity_max设置为你的设备能达到的最大IOPS。innodb_io_capacity就设置为它的50-75%，特别是你的系统主要是写操作时。 通常你可以预测你的系统的IOPS是多少。例如由8 15k硬盘组成的RAID10能做大约每秒1000随机写操作，所以你可以设置innodb_io_capacity=600和innodb_io_capacity_max=1000。许多廉价企业SSD可以做4,000-10,000 IOPS等。 这个值设置得不完美问题不大。但是，要注意默认的200和400会限制你的写吞吐量，因此你可能偶尔会捕捉到刷新进程。如果出现这种情况，可能是已经达到你硬盘的写IO吞吐量，或者这个值设置得太小限制了吞吐量。 11.INNODB_STATS_ON_METADATA 如果你跑的是MySQL 5.6或5.7，你不需要更改innodb_stats_on_metadata的默认值，因为它已经设置正确了。 不过在MySQL 5.5或5.1，强烈建议关闭这个变量 – 如果是开启，像命令show table status会立即查询INFORMATION_SCHEMA而不是等几秒再执行，这会使用到额外的IO操作。 从5.1.32版本开始，这个是动态变量，意味着你不需要重启MySQL服务器来关闭它。 12.INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN & INNODB_BUFFER_POOL_LOAD_AT_STARTUP innodb_buffer_pool_dump_at_shutdown和innodb_buffer_pool_load_at_startup这两个变量与性能无关，不过如果你偶尔重启mysql服务器(如生效配置)，那么就有关。当两个都激活时，MySQL缓冲池的内容(更具体地说，是缓存页)在停止MySQL时存储到一个文件。当你下次启动MySQL时，它会在后台启动一个线程来加载缓冲池的内容以提高预热速度到3-5倍。 两件事： 第一，它实际上没有在关闭时复制缓冲池内容到文件，仅仅是复制表空间ID和页面ID – 足够的信息来定位硬盘上的页面了。然后它就能以大量的顺序读非常快速的加载那些页面，而不是需要成千上万的小随机读。 第二，启动时是在后台加载内容，因为MySQL不需要等到缓冲池内容加载完成再开始接受请求(所以看起来不会有什么影响)。 从MySQL 5.7.7开始，默认只有25%的缓冲池页面在mysql关闭时存储到文件，但是你可以控制这个值 – 使用innodb_buffer_pool_dump_pct，建议75-100。 这个特性从MySQL 5.6才开始支持。 13.INNODB_ADAPTIVE_HASH_INDEX_PARTS 如果你运行着一个大量SELECT查询的MySQL服务器(并且已经尽可能优化)，那么自适应哈希索引将下你的下一个瓶颈。自适应哈希索引是InnoDB内部维护的动态索引，可以提高最常用的查询模式的性能。这个特性可以重启服务器关闭，不过默认下在mysql的所有版本开启。 这个技术非常复杂，在大多数情况下它会对大多数类型的查询直到加速的作用。不过，当你有太多的查询往数据库，在某一个点上它会花过多的时间等待AHI锁和闩锁。 如果你的是MySQL 5.7，没有这个问题 – innodb_adaptive_hash_index_parts默认设置为8，所以自适应哈希索引被切割为8个分区，因为不存在全局互斥。 不过在mysql 5.7前的版本，没有AHI分区数量的控制。换句话说，有一个全局互斥锁来保护AHI，可能导致你的select查询经常撞墙。 所以如果你运行的是5.1或5.6，并且有大量的select查询，最简单的方案就是切换成同一版本的Percona Server来激活AHI分区。 14.QUERY_CACHE_TYPE 如果人认为查询缓存效果很好，肯定应该使用它。好吧，有时候是有用的。不过这个只在你在低负载时有用，特别是在低负载下大多数是读取，小量写或者没有。 如果是那样的情况，设置query_cache_type=ON和query_cache_size=256M就好了。不过记住不能把256M设置更高的值了，否则会由于查询缓存失效时，导致引起严重的服务器停顿。 如果你的MySQL服务器高负载动作，建议设置query_cache_size=0和query_cache_type=OFF，并重启服务器生效。那样Mysql就会停止在所有的查询使用查询缓存互斥锁。 15.TABLE_OPEN_CACHE_INSTANCES 从MySQL 5.6.6开始，表缓存能分割到多个分区。 表缓存用来存放目前已打开表的列表，当每一个表打开或关闭互斥体就被锁定 – 即使这是一个隐式临时表。使用多个分区绝对减少了潜在的争用。 从MySQL 5.7.8开始，table_open_cache_instances=16是默认的配置。 欢迎做Java的工程师朋友们私信我资料免费获取免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料） 其中覆盖了互联网的方方面面，期间碰到各种产品各种场景下的各种问题，很值得大家借鉴和学习，扩展自己的技术广度和知识面。

1.又键单击“我的电脑（windows XP）”或“计算机（Windows 7）”查看本机的计算机名。2.打开“SQL Server 2008”，服务器类型选择：数据库引擎。服务器名称写上：计算机名安装SQL Server时自己创建的实例名。身份验证选择：SQL Server 身份验证。填上自己设置的登录名和密码。3.点击“连接”就可以登录了此时，SQL Server 2008登录出错的问题就解决了。总结：SQL Server 2008 版本数据库软件的服务器名称较SQL Server 2005版本做了改变，现在使用的是：计算机名实例名。这就导致了“无法连接到（local）”的问题。

不知道，学习一下

在服务里，找到sqlserver的服务，服务后面跟着一个括号，括号里就是实例名。比如服务名是sqlserver(mssqlserver)，则mssqlserver就是实例名。

使用递归查询，可以使用MySQL中的WITH语句来实现递归查询。WITH语句允许用户指定一个递归查询，在查询中可以使用表达式来指定查询的开始和结束条件，以及查询的结果如何被收集with recursive cte as (select id, name, parent_id from table1 where parent_id is nullunion allselect t.id, t.name, t.parent_id from table1 tinner join cte c on t.parent_id = c.id)select * from cte;

DML英文缩写　　DML = Data Manipulation Language，数据操纵语言，命令使用户能够查询数据库以及操作已有数据库中的数据的计算机语言。具体是指是UPDATE更新、INSERT插入、DELETE删除。　　DML = Data Media Laboratory，数据媒体实验室。　　DML = Doctor of Modern Languages，现代语言博士。　　DML（DataManipulation Language）数据操纵语言，SQL的分类之一，此外还有DDL（DataDefinition Language）数据定义语言和DCL（DataControl Language）数据控制语言。DML包括：INSERT、UPDATE、DELETE。注意，select语句属于DQL(DataQuery Language)。1　　DML：abbr.Doctorof Modern Languages 现代语言博士分类　　DML分成交互型DML和嵌入型DML两类。　　依据语言的级别，DML又可分成过程性DML和非过程性DML两种。　　如insert,delete,update,select(插入、删除、修改、检索)等都是DML.　　交互型DML:这类DML自成系统，可在终端上直接对数据库进行操作。　　嵌入型DML:这类DML是嵌入在主语言中使用。此时主语言是经过扩充能处理DML语句的语言。　　过程性DML:用户编程时，不仅需要指出“做什么”(需要什么样的数据)，还需要指出“怎么做”(怎么获得数据)。层状、网状的DML属于过程性语言。非过程性DML:用户编程时，只需要指出“做什么”，不需要指出“怎么做”。关系型DML属于非过程性语言。DDL　数据库模式定义语言DDL(DataDefinition Language)，是用于描述数据库中要存储的现实世界实体的语言。一个数据库模式包含该数据库中所有实体的描述定义。这些定义包括结构定义、操作方法定义等。　　数据库模式定义语言并非程序设计语言，DDL数据库模式定义语言是SQL语言（结构化程序设计语言）的组成部分。SQL语言包括三种主要程序设计语言类别的语句：数据定义语言(DDL)，数据操作语言(DML)及数据控制语言(DCL)。　　DDL描述的模式，必须由计算机软件进行编译，转换为便于计算机存储、查询和操纵的格式，完成这个转换工作的程序称为模式编译器。　　模式编译器处理模式定义主要产生两种类型的数据：数据字典以及数据类型和结构定义。　　数据字典和数据库内部结构信息是创建该模式所对应的数据库的依据，根据这些信息创建每个数据库对应的逻辑结构；对数据库数据的访问、查询也根据模式信息决定数据存取的方式和类型，以及数据之间的关系和对数据的完整性约束。　　数据字典是模式的内部信息表示，数据字典的存储方式对不同的DBMS各不相同。　　数据类型和结构的定义，是指当应用程序与数据库连接操作时，应用程序需要了解产生和提取的数据类型和结构。是为各种宿主语言提供的用户工作区的数据类型和结构定义，使用户工作区和数据库的逻辑结构相一致，减少数据的转换过程，这种数据类型和结构的定义通常用一个头文件来实现。　　数据库模式的定义通常有两种方式:交互方式定义模式和通过数据描述语言DDL描述文本定义模式。DCL一、DCL（DataControl Language）是数据库控制语言。是用来设置或更改数据库用户或角色权限的语句，包括（grant,deny,revoke等）语句。在默认状态下，只有sysadmin,dbcreator,db_owner或db_securityadmin等人员才有权力执行DCL　　DCL数据库控制语言不同于程序设计语言，SQL语言（结构化程序设计语言）的组成部分包括了DCL数据库控制语言。 SQL语言包括三种主要程序设计语言类别的语句：数据定义语言(DDL)，数据操作语言(DML)及数据控制语言(DCL)。二、(DCL)复合杠杆　　复合杠杆(Degree of Combining Leverage)是指由于固定成本和固定财务费用的存在而导致的普通股每股利润变动率大于产销量变动率的杠杆效应。　　对复合杠杆计量的主要指标是复合杠杆系数或复合杠杆度。复合杠杆系数是指普通股每股利润变动率相当于产销量变动率的倍数。其计算公式为：　　DCL＝（△EPS/EPS）÷（△Q/Q）＝DOL×DFL　　复合杠杆系数 ＝基期边际贡献÷（基期息税前利润－利息）DQLDQL:Data QueryLanguage SELECT 数据查询语言　　select具体用法　　SELECTselect_list　　[ INTOnew_table ]　　FROMtable_source　　[ WHEREsearch_condition ]　　[ GROUPBY group_by_expression ]　　[ HAVINGsearch_condition ]　　[ ORDERBY order_expression [ ASC | DESC ] ]　　例子：找出emp表中员工号为007的员工的工资　　SELECTt.sal　　FROM emptWHERE t.ID =007

ddl是sql的一种，ddl是数据库定义语言，比如创建表，修改表等操作统称为ddl还有一种叫dml，是对表中数据进行操作的，比如insert ，update delete 和 select等操作。

DDL就是数据定义语言创建、修改、删除表、视图、存储过程等都属于DDL一般帮助里都有很详细的说明，你可以参考一下

如果将来数据库服务也在容器中提供,建议使用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的范围 你能怎么改 换类型又不会怎么样 程序取到数之后你再方法里面强转一下就是了

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

SQL 巩固练习用到了前几天几个知识点 在查看SQL Server 2005的帮助文档中的cross apply 运算符时发现了一个个人感觉用到的知识点儿比较多，比较经典的例子。在此写下来，也是为了巩固一下前几天的知识点。 先建表一员工表（Employees）： CREATE TABLE Emplo SQL 巩固练习——用到了前几天几个知识点在查看SQL Server 2005的帮助文档中的cross apply 运算符时发现了一个个人感觉用到的知识点儿比较多，免备案空间，比较经典的例子。在此写下来，香港空间，也是为了巩固一下前几天的知识点。先建表一员工表（Employees）：CREATE TABLE Employees( empid , mgrid intNULL, empname varchar(25) NOT NULL, salary , CONSTRAINT PK_Employees PRIMARY KEY(empid),)向Employees表中插入数据：Employees , $10000.00), $5000.00), $5000.00), $5000.00) , $2500.00), $2500.00), $2500.00), $2500.00), $2500.00), $2500.00), $2000.00), $2000.00), $2000.00), $1500.00)查询向Employees表插入的全部数据SQL语句：Employees结果如图：再建表二部门表（Departments）：CREATE TABLE Departments( deptid , deptname VARCHAR(25) NOT NULL, deptmgrid Employees)向Departments表插入数据：,2), 7),8),9),4), NULL)查询向Departments表插入的全部数据SQL语句：Departments结果如图：下面的表值函数使用雇员 ID 作为参数，并返回该雇员及他/她的所有下属（用到了前面所学的CTE公共表表达式 with...as... 的递归）：) ( empid , empname VARCHAR(25) NOT NULL, mgrid INT NULL, lvl) Employees_Subtree(empid, empname, mgrid, lvl) AS (empid, empname, mgrid, 0FROM employeese.empid, e.empname, e.mgrid, es.lvlemployees AS eJOIN employees_subtree AS esON e.mgrid = es.empid ) Employees_Subtree返回每个部门经理的所有级别的全部下属，使用下面的SQL语句（用到了apply的cross apply）：Departments AS D CROSS APPLY fn_getsubtree(D.deptmgrid) AS ST结果如图：，虚拟主机

-- 使用数据库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中如何创表以及添加各种约束条件标签：

是自问自答？要达到题目的要求还需要group by 吧。

例子: select count(*) from table where DATEDIFF ([second], "2004-09-18 00:00:18", "2004-09-18 00:00:19") 0 说明 select DATEDIFF(day, time1 , time2) 对应示例语句如下 select DATEDIFF(day, "2010-07-23 0:41:18", "2010-07-23 23:41:18") time1 ti 例子:select count(*) from table where DATEDIFF ([second], "2004-09-18 00:00:18", "2004-09-18 00:00:19") > 0说明select DATEDIFF(day, time1 , time2) 对应示例语句如下select DATEDIFF(day, "2010-07-23 0:41:18", "2010-07-23 23:41:18")time1 > time2 为负数;time1 < time2 为正数;[day] :只会比较 2010-07-23 忽略 0:41:18" 其他同理以下分别:年: SELECT DATEDIFF([year],time1 , time2) 返回值： -6 ，说明是后减前 与 mysql教程 相反的。月: SELECT DATEDIFF([month], time1 , time2)天: SELECT DATEDIFF([day], time1 , time2)小时: SELECT DATEDIFF([hour], time1 , time2)秒: SELECT DATEDIFF([second], time1 , time2) 通过函数GETDATE（），你可以获得当前的日期和时间。函数GETDATE（）可以用来作为DATEDIME型字段的缺省值。这对插入记录时保存当时 的时间是有用的。要建立一个表，其中的记录包含有当前的日期和时间，可以添加一个DATETIME型字段，指定其缺省值为函数GETDATE（）的返回 值，就象这样：CREATE TABLE site_log ( username VARCHAR(40)， useractivity VARCHAR(100)， entrydate DATETIME DEFAULT GETDATE())转换日期和时间函数GETDATE（）的返回值在显示时只显示到秒。实际上，SQL Sever内部时间可以精确到毫秒级（确切地说，可以精确到3.33毫秒）。要得到不同格式的日期和时间，你需要使用函数CONVERT（）。例如，当下面的这个语句执行时，显示的时间将包括毫秒：SELECT CONVERT(VARCHAR(30)，GETDATE()，9)注意例子中数字9的使用。这个数字指明了在显示日期和时间时使用哪种日期和时间格式。当这个语句执行时，将显示如下的日期和时间：Nov 30 1997 3:29:55:170AM(1 row(s) affected)在函数CONVERT（）中你可以使用许多种不同风格的日期和时间格式。下表显示了所有的格式。日期和时间的类型：类型值 标准 输出 0 Default mon dd yyyy hh:miAM 1 USA mm/dd/yy 2 ANSI yy.mm.dd 3 British/French dd/mm/yy 4 German dd.mm.yy 5 Italian dd-mm-yy 6 - dd mon yy 7 - mon dd，yy 8 - hh:mi:ss 9 Default + milliseconds--mon dd yyyyhh:mi:ss:mmmAM(or ) 10 USA mm-dd-yy 11 JAPAN yy/mm/dd 12 ISO yymmdd 13 Europe Default + milliseconds--dd mon yyyy hh:mi:ss:mmm(24h) 14 - hh:mi:ss:mmm(24h) 类型0，9，和13总是返回四位的年。对其它类型，要显示世纪，把style值加上100。类型13和14返回24小时时钟的时间。类型0，7，和13返回的月份用三位字符表示（用Nov代表November）.对表中所列的每一种格式，你可以把类型值加上100来显示有世纪的年（例如，，00年将显示为2000年）。例如，要按日本标准显示日期，包括世纪，你应使用如下的语句：SELECT CONVERT（VARCHAR（30），GETDATE（），111） 在这个例子中，函数CONVERT（）把日期格式进行转换，显示为1997/11/30抽取日期和时间在许多情况下，你也许只想得到日期和时间的一部分，而不是完整的日期和时间。为了抽取日期的特定部分，你可以使用函数DATEPART（），象这样：SELECT site_name u2018Site Nameu2019，DATEPART(mm，site_entrydate) u2018Month Postedu2019 FROM site_directory函数DATEPART（）的参数是两个变量。第一个变量指定要抽取日期的哪一部分；第二个变量是实际的数据。在这个例子中，函数DATEPART（）抽取月份，因为mm代表月份。下面是这个SELECT 语句的输出结果：Site Name Month Postedu2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026Yahoo 2Microsoft 5Magicw3 5(3 row(s) affected) Month Posted列显示了每个站点被查询的月份。函数DATEPART（）的返回值是一个整数。你可以用这个函数抽取日期的各个不同部分，如下表所示。日期的各部分及其简写日期部分 简写 值year yy 1753--9999quarter qq 1--4month mm 1--12day of year dy 1--366day dd 1--31week wk 1--53weekday dw 1--7(Sunday--Saturday)hour hh 0--23minute mi 0--59second ss 0--59milisecond ms 0--999当你需要进行日期和时间的比较时，使用函数DATEPART（）返回整数是有用的。但是，上例中的查询结果（2，5）不是十分易读。要以更易读的格式得到部分的日期和时间，你可以使用函数DATENAME（），如下例所示：SELECT site_name u2018Site Nameu2019DATENAME(mm，site_entrydate) u2018Month Postedu2019FROM site_directory函数DATENAME（）和函数DATEPART（）接收同样的参数。但是，它的返回值是一个字符串，而不是一个整数。下面是上例该用DATENAME（）得到的结果：Site Name Month Postecu2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026.Yahoo FebruaryMicrosoft JuneMagicw3 June(3 row(s) affected)你也可以用函数DATENAE（）来抽取一个星期中的某一天。下面的这个例子同时抽取一周中的某一天和日期中的月份：SELECT site_name u2018Site Nameu2019，DATENAME(dw，site_entrydate)+ u2018-u2019 + DATENAME（mm，site_entrydate） u2018Day and Month Postedu2019 FORM site_directory这个例子执行时，将返回如下的结果：Site Name Day and Month Postedu2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026u2026Yahoo Friday - FebruaryMicrosoft Tuesday - JuneMagicw3 Monday - June(3 row(s) affected)返回日期和时间范围当你分析表中的数据时，你也许希望取出某个特定时间的数据。你也许对特定的某一天中??比如说2000年12月25日??访问者在你站点上的活动感兴趣。要取出这种类型的数据，你也许会试图使用这样的SELECT语句：SELECT * FROM weblog WHERE entrydate="12/25/20000"不要这样做。这个SELECT语句不会返回正确的记录??它将只返回日期和时间是12/25/2000 12:00:00:000AM的记录。换句话说，只有刚好在午夜零点输入的记录才被返回。问题是SQL Sever将用完整的日期和时间代替部分日期和时间。例如，当你输入一个日期，但不输入时间时，SQL Sever将加上缺省的时间“12：00：00：000AM”。当你输入一个时间，但不输入日期时，SQL Sever将加上缺省的日期“Jan 1 1900”。要返回正确的记录，你需要适用日期和时间范围。有不止一种途径可以做到这一点。例如，下面的这个SELECT 语句将能返回正确的记录：SELECT * FROM weblogWHERE entrydate>=”12/25/2000” AND entrydate=运算符,和datediff函数datediff函数:DATEDIFF ( datepart , startdate , enddate )datepart的取值可以是year,quarter,Month,dayofyear,Day,Week,Hour,minute,second,millisecondstartdate 是从 enddate 减去。如果 startdate 比 enddate 晚，返回负值。看以下实例:搜索hiredate的值在"1993-05-03"后的记录,该sql语句如下:SELECT hiredateFROM employeesWHERE datediff(day,cast(1993-05-03 as datetime),hiredate) >0执行该语句后结果如下:hiredate1993-10-17 00:00:00.0001993-10-17 00:00:00.0001994-01-02 00:00:00.0001994-03-05 00:00:00.0001994-11-15 00:00:00.000因此datediff(day,cast(1993-05-03 as datetime),hiredate)是把hiredate的值按"day"减去cast(1993-05-03 as datetime)的值.通过判定相减后值的正负来判定日期的先后。

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.delimiter //create procedure p1()begin update table_name set content=concat("百度",content);end//delimiter ;call p1();2.use mysql;delect from proc where db="test" and (type="PROCEDURE" or type="TRIGGER") and definer like "你的账号%";3.4.convert 中的 121 是指将 datetime 类型转换为 char 类型时获得包括世纪位数的 4 位年份。 我在mysql里面测试测这几个！

索引相关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()结果如图：

分类汇总的时候用。group by ：表示按字段分组。例如：分别计算男性用户和女性用户的平均年龄。select 性别，avg(年龄) as average from 表名 group by 性别

1、作用删除指定长度的字符，并在指定的起点处插入另一组字符。2、语法STUFF ( character_expression , start , length ,character_expression )3、示例以下示例在第一个字符串 abcdef 中删除从第 2 个位置（字符 b）开始的三个字符，然后在删除的起始位置插入第二个字符串，从而创建并返回一个字符串SELECT STUFF("abcdef", 2, 3, "ijklmn")GO下面是结果集aijklmnef

stuff(select "," + fieldname from tablename for xml path("")),1,1,"") 这一整句的作用是将多行fieldname字段的内容串联起来，用逗号分隔。

substring（字符串，开始位置，截取长度），substring（"abcd"，1，2）=bc

SUBSTR(string,start,count)取子字符串，从start开始（如果start是负数，从尾部开始），取count个上述就是PL/SQL函数的解释，从中可以看出，是1开始从左开始取数；如果是负值，那么就从右开始取数。

sql 截取字符串：1、LOCATE(substr , str )：返回子串 substr 在字符串 str 中第一次出现的位置，如果字符substr在字符串str中不存在，则返回0；2、POSITION(substr IN str )：返回子串 substr 在字符串 str 中第一次出现的位置，如果字符substr在字符串str中不存在，与LOCATE函数作用相同；3、LEFT(str, length)：从左边开始截取str，length是截取的长度；4、RIGHT(str, length)：从右边开始截取str，length是截取的长度；5、SUBSTRING_INDEX(str ,substr ,n)：返回字符substr在str中第n次出现位置之前的字符串;6、SUBSTRING(str ,n ,m)：返回字符串str从第n个字符截取到第m个字符；7、REPLACE(str, n, m)：将字符串str中的n字符替换成m字符；8、LENGTH(str)：计算字符串str的长度。

x为字符串， y为开始位置，z为截取长度例如:>> select substr("abcdefghijklmnopqrstuvwxyz", 10,10)jklmnopqrs>>

sub(字段,开始长度,结束长度)

substr(字符串,截取开始位置,截取长度) //返回截取的字substr("Hello World",0,1) //返回结果为 "H" *从字符串第一个字符开始截取长度为1的字符串substr("Hello World",1,1) //返回结果为 "H" *0和1都是表示截取的开始位置为第一个字符substr("Hello World",2,4) //返回结果为 "ello"substr("Hello World",-3,3)//返回结果为 "rld" *负数(-i)表示截取的开始位置为字符串右端向左数第i个字符

SQL的SUBSTR 函数的使用方法介绍 　　SUBSTR函数是用来截取数据库某一列字段中的一部分。 　　在各个数据库的函数名称不一样（真是蛋疼，后发明的数据库难道不能同先发明的一样吗？） 　　复制代码 代码如下: 　　MySQL: SUBSTR( ), SUBSTRING( ) 　　Oracle: SUBSTR( ) 　　SQL Server: SUBSTRING( ) ; 　　常用的方式是： 　　SBUSTR(str,pos); 　　就是从pos开始的位置，一直截取到最后。 　　还有一种比较常用的"是： 　　复制代码 代码如下: 　　SUBSTR(str,pos,len); 　　这种表示的意思是，就是从pos开始的位置，截取len个字符(空白也算字符)。 　　需要注意的是：如果pos为1(而不是0)，表示从第一个位置开始。 　　这点也很好理解，因为数据库不是我们平时写程序，他有他自己的一套习惯，数据库的记录都是从1开始没有从0开始。是吧。 ;

select substring("1234",1,2);+--------------------------+| substring("1234",1,2) |+--------------------------+| 12 |+--------------------------+select substring("1234",0,2)+--------------------------+| substring("1234",0,2) |+--------------------------+| 1 |+--------------------------+

--SQL版Create Function MyReplace(@Reg Varchar(1000),@Source Varchar(4000),@Str Varchar(1000))returns sql_variant AsBegin Declare @Err Int Declare @obj Int Declare @Rst sql_variant EXEC @Err=Sp_OACreate "VBScript.RegExp",@obj OUTPUT If @Err<>0 GoTo LB EXEC @Err=Sp_OASetProperty @obj,"Pattern",@Reg If @Err<>0 GoTo LB EXEC @Err=Sp_OASetProperty @obj,"Global","True" If @Err<>0 GoTo LB EXEC @Err=Sp_OASetProperty @obj,"IgnoreCase","False" If @Err<>0 GoTo LB EXEC @Err=Sp_OAMethod @obj,"Replace",@Rst OUTPUT,@source,@Str If @Err<>0 GoTo LB EXEC @Err=Sp_OADestroy @obj If @Err<>0 GoTo LB Return @RstLB: EXEC Sp_OADestroy @obj RETURN NullEndCreate Function IsMatch(@Reg Varchar(1000),@Source Varchar(4000))returns sql_variant AsBegin Declare @Err Int Declare @obj Int Declare @Rst sql_variant EXEC @Err=Sp_OACreate "VBScript.RegExp",@obj OUTPUT If @Err<>0 GoTo LB EXEC @Err=Sp_OASetProperty @obj,"Pattern",@Reg If @Err<>0 GoTo LB EXEC @Err=Sp_OASetProperty @obj,"Global","True" If @Err<>0 GoTo LB EXEC @Err=Sp_OASetProperty @obj,"IgnoreCase","False" If @Err<>0 GoTo LB EXEC @Err=Sp_OAMethod @obj,"Test",@Rst OUTPUT,@source If @Err<>0 GoTo LB EXEC @Err=Sp_OADestroy @obj If @Err<>0 GoTo LB Return @RstLB: EXEC Sp_OADestroy @obj RETURN NullEnd--CLR版using System;using System.Data;using System.Data.SqlClient;using System.Data.SqlTypes;using System.Collections;using Microsoft.SqlServer.Server;using System.Text.RegularExpressions;public partial class SqlFunction{ //匹配 [Microsoft.SqlServer.Server.SqlFunction] public static SqlString IsMatch(string source,string pattern) { SqlString Rst; if (Regex.IsMatch(source, pattern) == true) Rst = "True"; else Rst = "False"; return Rst; } //替换 [Microsoft.SqlServer.Server.SqlFunction] public static SqlString MyReplace(string source, string pattern, string value) { return Regex.Replace(source, pattern, value); } //分割 [Microsoft.SqlServer.Server.SqlFunction(FillRowMethodName = "FillRow",TableDefinition="ZFCC_C nvarchar(100)")] public static IEnumerable Splict(string source, string pattern) { return Regex.Split(source, pattern); } public static void FillRow(object obj, out SqlString str) { str = new SqlString ((string )obj); } //统计 [Microsoft.SqlServer.Server.SqlFunction] public static SqlInt32 Occurs(string source, string pattern) { return Regex.Matches(source, pattern).Count; } //截取 [Microsoft.SqlServer.Server.SqlFunction] public static SqlString MySubstr(string source, string pattern) { string Rst=""; MatchCollection MCollection; MCollection = Regex.Matches(source, pattern); foreach (Match M in MCollection) Rst+=M.Value; return Rst; }};

替换成什么？

你这个是直接查excel的，所以不支持自定义函数，你可以这么实现：把结果查出来，然后循环中用tiqu这个函数处理，当然你的函数要改成传字符串了。

delete from 表A where lefttrim(righttrim(字段名)) like "第%"

public string NoHTML(string Htmlstring) //去除HTML标记 { //删除脚本 Htmlstring = Regex.Replace(Htmlstring, @"<script[^>]*?>.*?</script>", "", RegexOptions.IgnoreCase); //删除HTML Htmlstring = Regex.Replace(Htmlstring, @"<(.[^>]*)>", "", RegexOptions.IgnoreCase); Htmlstring = Regex.Replace(Htmlstring, @"([ ])[s]+", "", RegexOptions.IgnoreCase); Htmlstring = Regex.Replace(Htmlstring, @"-->", "", RegexOptions.IgnoreCase); Htmlstring = Regex.Replace(Htmlstring, @"<!--.*", "", RegexOptions.IgnoreCase); Htmlstring = Regex.Replace(Htmlstring, @"&(quot|#34);", """, RegexOptions.IgnoreCase); Htmlstring = Regex.Replace(Htmlstring, @"&(amp|#38);", "&", RegexOptions.IgnoreCase); Htmlstring = Regex.Replace(Htmlstring, @"&(lt|#60);", "<", RegexOptions.IgnoreCase); Htmlstring = Regex.Replace(Htmlstring, @"&(gt|#62);", ">", RegexOptions.IgnoreCase); Htmlstring = Regex.Replace(Htmlstring, @"&(nbsp|#160);", " ", RegexOptions.IgnoreCase); Htmlstring = Regex.Replace(Htmlstring, @"&(iexcl|#161);", "xa1", RegexOptions.IgnoreCase); Htmlstring = Regex.Replace(Htmlstring, @"&(cent|#162);", "xa2", RegexOptions.IgnoreCase); Htmlstring = Regex.Replace(Htmlstring, @"&(pound|#163);", "xa3", RegexOptions.IgnoreCase); Htmlstring = Regex.Replace(Htmlstring, @"&(copy|#169);", "xa9", RegexOptions.IgnoreCase); Htmlstring = Regex.Replace(Htmlstring, @"(d+);", "", RegexOptions.IgnoreCase); Htmlstring.Replace("<", ""); Htmlstring.Replace(">", ""); Htmlstring.Replace(" ", ""); Htmlstring = HttpContext.Current.Server.HtmlEncode(Htmlstring).Trim(); return Htmlstring; }

用以下的sql可以查询出当前session中正在运行的sql信息：SELECT S.MODULE, SQL_TEXT, SN.OSUSER, SN.MACHINE, S.EXECUTIONSFROM SYS.V_$SQL S, SYS.ALL_USERS U, V$SESSION SNWHERE S.PARSING_USER_ID = U.USER_IDAND UPPER(U.USERNAME) IN ("USERNAME")AND (UPPER(S.MODULE) = "APP.EXE")AND SN.sql_hash_value = S.hash_valueAND SN.sql_address = S.addressORDER BY S.LAST_LOAD_TIME

你连接的时候监听还没有起来吧

第1步：找到菜单选项第2步：选择表名第3步：选择文件类型为Excel第4步：设置参数在oracle中trim函数可以除去字符串前后的空格，所以选上。第5步：把excel中的列和数据库中的字段对应起来。每一列对应一个字段。第6步：查看约束第7步：设置导入模式，我设置的时导入完成后不提交，手动提交。点击Execute执行。执行过程中：出现以下错误，问到是否继续执行。这种错误一般是因为excel中的数据结构与数据库表中的数据类型不统一而引起的。我点击的yes继续执行，中间可能还会有其它的数据类型有问题，这些都需要在上传Excel之前做好数据处理。最终导入完成会弹出以下的信息。执行了527条，成功了523。也就是说有4条数据有问题，没有插入进去。总结：用excel向数据库中导表时，首先要保存excel中的字段数据类型与数据库中的数据类型相同，注意主键约束和字符串长度也不能超出限制。调整好数据就可以快速的导入。

你使用光盘装的还是什么安装的。

一、关系运算：1. 等值比较: = 语法：A=B 操作类型：所有基本类型 描述: 如果表达式A与表达式B相等，则为TRUE；否则为FALSE 举例： hive>select 1 from lxw_dual where 1=1; 12. 不等值比较: <> 语法: A <> B操作类型: 所有基本类型描述: 如果表达式A为NULL，或者表达式B为NULL，返回NULL；如果表达式A与表达式B不相等，则为TRUE；否则为FALSE举例：hive> select1 from lxw_dual where 1 <> 2;13. 小于比较: < 语法: A < B操作类型: 所有基本类型描述: 如果表达式A为NULL，或者表达式B为NULL，返回NULL；如果表达式A小于表达式B，则为TRUE；否则为FALSE举例：hive> select1 from lxw_dual where 1 < 2;14. 小于等于比较: <=语法: A <= B操作类型: 所有基本类型描述: 如果表达式A为NULL，或者表达式B为NULL，返回NULL；如果表达式A小于或者等于表达式B，则为TRUE；否则为FALSE举例：hive> select1 from lxw_dual where 1 <= 1;15. 大于比较: >语法: A > B操作类型: 所有基本类型描述: 如果表达式A为NULL，或者表达式B为NULL，返回NULL；如果表达式A大于表达式B，则为TRUE；否则为FALSE举例：hive> select1 from lxw_dual where 2 > 1;16. 大于等于比较: >=语法: A >= B操作类型: 所有基本类型描述: 如果表达式A为NULL，或者表达式B为NULL，返回NULL；如果表达式A大于或者等于表达式B，则为TRUE；否则为FALSE举例：hive> select1 from lxw_dual where 1 >= 1;1注意：String的比较要注意(常用的时间比较可以先to_date之后再比较)hive> select* from lxw_dual;OK201111120900:00:00 2011111209hive> selecta,b,a<b,a>b,a=b from lxw_dual;201111120900:00:00 2011111209 false true false7. 空值判断: IS NULL语法: A IS NULL操作类型: 所有类型描述: 如果表达式A的值为NULL，则为TRUE；否则为FALSE举例：hive> select1 from lxw_dual where null is null;18. 非空判断: IS NOTNULL语法: A IS NOT NULL操作类型: 所有类型描述: 如果表达式A的值为NULL，则为FALSE；否则为TRUE举例：hive> select1 from lxw_dual where 1 is not null;19. LIKE比较: LIKE语法: A LIKE B操作类型: strings描述: 如果字符串A或者字符串B为NULL，则返回NULL；如果字符串A符合表达式B 的正则语法，则为TRUE；否则为FALSE。B中字符”_”表示任意单个字符，而字符”%”表示任意数量的字符。举例：hive> select1 from lxw_dual where "football" like "foot%";1hive> select1 from lxw_dual where "football" like "foot____";1注意：否定比较时候用NOT ALIKE Bhive> select1 from lxw_dual where NOT "football" like "fff%";110. JAVA的LIKE操作: RLIKE语法: A RLIKE B操作类型: strings描述: 如果字符串A或者字符串B为NULL，则返回NULL；如果字符串A符合JAVA正则表达式B的正则语法，则为TRUE；否则为FALSE。举例：hive> select1 from lxw_dual where "footbar" rlike "^f.*r$";1注意：判断一个字符串是否全为数字：hive>select 1from lxw_dual where "123456" rlike "^\d+$";1hive> select1 from lxw_dual where "123456aa" rlike "^\d+$";11. REGEXP操作: REGEXP语法: A REGEXP B操作类型: strings描述: 功能与RLIKE相同举例：hive> select1 from lxw_dual where "footbar" REGEXP "^f.*r$";1二、数学运算：1. 加法操作: +语法: A + B操作类型：所有数值类型说明：返回A与B相加的结果。结果的数值类型等于A的类型和B的类型的最小父类型（详见数据类型的继承关系）。比如，int + int 一般结果为int类型，而int + double 一般结果为double类型举例：hive> select1 + 9 from lxw_dual;10hive> createtable lxw_dual as select 1 + 1.2 from lxw_dual;hive>describe lxw_dual;_c0 double2. 减法操作: -语法: A – B操作类型：所有数值类型说明：返回A与B相减的结果。结果的数值类型等于A的类型和B的类型的最小父类型（详见数据类型的继承关系）。比如，int – int 一般结果为int类型，而int – double 一般结果为double类型举例：hive> select10 – 5 from lxw_dual;5hive> createtable lxw_dual as select 5.6 – 4 from lxw_dual;hive>describe lxw_dual;_c0 double3. 乘法操作: *语法: A * B操作类型：所有数值类型说明：返回A与B相乘的结果。结果的数值类型等于A的类型和B的类型的最小父类型（详见数据类型的继承关系）。注意，如果A乘以B的结果超过默认结果类型的数值范围，则需要通过cast将结果转换成范围更大的数值类型举例：hive> select40 * 5 from lxw_dual;2004. 除法操作: /语法: A / B操作类型：所有数值类型说明：返回A除以B的结果。结果的数值类型为double举例：hive> select40 / 5 from lxw_dual;8.0注意：hive中最高精度的数据类型是double,只精确到小数点后16位，在做除法运算的时候要特别注意hive>select ceil(28.0/6.999999999999999999999) from lxw_duallimit 1; 结果为4hive>select ceil(28.0/6.99999999999999) from lxw_dual limit1; 结果为55. 取余操作: %语法: A % B操作类型：所有数值类型说明：返回A除以B的余数。结果的数值类型等于A的类型和B的类型的最小父类型（详见数据类型的继承关系）。举例：hive> select 41 % 5 from lxw_dual;1hive> select 8.4 % 4 from lxw_dual;0.40000000000000036注意：精度在hive中是个很大的问题，类似这样的操作最好通过round指定精度hive> select round(8.4 % 4 , 2) from lxw_dual;0.46. 位与操作: &语法: A & B操作类型：所有数值类型说明：返回A和B按位进行与操作的结果。结果的数值类型等于A的类型和B的类型的最小父类型（详见数据类型的继承关系）。举例：hive> select 4 & 8 from lxw_dual;0hive> select 6 & 4 from lxw_dual;47. 位或操作: |语法: A | B操作类型：所有数值类型说明：返回A和B按位进行或操作的结果。结果的数值类型等于A的类型和B的类型的最小父类型（详见数据类型的继承关系）。举例：hive> select 4 | 8 from lxw_dual;12hive> select 6 | 8 from lxw_dual;148. 位异或操作: ^语法: A ^ B操作类型：所有数值类型说明：返回A和B按位进行异或操作的结果。结果的数值类型等于A的类型和B的类型的最小父类型（详见数据类型的继承关系）。举例：hive> select 4 ^ 8 from lxw_dual;12hive> select 6 ^ 4 from lxw_dual;29．位取反操作: ~语法: ~A操作类型：所有数值类型说明：返回A按位取反操作的结果。结果的数值类型等于A的类型。举例：hive> select ~6 from lxw_dual;-7hive> select ~4 from lxw_dual;-5三、逻辑运算：1. 逻辑与操作: AND语法: A AND B操作类型：boolean说明：如果A和B均为TRUE，则为TRUE；否则为FALSE。如果A为NULL或B为NULL，则为NULL举例：hive> select 1 from lxw_dual where 1=1 and 2=2;12. 逻辑或操作: OR语法: A OR B操作类型：boolean说明：如果A为TRUE，或者B为TRUE，或者A和B均为TRUE，则为TRUE；否则为FALSE举例：hive> select 1 from lxw_dual where 1=2 or 2=2;13. 逻辑非操作: NOT语法: NOT A操作类型：boolean说明：如果A为FALSE，或者A为NULL，则为TRUE；否则为FALSE举例：hive> select 1 from lxw_dual where not 1=2;1四、数值计算1. 取整函数: round语法: round(double a)返回值: BIGINT说明: 返回double类型的整数值部分（遵循四舍五入）举例：hive> select round(3.1415926) from lxw_dual;3hive> select round(3.5) from lxw_dual;4hive> create table lxw_dual as select round(9542.158) fromlxw_dual;hive> describe lxw_dual;_c0 bigint2. 指定精度取整函数: round语法: round(double a, int d)返回值: DOUBLE说明: 返回指定精度d的double类型举例：hive> select round(3.1415926,4) from lxw_dual;3.14163. 向下取整函数: floor语法: floor(double a)返回值: BIGINT说明: 返回等于或者小于该double变量的最大的整数举例：hive> select floor(3.1415926) from lxw_dual;3hive> select floor(25) from lxw_dual;254. 向上取整函数: ceil语法: ceil(double a)返回值: BIGINT说明: 返回等于或者大于该double变量的最小的整数举例：hive> select ceil(3.1415926) from lxw_dual;4hive> select ceil(46) from lxw_dual;465. 向上取整函数: ceiling语法: ceiling(double a)返回值: BIGINT说明: 与ceil功能相同举例：hive> select ceiling(3.1415926) from lxw_dual;4hive> select ceiling(46) from lxw_dual;466. 取随机数函数: rand语法: rand(),rand(int seed)返回值: double说明: 返回一个0到1范围内的随机数。如果指定种子seed，则会等到一个稳定的随机数序列举例：hive> select rand() from lxw_dual;0.5577432776034763hive> select rand() from lxw_dual;0.6638336467363424hive> select rand(100) from lxw_dual;0.7220096548596434hive> select rand(100) from lxw_dual;0.72200965485964347. 自然指数函数: exp语法: exp(double a)返回值: double说明: 返回自然对数e的a次方举例：hive> select exp(2) from lxw_dual;7.38905609893065自然对数函数: ln语法: ln(double a)返回值: double说明: 返回a的自然对数举例：hive> select ln(7.38905609893065) from lxw_dual;2.08. 以10为底对数函数: log10语法: log10(double a)返回值: double说明: 返回以10为底的a的对数举例：hive> select log10(100) from lxw_dual;2.09. 以2为底对数函数: log2语法: log2(double a)返回值: double说明: 返回以2为底的a的对数举例：hive> select log2(8) from lxw_dual;3.010. 对数函数: log语法: log(double base, double a)返回值: double说明: 返回以base为底的a的对数举例：hive> select log(4,256) from lxw_dual;4.011. 幂运算函数: pow语法: pow(double a, double p)返回值: double说明: 返回a的p次幂举例：hive> select pow(2,4) from lxw_dual;16.012. 幂运算函数: power语法: power(double a, double p)返回值: double说明: 返回a的p次幂,与pow功能相同举例：hive> select power(2,4) from lxw_dual;16.013. 开平方函数: sqrt语法: sqrt(double a)返回值: double说明: 返回a的平方根举例：hive> select sqrt(16) from lxw_dual;4.014. 二进制函数: bin语法: bin(BIGINT a)返回值: string说明: 返回a的二进制代码表示举例：hive> select bin(7) from lxw_dual;11115. 十六进制函数: hex语法: hex(BIGINT a)返回值: string说明: 如果变量是int类型，那么返回a的十六进制表示；如果变量是string类型，则返回该字符串的十六进制表示举例：hive> select hex(17) from lxw_dual;11hive> select hex(‘abc") from lxw_dual;61626316. 反转十六进制函数: unhex语法: unhex(string a)返回值: string说明: 返回该十六进制字符串所代码的字符串举例：hive> select unhex(‘616263")from lxw_dual;abchive> select unhex(‘11")from lxw_dual;-hive> select unhex(616263) from lxw_dual;abc17. 进制转换函数: conv语法: conv(BIGINT num, int from_base, int to_base)返回值: string说明: 将数值num从from_base进制转化到to_base进制举例：hive> select conv(17,10,16) from lxw_dual;11hive> select conv(17,10,2) from lxw_dual;1000118. 绝对值函数: abs语法: abs(double a) abs(int a)返回值: double int说明: 返回数值a的绝对值举例：hive> select abs(-3.9) from lxw_dual;3.9hive> select abs(10.9) from lxw_dual;10.919. 正取余函数: pmod语法: pmod(int a, int b),pmod(double a, double b)返回值: int double说明: 返回正的a除以b的余数举例：hive> select pmod(9,4) from lxw_dual;1hive> select pmod(-9,4) from lxw_dual;320. 正弦函数: sin语法: sin(double a)返回值: double说明: 返回a的正弦值举例：hive> select sin(0.8) from lxw_dual;0.717356090899522821. 反正弦函数: asin语法: asin(double a)返回值: double说明: 返回a的反正弦值举例：hive> select asin(0.7173560908995228) from lxw_dual;0.822. 余弦函数: cos语法: cos(double a)返回值: double说明: 返回a的余弦值举例：hive> select cos(0.9) from lxw_dual;0.621609968270664423. 反余弦函数: acos语法: acos(double a)返回值: double说明: 返回a的反余弦值举例：hive> select acos(0.6216099682706644) from lxw_dual;0.924. positive函数: positive语法: positive(int a), positive(double a)返回值: int double说明: 返回a举例：hive> select positive(-10) from lxw_dual;-10hive> select positive(12) from lxw_dual;1225. negative函数: negative语法: negative(int a), negative(double a)返回值: int double说明: 返回-a举例：hive> select negative(-5) from lxw_dual;5hive> select negative(8) from lxw_dual;-8

Session Manager Subsystem，该进程为会话管理子系统用以初始化系统变量，MS-DOS驱动名称类似LPT1以及COM，调用Win32壳子系统和运行在Windows登陆过程。它是一个会话管理子系统，负责启动用户会话。这个进程是通过系统进程初始化的并且对许多活动的，包括已经正在运行的Winlogon，Win32(Csrss.exe)线程和设定的系统变量作出反映。在它启动这些进程后，它等待Winlogon或者Csrss结束。如果这些过程时正常的，系统就关掉了。如果发生了什么不可预料的事情，smss.exe就会让系统停止响应(挂起)。要注意：如果系统中出现了不只一个smss.exe进程，而且有的smss.exe路径是"%WINDIR%SMSS.EXE"，那就是中了TrojanClicker.Nogard.a病毒，这是一种Windows下的PE病毒，它采用VB6编写 ，是一个自动访问某站点的木马病毒。该病毒会在注册表中多处添加自己的启动项，还会修改系统文件WIN.INI，并在[WINDOWS]项中加入"RUN" = "%WINDIR%SMSS.EXE"。手工清除时请先结束病毒进程smss.exe，再删除%WINDIR%下的smss.exe文件，然后清除它在注册表和WIN.INI文件中的相关项即可。

set rs=server.createobject("adodb.recordset") sql="select * from 表" rs.open sql,conn,1,1 if not(rs.bof and rs.eof) then while not rs.eof response.write rs("字段") rs.movenext wend end if其中rs.open sql,conn,1,1 中的conn为set conn=server.createobject("adodb.connection")不知道是不是你要的你没有说的太清楚

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 ）方法来更新数据记录。

　　 程序数据库类 　　 ASP与Access数据库连接 　　<%@ language=VBscript%>　　<%　　dim conn mdbfile　　mdbfile=server mappath( 数据库名称 mdb )　　set conn=server createobject( nnection )　　conn open driver={microsoft access driver 　　(* mdb)};uid=admin;pwd=数据库密码;dbq= &mdbfile　　%>　　 ASP与SQL数据库连接 　　<%@ language=VBscript%>　　<%　　dim conn　　set conn=server createobject( nnection )　　con open PROVIDER=SQLOLEDB;DATA 　　SOURCE=SQL服务器名称或IP地址;UID=sa;PWD=数据库密码;DATABASE=数据库名称　　%>　　　　 建立记录集对象 　　set rs=server createobject( adodb recordset )　　rs open SQL语句 conn 　　　　 SQL常用命令使用方法 　　( ) 数据记录筛选 　　sql= select * from 数据表 where 字段名=字段值 order by 字段名 [desc] 　　sql= select * from 数据表 where 字段名 like %字段值% order by 字段名 [desc] 　　sql= select top * from 数据表 where 字段名 order by 字段名 [desc] 　　sql= select * from 数据表 where 字段名 in ( 值 值 值 ) 　　sql= select * from 数据表 where 字段名 beeen 值 and 值 　　　　( ) 更新数据记录 　　sql= update 数据表 set 字段名=字段值 where 条件表达式 　　sql= update 数据表 set 字段 =值 字段 =值 …… 字段n=值n where 条件表达式 　　　　( ) 删除数据记录 　　sql= delete from 数据表 where 条件表达式 　　sql= delete from 数据表 (将数据表所有记录删除)　　　　( ) 添加数据记录 　　sql= insert into 数据表 (字段 字段 字段 …) values (值 值 值 …) 　　sql= insert into 目标数据表 select * from 源数据表 (把源数据表的记录添加到目标数据表)　　　　( ) 数据记录统计函数 　　AVG(字段名) 得出一个表格栏平均值　　COUNT(*|字段名) 对数据行数的统计或对某一栏有值的数据行数统计　　MAX(字段名) 取得一个表格栏最大的值　　MIN(字段名) 取得一个表格栏最小的值　　SUM(字段名) 把数据栏的值相加　　引用以上函数的方法 　　sql= select sum(字段名) as 别名 from 数据表 where 条件表达式 　　set rs=conn excute(sql)　　用 rs( 别名 ) 获取统的计值 其它函数运用同上 　　　　( ) 数据表的建立和删除 　　CREATE TABLE 数据表名称(字段 类型 (长度) 字段 类型 (长度) …… )　　例 CREATE TABLE tab (name varchar( ) datetime default now())　　　　DROP TABLE 数据表名称 (永久性删除一个数据表)　　 记录集对象的方法 　　rs movenext 将记录指针从当前的位置向下移一行　　rs moveprevious 将记录指针从当前的位置向上移一行　　rs movefirst 将记录指针移到数据表第一行　　rs movelast 将记录指针移到数据表最后一行　　rs absoluteposition=N 将记录指针移到数据表第N行　　rs absolutepage=N 将记录指针移到第N页的第一行　　rs pagesize=N 设置每页为N条记录　　rs pagecount 根据 pagesize 的设置返回总页数　　rs recordcount 返回记录总数　　rs bof 返回记录指针是否超出数据表首端 true表示是 false为否　　rs eof 返回记录指针是否超出数据表末端 true表示是 false为否　　rs delete 删除当前记录 但记录指针不会向下移动　　rs addnew 添加记录到数据表末端　　rs update 更新数据表记录　　 　　Recordset对象方法　　Open方法　　recordset Open Source ActiveConnection CursorType LockType Options　　Source　　Recordset对象可以通过Source属性来连接Command对象 Source参数可以是一个Command对象名称 一段SQL命令 一个指定的数据表名称或是一个Stored 　　Procedure 假如省略这个参数 系统则采用Recordset对象的Source属性 　　　　ActiveConnection　　Recordset对象可以通过ActiveConnection属性来连接Connection对象 这里的ActiveConnection可以是一个Connection对象或是一串包含数据库连接信息（ConnectionString）的字符串参数 　　　　CursorType　　Recordset对象Open方法的CursorType参数表示将以什么样的游标类型启动数据 包括adOpenForwardOnly adOpenKeyset adOpenDynamic及adOpenStatic 分述如下 　　 　　常数 常数值 说明　　 　　adOpenForwardOnly 缺省值 启动一个只能向前移动的游标（Forward Only） 　　adOpenKeyset 启动一个Keyset类型的游标 　　adOpenDynamic 启动一个Dynamic类型的游标 　　adOpenStatic 启动一个Static类型的游标 　　 　　以上几个游标类型将直接影响到Recordset对象所有的属性和方法 以下列表说明他们之间的区别 　　 　　Recordset属性 adOpenForwardOnly adOpenKeyset adOpenDynamic adOpenStatic　　 　　AbsolutePage 不支持 不支持 可读写 可读写　　AbsolutePosition 不支持 不支持 可读写 可读写　　ActiveConnection 可读写 可读写 可读写 可读写　　BOF 只读 只读 只读 只读　　Bookmark 不支持 不支持 可读写 可读写　　CacheSize 可读写 可读写 可读写 可读写　　CursorLocation 可读写 可读写 可读写 可读写　　CursorType 可读写 可读写 可读写 可读写　　EditMode 只读 只读 只读 只读　　EOF 只读 只读 只读 只读　　Filter 可读写 可读写 可读写 可读写　　LockType 可读写 可读写 可读写 可读写　　MarshalOptions 可读写 可读写 可读写 可读写　　MaxRecords 可读写 可读写 可读写 可读写　　PageCount 不支持 不支持 只读 只读　　PageSize 可读写 可读写 可读写 可读写　　RecordCount 不支持 不支持 只读 只读　　Source 可读写 可读写 可读写 可读写　　State 只读 只读 只读 只读　　Status 只读 只读 只读 只读　　AddNew 支持 支持 支持 支持　　CancelBatch 支持 支持 支持 支持　　CancelUpdate 支持 支持 支持 支持　　Clone 不支持 不支持　　Close 支持 支持 支持 支持　　Delete 支持 支持 支持 支持　　GetRows 支持 支持 支持 支持　　Move 不支持 支持 支持 支持　　MoveFirst 支持 支持 支持 支持　　MoveLast 不支持 支持 支持 支持　　MoveNext 支持 支持 支持 支持　　MovePrevious 不支持 支持 支持 支持　　NextRecordset 支持 支持 支持 支持　　Open 支持 支持 支持 支持　　Requery 支持 支持 支持 支持　　Resync 不支持 不支持 支持 支持　　Supports 支持 支持 支持 支持　　Update 支持 支持 支持 支持　　UpdateBatch 支持 支持 支持 支持　　 　　其中NextRecordset方法并不适用于Microsoft Access数据库 　　　　LockType　　Recordset对象Open方法的LockType参数表示要采用的Lock类型 如果忽略这个参数 那么系统会以Recordset对象的LockType属性为预设值 LockType参数包含adLockReadOnly adLockPrssimistic adLockOptimistic及adLockBatchOptimistic等 分述如下 　　 　　常数 常数值 说明　　 　　adLockReadOnly 缺省值 Recordset对象以只读方式启动 无法运行AddNew Update及Delete等方法　　adLockPrssimistic 当数据源正在更新时 系统会暂时锁住其他用户的动作 以保持数据一致性 　　adLockOptimistic 当数据源正在更新时 系统并不会锁住其他用户的动作 其他用户可以对数据进行增 删 改的操作 　　adLockBatchOptimistic 当数据源正在更新时 其他用户必须将CursorLocation属性改为adUdeClientBatch才能对数据进行增 删 改的操作 lishixinzhi/Article/program/SQLServer/201311/22247

Adodc1.Recordset.Open 执行语句, , , adLockBatchOptimistic用OPEN 的方法执行，LOCKTYPE 可以不设置，也可以设置 adLockBatchOptimistic！

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 ）方法来更新数据记录。

它所锁定的资源，其他事务不能读取也不能修改。独占锁不能和其他锁兼容。(4) 架构锁结构锁分为结构修改锁（Sch-M）和结构稳定锁（Sch-S）。执行表定义语言操作时，SQL Server采用Sch-M锁，编译查询时，SQL Server采用Sch-S锁。 (5) 意向锁意向锁说明SQL Server有在资源的低层获得共享锁或独占锁的意向。(6) 批量修改锁批量复制数据时使用批量修改锁1.3.4 SQL Server锁类型 (1) HOLDLOCK: 在该表上保持共享锁，直到整个事务结束，而不是在语句执行完立即释放所添加的锁。 (2) NOLOCK：不添加共享锁和排它锁，当这个选项生效后，可能读到未提交读的数据或“脏数据”，这个选项仅仅应用于SELECT语句。 (3) PAGLOCK：指定添加页锁（否则通常可能添加表锁）。 (4) READCOMMITTED用与运行在提交读隔离级别的事务相同的锁语义执行扫描。默认情况下，SQL Server 2000 在此隔离级别上操作。(5) READPAST: 跳过已经加锁的数据行，这个选项将使事务读取数据时跳过那些已经被其他事务锁定的数据行，而不是阻塞直到其他事务释放锁， READPAST仅仅应用于READ COMMITTED隔离性级别下事务操作中的SELECT语句操作。 (6) READUNCOMMITTED：等同于NOLOCK。 (7) REPEATABLEREAD：设置事务为可重复读隔离性级别。 (8) ROWLOCK：使用行级锁，而不使用粒度更粗的页级锁和表级锁。

隔离级别（推荐教程：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）：读写都会加锁

123456789101112131415 --查看被锁表： select request_session_id spid,OBJECT_NAME(resource_associated_entity_id) tableName from sys.dm_tran_locks where resource_type="OBJECT" --spid 锁表进程 --tableName 被锁表名 -- 解锁： declare @spid int Set @spid = 57 --锁表进程 declare @sql varchar(1000) set @sql="kill "+cast(@spid as varchar) exec(@sql)

rs("friend") = "值";

输出如下+---+| 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 || +----+----

回到目录 当数据表被事务锁定后，我们再进行select查询时，需要为with(锁选项)来查询信息，如果不加，select将会被阻塞，直到锁被释放，下面介绍几种SQL的锁选项 SQL的几把锁 NOLOCK（不加锁） 此选项被选中时，SQL Server 在读取或修改数据时不加任何锁 回到目录当数据表被事务锁定后，我们再进行select查询时，需要为with(锁选项)来查询信息，如果不加，select将会被阻塞，直到锁被释放，下面介绍几种SQL的锁选项SQL的几把锁NOLOCK（不加锁）此选项被选中时，SQL Server 在读取或修改数据时不加任何锁。 在这种情况下，用户有可能读取到未完成事务（Uncommited Transaction）或回滚(Roll Back)中的数据, 即所谓的“脏数据”。 HOLDLOCK（保持锁） 此选项被选中时，SQL Server 会将此共享锁保持至整个事务结束，而不会在途中释放。 UPDLOCK（修改锁） 此选项被选中时，SQL Server 在读取数据时使用修改锁来代替共享锁，并将此锁保持至整个事务或命令结束。使用此选项能够保证多个进程能同时读取数据但只有该进程能修改数据。 TABLOCK（表锁） 此选项被选中时，SQL Server 将在整个表上置共享锁直至该命令结束。 这个选项保证其他进程只能读取而不能修改数据。 PAGLOCK（页锁） 此选项为默认选项， 当被选中时，SQL Server 使用共享页锁。 TABLOCKX（排它表锁） 此选项被选中时，SQL Server 将在整个表上置排它锁直至该命令或事务结束。这将防止其他进程读取或修改表中的数据。 下面看一下.net frameworks平台关于事务级别的枚举，它对应于sql的事件级别namespace System.Transactions{ // 摘要: // Specifies the isolation level of a transaction. public enum IsolationLevel { // 摘要:序列化隔离级别，约束力最高，在数据集上放置一个范围锁，以防止其他用户在事务完成之前更新数据集或将行插入数据集内。 // 这是四个隔离级别中限制最大的级别。因为并发级别较低，所以应只在必要时才使用该选项。该选项的作用与在事务内所有 SELECT 语句中的所有表上设置 HOLDLOCK 相同。 // Volatile data can be read but not modified, and no new data can be added // during the transaction. Serializable = 0, // // 摘要:可重复读的隔离级别，可能出现幻读，锁定查询中使用的所有数据以防止其他用户更新数据，但是其他用户可以将新的幻像行插入数据集， // 且幻像行包括在当前事务的后续读取中。因为并发低于默认隔离级别，所以应只在必要时才使用该选项。 // Volatile data can be read but not modified during the transaction.New data // can be added during the transaction. RepeatableRead = 1, // // 摘要:不能读但可修改，可能出现不可重复读,指定在读取数据时控制共享锁以避免脏读，但数据可在事务结束前更改， // 从而产生不可重复读取或幻像数据。该选项是 SQL Server 的默认值。 // Volatile data cannot be read during the transaction, but can be modified. ReadCommitted = 2, // // 摘要:可以读也可以修改，可能出现脏数据,执行脏读或 0 级隔离锁定，这表示不发出共享锁，也不接受排它锁。 // 当设置该选项时，可以对数据执行未提交读或脏读；在事务结束前可以更改数据内的数值，行也可以出现在数据集中或从数据集消失。这是四个隔离级别中限制最小的级别。 // Volatile data can be read and modified during the transaction. ReadUncommitted = 3, // // 摘要:忽略数据的修改,得到修改前的数据 // Volatile data can be read.Before a transaction modifies data, it verifies // if another transaction has changed the data after it was initially read.If // the data has been updated, an error is raised.This allows a transaction to // get to the previously committed value of the data. Snapshot = 4, // // 摘要: // The pending changes from more highly isolated transactions cannot be overwritten. Chaos = 5, // // 摘要: // A different isolation level than the one specified is being used, but the // level cannot be determined.An exception is thrown if this value is set. Unspecified = 6, }}对于事务级别的总结下面是在嵌套事务中经常遇到的情况1 脏读：一个事务会读进还没有被另一个事务提交的数据，所以你会看到一些最后被另一个事务回滚掉的数据。2 读值不可复现：一个事务读进一条记录，另一个事务更改了这条记录并提交完毕，这时候第一个事务再次读这条记录时，它已经改变了。3 幻影读：一个事务用select子句来检索一个表的数据，另一个事务insert一条新的记录，并且符合select条件，这样，第一个事务用同一个select条件来检索数据后，就会多出一条记录。下面是IsolationLevel级别在使用过程中的一些说明（来自博文：http://www.cnblogs.com/CN5135/archive/2011/10/24/2222350.html）ReadCommitted： 假设A事务对正在读取数据Data放置了共享锁，那么Data不能被其它事务改写，所以当B事务对Data进行读取时总和A读取的Data数据是一致的，所以避免了脏读。由于在A没有提交之前可以对Data进行改写，那么B读取到的某个值可能会在其读取后被A更改从而导致了该值不能被重复取得；或者当B再次用相同的where字句时得到了和前一次不一样数据的结果集，也就是幻像数据。ReadUncommitted：假设A事务即不发布共享锁，也不接受独占锁，那么并发的B或者其它事务可以改写A事务读取的数据，那么并发的C事务读取到的数据的状态和A的或者B的数据都可能不一致，那么。脏读、不可重复读、幻象数据都可能存在。RepeatableRead：（注意MSDN原文中的第一句话：在查询中使用的所有数据上放置锁，所以不存在脏读的情况）。假设A事务对读取的所有数据Data放置了锁，以阻止其它事务对Data的更改，在A没有提交之前，新的并发事务读取到的数据如果存在于Data中，那么该数据的状态和A事务中的数据是一致的，从而避免了不可重复的读取。但在A事务没有结束之前，B事务可以插入新记录到Data所在的表中，那么其它事务再次用相同的where字句查询时，得到的结果数可能上一次的不一致，也就是幻像数据。Serializable： 在数据表上放置了排他锁，以防止在事务完成之前由其他用户更新行或向数据集中插入行，这是最严格的锁。它防止了脏读、不可重复读取和幻象数据。它的对应表如下：隔离级别脏读（Dirty Read）不可重复读（NonRepeatable Read）幻读（Phantom Read）读未提交（Read uncommitted） 可能 可能 可能 读已提交（Read committed） 不可能 可能 可能 可重复读（Repeatable read） 不可能 不可能 可能 可串行化（Serializable ） 不可能 不可能 不可能回到目录

(1)HOLDLOCK:在该表上保持共享锁，直到整个事务结束，而不是在语句执行完立即释放所添加的锁。(2)NOLOCK：不添加共享锁和排它锁，当这个选项生效后，可能读到未提交读的数据或“脏数据”，这个选项仅仅应用于SELECT语句。(3)PAGLOCK：指定添加页锁（否则通常可能添加表锁）。(4)READCOMMITTED用与运行在提交读隔离级别的事务相同的锁语义执行扫描。默认情况下，SQLServer2000在此隔离级别上操作。(5)READPAST:跳过已经加锁的数据行，这个选项将使事务读取数据时跳过那些已经被其他事务锁定的数据行，而不是阻塞直到其他事务释放锁，READPAST仅仅应用于READCOMMITTED隔离性级别下事务操作中的SELECT语句操作。(6)READUNCOMMITTED：等同于NOLOCK。(7)REPEATABLEREAD：设置事务为可重复读隔离性级别。(8)ROWLOCK：使用行级锁，而不使用粒度更粗的页级锁和表级锁。(9)SERIALIZABLE：用与运行在可串行读隔离级别的事务相同的锁语义执行扫描。等同于HOLDLOCK。(10)TABLOCK：指定使用表级锁，而不是使用行级或页面级的锁，SQLServer在该语句执行完后释放这个锁，而如果同时指定了...(1)HOLDLOCK:在该表上保持共享锁，直到整个事务结束，而不是在语句执行完立即释放所添加的锁。(2)NOLOCK：不添加共享锁和排它锁，当这个选项生效后，可能读到未提交读的数据或“脏数据”，这个选项仅仅应用于SELECT语句。(3)PAGLOCK：指定添加页锁（否则通常可能添加表锁）。(4)READCOMMITTED用与运行在提交读隔离级别的事务相同的锁语义执行扫描。默认情况下，SQLServer2000在此隔离级别上操作。(5)READPAST:跳过已经加锁的数据行，这个选项将使事务读取数据时跳过那些已经被其他事务锁定的数据行，而不是阻塞直到其他事务释放锁，READPAST仅仅应用于READCOMMITTED隔离性级别下事务操作中的SELECT语句操作。(6)READUNCOMMITTED：等同于NOLOCK。(7)REPEATABLEREAD：设置事务为可重复读隔离性级别。(8)ROWLOCK：使用行级锁，而不使用粒度更粗的页级锁和表级锁。(9)SERIALIZABLE：用与运行在可串行读隔离级别的事务相同的锁语义执行扫描。等同于HOLDLOCK。(10)TABLOCK：指定使用表级锁，而不是使用行级或页面级的锁，SQLServer在该语句执行完后释放这个锁，而如果同时指定了HOLDLOCK，该锁一直保持到这个事务结束。(11)TABLOCKX：指定在表上使用排它锁，这个锁可以阻止其他事务读或更新这个表的数据，直到这个语句或整个事务结束。(12)UPDLOCK：指定在读表中数据时设置更新锁（updatelock）而不是设置共享锁，该锁一直保持到这个语句或整个事务结束，使用UPDLOCK的作用是允许用户先读取数据（而且不阻塞其他用户读数据），并且保证在后来再更新数据时，这一段时间内这些数据没有被其他用户修改。

（推荐教程：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)数据，而另一个事务却在此时插入了新的几列数据，先前的事务在接下来的查询中，就会发现有几列数据是它先前所没有的。

第一个问题：新版本的mysql通过mvcc解决了幻读的问题，所以你没有看到的幻读现象第二个问题：B事务是没有办法看到A事务所做的改变，除非你的B事务的级别低于repeatable-read

一般用于此类语句中：select * from t with(NOLOCK)nolock是不加锁查询，可以读取被事务锁定的数据，也称为脏读。说明：使当前会话的查询，不受其它会话的事务所阻塞。但是这样做，就读取了其它事务的“修改后未提交的”数据。也就是允许“READ UNCOMMITTED”

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

set session tx_isolation="read-uncommitted"; ？