iterate语句的作用（mysql之游标）

本文目录

• mysql之游标
• 在mysql语句中为什么要加反引号
• List和Iterator在用hibernate查询时候的区别
• 什么是C++的迭代器Interator
• iterate和find有什么区别

mysql之游标

游标：能够对结果集中的每一条记录进行定位，并对指向的记录中的数据进行操作的数据结构。
创建游标： CREATE FUNCTION 函数名称 （参数）RETURNS 数据类型 程序体
存储过程中使用游标的4个步骤：定义游标、打开游标、读取游标数据和关闭游标。
定义游标： DECLARE 游标名 CURSOR FOR 查询语句
打开游标： OPEN 游标名称；
读取游标数据： FETCH 游标名 INTO 变量列表；
关闭游标： CLOSE 游标名；
条件处理语句： DECLARE 处理方式 HANDLER FOR 问题 操作；
流程控制语句：跳转语句(ITERATE语句和LEAVE语句)、循环语句（LOOP、WHILE、REPEAT）、条件判断语句（IF语句和CASE语句）

创建游标： CREATE FUNCTION 函数名称 （参数）RETURNS 数据类型 程序体
存储函数与存储过程很像，但有几个不同点：
1、存储函数必须返回一个值或者数据表，存储过程可以不返回。
2、存储过程可以通过CALL语句调用，存储函数不可以
3、存储函数可以放在查询语句中使用，存储过程不可以
4、存储过程的功能更强大，包括能够执行对表的操作（比如创建表、删除表等）和事务操作

游标操作步骤包含4个：定义游标、打开游标、读取游标数据和关闭游标。
1、创建存储过程

在mysql语句中为什么要加反引号

Select * from `member` order by posts desc limit 0,10;
它是为了区分MYSQL的保留字与普通字符而引入的符号。
举个例子：SELECT `select` FROM `test` WHERE select=‘字段值‘
在test表中，有个select字段，如果不用反引号，MYSQL将把select视为保留字而导致出错，所以，有MYSQL保留字作为字段的，必须加上反引号来区分。
引号一般用在字段的值,如果字段值是字符或字符串，则要加引号，如：select=‘字段值‘
不加反引号建的表不能包含MYSQL保留字，否则出错
反引号`，数字1左边的符号。
保留字不能用于表名，比如desc，此时需要加入反引号来区别，但使用表名时可忽略反引号。
create table desc报错
create table `desc`成功
create table `test`成功
drop table test成功
保留字不能用于字段名，比如desc，此时也需要加入反引号，并且insert等使用时也要加上反引号。
create table `test`（`desc` varchar(255)）成功
insert into test(desc) values(‘fxf‘)失败
insert into test(`desc`) values(‘fxf‘)成功
mysql常见的保留字
使用mysql时一定要注意，不要使用它的保留字作为表名或者列名，否则会出现莫名其妙的错误。
昨天建了一个表，其中一列名为interval(时间间隔)，结果数据死都插不进去，最后才发现原来interval是mysql的保留字。
以后出现类似的错误要先想想是不是因为表名或列名冲突造成的啊。
从网上找了一个mysql的保留字列表，仅供参考。
ADD
ALL
ALTER
ANALYZE
AND
AS
ASC
ASENSITIVE
BEFORE
BETWEEN
BIGINT
BINARY
BLOB
BOTH
BY
CALL
CASCADE
CASE
CHANGE
CHAR
CHARACTER
CHECK
COLLATE
COLUMN
CONDITION
CONNECTION
CONSTRAINT
CONTINUE
CONVERT
CREATE
CROSS
CURRENT_DATE
CURRENT_TIME
CURRENT_TIMESTAMP
CURRENT_USER
CURSOR
DATABASE
DATABASES
DAY_HOUR
DAY_MICROSECOND
DAY_MINUTE
DAY_SECOND
DEC
DECIMAL
DECLARE
DEFAULT
DELAYED
DELETE
DESC
DESCRIBE
DETERMINISTIC
DISTINCT
DISTINCTROW
DIV
DOUBLE
DROP
DUAL
EACH
ELSE
ELSEIF
ENCLOSED
ESCAPED
EXISTS
EXIT
EXPLAIN
FALSE
FETCH
FLOAT
FLOAT4
FLOAT8
FOR
FORCE
FOREIGN
FROM
FULLTEXT
GOTO
GRANT
GROUP
HAVING
HIGH_PRIORITY
HOUR_MICROSECOND
HOUR_MINUTE
HOUR_SECOND
IF
IGNORE
IN
INDEX
INFILE
INNER
INOUT
INSENSITIVE
INSERT
INT
INT1
INT2
INT3
INT4
INT8
INTEGER
INTERVAL
INTO
IS
ITERATE
JOIN
KEY
KEYS
KILL
LABEL
LEADING
LEAVE
LEFT
LIKE
LIMIT
LINEAR
LINES
LOAD
LOCALTIME
LOCALTIMESTAMP
LOCK
LONG
LONGBLOB
LONGTEXT
LOOP
LOW_PRIORITY
MATCH
MEDIUMBLOB
MEDIUMINT
MEDIUMTEXT
MIDDLEINT
MINUTE_MICROSECOND
MINUTE_SECOND
MOD
MODIFIES
NATURAL
NOT
NO_WRITE_TO_BINLOG
NULL
NUMERIC
ON
OPTIMIZE
OPTION
OPTIONALLY
OR
ORDER
OUT
OUTER
OUTFILE
PRECISION
PRIMARY
PROCEDURE
PURGE
RAID0
RANGE
READ
READS
REAL
REFERENCES
REGEXP
RELEASE
RENAME
REPEAT
REPLACE
REQUIRE
RESTRICT
RETURN
REVOKE
RIGHT
RLIKE
SCHEMA
SCHEMAS
SECOND_MICROSECOND
SELECT
SENSITIVE
SEPARATOR
SET
SHOW
SMALLINT
SPATIAL
SPECIFIC
SQL
SQLEXCEPTION
SQLSTATE
SQLWARNING
SQL_BIG_RESULT
SQL_CALC_FOUND_ROWS
SQL_SMALL_RESULT
SSL
STARTING
STRAIGHT_JOIN
TABLE
TERMINATED
THEN
TINYBLOB
TINYINT
TINYTEXT
TO
TRAILING
TRIGGER
TRUE
UNDO
UNION
UNIQUE
UNLOCK
UNSIGNED
UPDATE
USAGE
USE
USING
UTC_DATE
UTC_TIME
UTC_TIMESTAMP
VALUES
VARBINARY
VARCHAR
VARCHARACTER
VARYING
WHEN
WHERE
WHILE
WITH
WRITE
X509
XOR
YEAR_MONTH
ZEROFILL
注：MySQL允许部分关键字用做未引起来的识别符，因为许多人以前曾使用过它们。如：ACTION、BIT、DATE、ENUM、NO、TEXT、TIME、TIMESTAMP
所以为了安全起见可以在表名和字段名上都加上``。
在mysql语句中为什么要加反引号
标签：bodytimeinfarchascmsucapewarningstart

List和Iterator在用hibernate查询时候的区别

List和Iterator的区别
让我们先运行一下代码
实例：public void fillAll(){
Session session=HibernateUtil.getSession();
Query query=session.createQuery("from Customers");
List《Customers》 list=query.list();
for(Customers l:list){
System.out.println(l.getEmail());
}
执行结果：Hibernate: selectcustomers0_.id as id0_, customers0_.realName as realName0_, customers0_.pass aspass0_, customers0_.sex as sex0_, customers0_.petName as petName0_,customers0_.email as email0_, customers0_.rdate as rdate0_ from Customers customers0_
null
asd
null
}
@Test
public void fillA(){
Session session=HibernateUtil.getSession();
Query query=session.createQuery("from Customers");
Iterator《Customers》 it=query.iterate();
while(it.hasNext()){
Customers c=(Customers) it.next();
System.out.println(c.getEmail());
}
}
执行结果：Hibernate: select customers0_.id as col_0_0_ from Customers customers0_
Hibernate: selectcustomers0_.id as id0_0_, customers0_.realName as realName0_0_,customers0_.pass as pass0_0_, customers0_.sex as sex0_0_, customers0_.petNameas petName0_0_, customers0_.email as email0_0_, customers0_.rdate as rdate0_0_from Customers customers0_ where customers0_.id=?
null
Hibernate: selectcustomers0_.id as id0_0_, customers0_.realName as realName0_0_,customers0_.pass as pass0_0_, customers0_.sex as sex0_0_, customers0_.petNameas petName0_0_, customers0_.email as email0_0_, customers0_.rdate as rdate0_0_from Customers customers0_ where customers0_.id=?
asd
Hibernate: selectcustomers0_.id as id0_0_, customers0_.realName as realName0_0_,customers0_.pass as pass0_0_, customers0_.sex as sex0_0_, customers0_.petNameas petName0_0_, customers0_.email as email0_0_, customers0_.rdate as rdate0_0_from Customers customers0_ where customers0_.id=?
Null
很明显的看出：Iterator输入的sql语句多：N+1条语句
总结:
Query的两个方法，list()和 iterate() ， 两个方法都是把结果集列出来， 他们有3点不一样，
1：返回的类型不一样，list()返回List,iterate()返回Iterator,
2: 获取数据的方式不一样，list()会直接查数据库,iterate()会先到数据库中把id都取出来，然后真正要遍历某个对象的时候先到缓存中找,如果找不到,以id为条件再发一条sql到数据库,这样如果缓存中没有数据,则查询数据库的次数为n+1。
3：iterate会查询2级缓存，　list只会查询一级缓存。
4: list()中返回的List中每个对象都是原本的对象,iterate()中返回的对象是代理对象.(debug可以发现)
list()方法在执行时，直接运行查询结果所需要的查询语句。
iterator()方法则是先执行得到对象ID的查询，然后在根据每个ID值去取得所要查询的对象。
因此：对于list()方式的查询通常只会执行一个SQL语句，而对于iterator()方法的查询则可能需要执行N+1条SQL语句(N为结果集中的记录数).
结果集的处理方法不同:
list()方法会一次取出所有的结果集对象，而且他会依据查询的结果初始化所有的结果集对象。如果在结果集非常庞大的时候会占据非常多的内存，甚至会造成内存溢出的情况发生。
iterator()方法在执行时不会一次初始化所有的对象，而是根据对结果集的访问情况来初始化对象。一次在访问中可以控制缓存中对象的数量，以避免占用过多的缓存，导致内存溢出情况的发生。
如果数量巨大的话，建议用iterator

什么是C++的迭代器Interator

容器就是数据结构的泛指，迭代器就是指针的泛指，可以指向元素。容器相当于一个储藏柜，里面装的许多不同的物品就像是储存的元素，比如面包、啤酒、苹果、现金。要取得各个物体就得用与各个物体向匹配的工具，如取出面包要用盘子、取出啤酒要用杯子、取出苹果要用篮子、取出现金要用钱包。迭代器的作用就相当于取出物品的工具的抽象，通过迭代器泛指现实生活中从贮藏室中取出物体的工具。C++迭代器是一种检查容器内元素并遍历元素的数据类型。1 Iterator definitionsIn C++, an iterator is any object that, pointing to some element in a range of elements (such as an array or a container), has the ability to iterate through the elements of that range using a set of operators (at least, the increment (++) and dereference (*) operators).The most obvious form of iterator is a pointer: A pointer can point to elements in an array, and can iterate through them using the increment operator (++). But other forms of iterators exist. For example, each container type (such as a vector) has a specific iterator type designed to iterate through its elements in an efficient way.C++迭代器Interator就是一个指向某种STL对象的指针。通过该指针可以简单方便地遍历所有元素。 C++中的iterator为STL中的重要概念。iterator的概念源自于对遍历一个线性容器工具的抽象，即如何你能访问这个容器的某个元素。对于最简单的数组，当然可以用数组的索引值，因为数组是连续存放在内存中的；但对于链表，就必须用指针。除此之外，还有还有很多种数据结构需要提供一个方便的工具来访问其中的元素，方法有ID，关键字等等。为了统一所有的容器的这种工具的使用，一般提供一整套容器的开发者就会用一种方式来表示各种容器的访问工具。例如C＋＋ STL就是使用iterator。MFC自己的容器使用position。C#和java也有自己的方法，但方法是不变的。 iterator的用法可以被统一，但不同的底层容器实现其iterator的原理是不一样的。例如iterator++你可以理解为移动到容器的下一个元素，如果底层如果是数组，把索引值加一就行；如果底层是链表，就得执行类似于m_pCurrent = m_pCurrent-》 pNext;的操作。因此每种容器都有自己的iterator实现方法。C++ STL iterator的常用方法有：iterator++ 移到下个元素iterator-- 移到上个元素*iterator 访问iterator所指元素的值《 》 == != iterator之间的比较，例如判断哪个元素在前iterator1 + iterator2 iterator之间的加法运算，类似于指针加法 2 容器的 iterator 类型每种容器类型都定义了自己的C++迭代器类型，如 vector：vector《int》::iterator iter;这符语句定义了一个名为 iter 的变量，它的数据类型是 vector《int》 定义的 iterator 类型。每个标准库容器类型都定义了一个名为 iterator 的成员，这里的 iterator 与迭代器实际类型的含义相同。begin 和 end 操作每种容器都定义了一对命名为 begin 和 end 的函数，用于返回迭代器。如果容器中有元素的话，由 begin 返回的迭代器指向第一个元素： vector《int》::iterator iter = ivec.begin();上述语句把 iter 初始化为由名为 vector 操作返回的值。假设 vector 不空，初始化后，iter 即指该元素为ivec 就是指向同一个元素。上面这个语句的效果就是把这个元素的值赋为 0。迭代器使用自增操作符向前移动迭代器指向容器中下一个元素。从逻辑上说，C++迭代器的自增操作和int 型对象的自增操作类似。对 int 对象来说，操作结果就是把 int 型值“加 1”，而对迭代器对象则是把容器中的迭代器“向前移动一个位置”。因此，如果 iter 指向第一个元素，则 ++iter 指向第二个元素。由于 end 操作返回的迭代器不指向任何元素，因此不能对它进行解引用或自增操作。

iterate和find有什么区别

在hibernate当中重点比较了find及iterate的使用，主要是他们在查询数据时的优劣势的比较，而由session.find()方法也引申出了query cache这个概念及对find在查询时的劣势的解闷方案。虽然query cache在使用上还是有很多的局限，但是它对提高find的性能起到了很大的作用。
在Hibernate2.0当中使用：session.find(),session.iterate(),而hibernate3.0当中使用的是query.find(),query.iterate()来代替。
下面我们着重分析一下这两个方法的使用：
1. 如果我们在使用find,iterate进行查询时分别构建他们的HQL，那么我们在控制台输出当中看到iterate()方法所使用的SQL语句的次数要远远超过Find()。
但是，为什么iterate()还存在呢？
2. 当我们在使用find构建HQL后，而同样的查询也让iterate()来执行一次的话(前提是必须使用find()构建的HQL),那么iterate()的执行并不再像前面介绍的那样会比find()方法多执行SQL，而是根本再执行一条SQL。这就是iterate()方法的使用。它使用了Hibernate缓存机制.Find()方法在查询出结果后把查询结果集置入缓存，而iterate()执行的时候先执行一条Select SQL,查询所有符合条件的结果集，接下来iterate()根据查询的id在本地缓存中查找符合条件的结果集，如果有完全符合条件的结果集，则直接以此作为返回结果。如果没有找到再执行相应的SQL,并且把结果纳入缓存当中。以备使用
3.缓存机制并不对find()方法起使用。如果你两次执行相同条件的或相近条件的HQL，第二个方法的SQL并不减少。还会照常执行。这就是说缓存机制并不对find()方法起作用。find()对缓存只写不读，而iterate()方法就可以充分利用缓存的优势。
4.内存方面的考虑，除了缓存的优势之外，我们还可以利用iterate()与evict()方法来提升查询性能上的优势。
这个问题主要是大数据量所带来的考虑。因为find()方法可以对大数据量的结果集进行缓存，但是如果数据量超大的话，也会带来内存溢出方面的问题。利用iterate(),evict()可以对记录进行逐条处理，将内存消耗保持在可接受的范围之内。
它包括从session中消除对对象，及从sessionFactory当中消除对象。
5. 对于find()方法在读取缓存问题方面的解决。Query Cache是一个解决方案，不过目前的使用受限比较大。
使用Query Cache的条件是：
A。数据库表结构不变。即未发生过update,insert,delete等操作
B。相同的HSQL的重复执行操作。
由于以上两个原因，query Cache的使用上受到了很大 的限制。
如果想使用query cache我们需要配置 hibernate.cfg.xml文件：
《class ......》
《property nam="hibernate,cache.use_query_cache"》True《/property》
《/class》
在编码当中使用：Query.setQueryCache(true);即可。