1.应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，如：
select id from t where num is null
可以在num上设置默认值0，确保表中num列没有null值，然后这样查询：
select id from t where num=0
2.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。优化器将无法通过索引来确定将要命中的行数,因此需要搜索该表的所有行。
3.应尽量避免在 where 子句中使用 or 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描，如：
select id from t where num=10 or num=20
可以这样查询：
select id from t where num=10
union all
select id from t where num=20
4.in 和 not in 也要慎用，因为IN会使系统无法使用索引,而只能直接搜索表中的数据。如：
select id from t where num in(1,2,3)
对于连续的数值，能用 between 就不要用 in 了：
select id from t where num between 1 and 3
5.尽量避免在索引过的字符数据中，使用非打头字母搜索。这也使得引擎无法利用索引。
见如下例子：
SELECT * FROM T1 WHERE NAME LIKE ‘%L%’
SELECT * FROM T1 WHERE SUBSTING(NAME,2,1)=’L’
SELECT * FROM T1 WHERE NAME LIKE ‘L%’
即使NAME字段建有索引，前两个查询依然无法利用索引完成加快操作，引擎不得不对全表所有数据逐条操作来完成任务。而第三个查询能够使用索引来加快操作。
6.必要时强制查询优化器使用某个索引，如在 where 子句中使用参数，也会导致全表扫描。因为SQL只有在运行时才会解析局部变量，但优化程序不能将访问计划的选择推迟到运行时；它必须在编译时进行选择。然而，如果在编译时建立访问计划，变量的值还是未知的，因而无法作为索引选择的输入项。如下面语句将进行全表扫描：
select id from t where num=@num
可以改为强制查询使用索引：
select id from t with(index(索引名)) where num=@num
7.应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如：
SELECT * FROM T1 WHERE F1/2=100
应改为:
SELECT * FROM T1 WHERE F1=100*2
SELECT * FROM RECORD WHERE SUBSTRING(CARD_NO,1,4)=’5378’
应改为:
SELECT * FROM RECORD WHERE CARD_NO LIKE ‘5378%’
SELECT member_number, first_name, last_name FROM members
WHERE DATEDIFF(yy,datofbirth,GETDATE()) > 21
应改为:
SELECT member_number, first_name, last_name FROM members
WHERE dateofbirth < DATEADD(yy,-21,GETDATE())
即：任何对列的操作都将导致表扫描，它包括数据库函数、计算表达式等等，查询时要尽可能将操作移至等号右边。
8.应尽量避免在where子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描。如：
select id from t where substring(name,1,3)='abc'--name以abc开头的id
select id from t where datediff(day,createdate,'2005-11-30')=0--‘2005-11-30’生成的id
应改为:
select id from t where name like 'abc%'
select id from t where createdate>='2005-11-30' and createdate<'2005-12-1'
9.不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。
10.在使用索引字段作为条件时，如果该索引是复合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用，并且应尽可能的让字段顺序与索引顺序相一致。
11.很多时候用 exists是一个好的选择：
elect num from a where num in(select num from b)
用下面的语句替换：
select num from a where exists(select 1 from b where num=a.num)
SELECT SUM(T1.C1)FROM T1 WHERE(
(SELECT COUNT(*)FROM T2 WHERE T2.C2=T1.C2>0)
SELECT SUM(T1.C1) FROM T1WHERE EXISTS(
SELECT * FROM T2 WHERE T2.C2=T1.C2)
两者产生相同的结果，但是后者的效率显然要高于前者。因为后者不会产生大量锁定的表扫描或是索引扫描。
Ⅱ MySQL大数据量分页查询方法及其优化
使用子查询优化大数据量分页查询
这种方式的做法是先定位偏移位置的id，然后再往后查询，适用于id递增的情况。
使用id限定优化大数据量分页查询
使用这种方式需要先假设数据表的id是连续递增的，我们根据查询的页数和查询的记录数可以算出查询的id的范围，可以使用 id between and 来查询：
当然了，也可以使用in的方式来进行查询，这种方式经常用在多表关联的情况下，使用其他表查询的id集合来进行查询：
但是使用这种in查询方式的时候要注意的是，某些MySQL版本并不支持在in子句中使用limit子句。
参考 sql优化之大数据量分页查询（mysql） - yanggb - 博客园 (cnblogs.com)
Ⅲ 数据库的多表大数据查询应如何优化
1.应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，如：x0dx0aselect id from t where num is nullx0dx0a可以在num上设置默认值0，确保表中num列没有null值，然后这样查询：x0dx0aselect id from t where num=0x0dx0a2.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。优化器将无法通过索引来确定将要命中的行数,因此需要搜索该表的所有行。x0dx0a3.应尽量避免在 where 子句中使用 or 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描，如：x0dx0aselect id from t where num=10 or num=20x0dx0a可以这样查询：x0dx0aselect id from t where num=10x0dx0aunion allx0dx0aselect id from t where num=20x0dx0a4.in 和 not in 也要慎用，因为IN会使系统无法使用索引,而只能直接搜索表中的数据。如：x0dx0aselect id from t where num in(1,2,3)x0dx0a对于连续的数值，能用 between 就不要用 in 了：x0dx0aselect id from t where num between 1 and 3x0dx0a5.尽量避免在索引过的字符数据中，使用非打头字母搜索。这也使得引擎无法利用索引。 x0dx0a见如下例子： x0dx0aSELECT * FROM T1 WHERE NAME LIKE ‘%L%’ x0dx0aSELECT * FROM T1 WHERE SUBSTING(NAME,2,1)=’L’ x0dx0aSELECT * FROM T1 WHERE NAME LIKE ‘L%’ x0dx0a即使NAME字段建有索引，前两个查询依然无法利用索引完成加快操作，引擎不得不对全表所有数据逐条操作来完成任务。而第三个查询能够使用索引来加快操作。x0dx0a6.必要时强制查询优化器使用某个索引，如在 where 子句中使用参数，也会导致全表扫描。因为SQL只有在运行时才会解析局部变量，但优化程序不能将访问计划的选择推迟到运行时；它必须在编译时进行选择。然而，如果在编译时建立访问计划，变量的值还是未知的，因而无法作为索引选择的输入项。如下面语句将进行全表扫描：x0dx0aselect id from t where num=@numx0dx0a可以改为强制查询使用索引：x0dx0aselect id from t with(index(索引名)) where num=@numx0dx0a7.应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如：x0dx0aSELECT * FROM T1 WHERE F1/2=100 x0dx0a应改为: x0dx0aSELECT * FROM T1 WHERE F1=100*2x0dx0aSELECT * FROM RECORD WHERE SUBSTRING(CARD_NO,1,4)=’5378’ x0dx0a应改为: x0dx0aSELECT * FROM RECORD WHERE CARD_NO LIKE ‘5378%’x0dx0aSELECT member_number, first_name, last_name FROM members x0dx0aWHERE DATEDIFF(yy,datofbirth,GETDATE()) > 21 x0dx0a应改为: x0dx0aSELECT member_number, first_name, last_name FROM members x0dx0aWHERE dateofbirth < DATEADD(yy,-21,GETDATE()) x0dx0a即：任何对列的操作都将导致表扫描，它包括数据库函数、计算表达式等等，查询时要尽可能将操作移至等号右边。x0dx0a8.应尽量避免在where子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描。如：x0dx0aselect id from t where substring(name,1,3)='abc'--name以abc开头的idx0dx0aselect id from t where datediff(day,createdate,-11-30')=0--‘2005-11-30’生成的idx0dx0a应改为:x0dx0aselect id from t where name like 'abc%'x0dx0aselect id from t where createdate>=-11-30' and createdate<-12-1'x0dx0a9.不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。x0dx0a10.在使用索引字段作为条件时，如果该索引是复合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用，并且应尽可能的让字段顺序与索引顺序相一致。x0dx0a11.很多时候用 exists是一个好的选择：x0dx0aelect num from a where num in(select num from b)x0dx0a用下面的语句替换：x0dx0aselect num from a where exists(select 1 from b where num=a.num)x0dx0aSELECT SUM(T1.C1)FROM T1 WHERE( x0dx0a(SELECT COUNT(*)FROM T2 WHERE T2.C2=T1.C2>0) x0dx0aSELECT SUM(T1.C1) FROM T1WHERE EXISTS( x0dx0aSELECT * FROM T2 WHERE T2.C2=T1.C2) x0dx0a两者产生相同的结果，但是后者的效率显然要高于前者。因为后者不会产生大量锁定的表扫描或是索引扫描。
Ⅳ 如何利用大数据更好地促进SEO优化服务
所汪高谓的大数据SEO，其实就是找热点，因为热点新闻、事件在搜索引擎的搜索量会相当高，在事件发生的那段有效时间内，大量的相关关键词会进入热搜，你可以把握这些关键词趋势，做一些半原创的新闻，这样会让搜索引擎对你的友好度上升。
如何把握热点事件呢，可以通过微博舆情大数据，网络搜野运索风云榜，腾讯舆情，头条指数，网络指数等综合颂陵梁分析，取一些跟自己领悟相关的新闻、热点事件进行聚合创作。长期下去搜索引擎必定给你很高的权重。
Ⅳ 大数据量实时统计排序分页查询 优化总结
大数据量实时统计排序分页查询 (并发数较小时) 的瓶颈不是函数（count，sum等）执行，
不是having, 也不是order by，甚至不是表join, 导致慢的原因就在于“数据量太大本身”
就是将表划分为M份相互独立的部分,可以是分表，也可以是不分表但冗余一个取模结果字段
实际结果是不分表比分表更加灵活，只需稍加配置，就可以动态切分大表，随意更改M的大小。
将1条慢sql（大于30秒）拆分成为N条查询速度巨快的sql(单条sql执行时间控制在20毫秒以内)
然后再web应用中以适当的线程数去并发查询这些执行时间快的N条小sql再汇总结果
第一步查询中去并发执行这N条小sql, 只取排序字段和标识字段，其他字段一律丢弃
汇总结果后定位出当前页面要显示的pageNum条数据，再进行第二步查询，取出页面上需要展示的所有字段
PS：这一点是至关重要的，其他几点都可以不看，这点是最关键的。慢慢解释一下：
a) 第一种方式是把数据库中所有记录（只取排序字段和标识字段并且不做任何sum，count having order by等操作）
全部拉到web应用中，在web应用中完成所有的计算
b) 第二种方式是把数据库中所有记录做sum count having等操作之后的所有行数拉到web应用中，在web应用中完成剩余计算
c) 第三种方式是把数据库中所有记录做sum count having order by等操作之后把limit后的数据拉到web应用中，
在web应用中对limit后的数据再计算
显然，第一种方式 数据库什么活都不做只取数据 是不可行的。以lg_order_count_seller为例，1500万行，
如果只算id, seller_id和order_count 这三个bigint类型，至少需要拉8*3*1500 0000 = 360000000=340M,
拉到内存中之后存储需要8*4*15000000= 460M,这还不算List是的2的n次方这个特点和计算排序等的内存开销，
不仅数据库与web应用机器IO扛不住，就是应用自身恐怕也要OOM了。
第二种方式，所有记录做sum count having等操作之后,由于是group by seller_id的，总得数据量变为100万（就是卖家总数），
这样子一来，共需要拉8*3*100 0000 = 23M,拉到内存之后，需要8*4*100 0000 = 30M, 再算上List是的2的n次方这个特点和
计算排序等的内存开销也不会超过100M, IO的时间和内存开销勉强可以考虑接受。
第三种方式，所有记录做sum count having order by等操作之后把limit后的数据拉到web应用中，因为做了limit，所以，
数据量很小了，无论是IO还是内存开销都已经很小了。可以忽略。
综合以上三种，第三种方式适用于页面的前n页和后n页，因为这个limit的数据量随着页数的增大而增大，
当大到每个切分后的小表的数据量时就转为第二种方式了。
第二种方式适用于页面的第[n+1, totaoPageNum-n]页。
切分成N条小sql后并行执行时排序不稳定性的解决办法
① 问题描述：
优化之前，还是是一条大慢sql查询时，由于数据库排序是稳定排序，
所以当两条记录排序字段值相同时他们在页面上的页码位置是固定的。
优化之后，当并行执行这N条小sql时，由于无法控制这些小sql的先后执行顺序，
导致在web应用中当两条记录的排序字段值相同时在页面上的页码位置是随机的。
② 解决办法：
除了拉标识字段(seller_id)和排序字段(order_count_sum)之外，再取一个unique（id）的字段，当两条记录的排序字段值相同时，再用这个unique的字段（在卖家监控中这个字段是id）进行第二次排序.这样就解决了排序不稳定的问题。
③ 也许，看到这里会有疑问，为什么不用seller_id？seller_id也是唯一， 这样子不是少取id这个字段，减少IO了？
seller_id虽然也是唯一，可以辅助排序，但是不要忘记数据库的排序规则是：
如果两列的值相等，那么序号在前的排在前面，这里的序号就是主键(自动生成，autoincrement),
如果用seller_id的话还是不能保证排序的稳定性，只能用主键id.
优先加载页面上的主要元素，然后再去异步加载次要元素，
反应在卖家监控页面中，查数据和查页页码的sql语句基本相同，是在竞争同一资源，
所以，需要做一个策略，优先把资源让给查数，数据查完之后再去查页码。
限流
由于多线程取数据并没有从本质上提高数据库性能，所以必须针对大数据量实时统计排序分页查询做限流
我这里打个比方：食堂有6个窗口，物流团队吃饭要买6个菜，平均每买1个菜需要1分钟的时间，
如果派我一个人去一个窗口买的话需要6分钟的时间
假如派6个人分别去6个窗口买这6个菜，只需要1分钟的时间
但是，如果除了物流团队，再来其他5个团队呢，也就是说6个团队每个团队买6个菜共买36个菜，
这样子有的团队先买完，有的团队后买完，但平均时间还是6分钟。本质上没有变化。
所以，对于特定的查询条件，必须进行限流。让每分钟至多有6个团队买菜，这样子能使得情况变得不至于太糟糕。
从根本上改变现状
这一点从目前来看只能是展望了，比如mysql数据库换更为强大的oracle数据库，
或更换InnoDb引擎为其他，或更换SATA硬盘为SSD 。。。。。。
从实践效果来看，优化后的效果是很明显的。
相同的查询条件，原来一个页面查询时间由于超过60秒超时了，根据1-6点建议优化之后，查询时间变为2秒至3.5秒之间。
Ⅵ 如何优化操作大数据量数据库
下面以关系数据库系统Informix为例，介绍改善用户查询计划的方法。
1．合理使用索引
索引是数据库中重要的数据结构，它的根本目的就是为了提高查询效率。现在大多数的数据库产品都采用IBM最先提出的ISAM索引结构。索引的使用要恰到好处，其使用原则如下：
●在经常进行连接，但是没有指定为外键的列上建立索引，而不经常连接的字段则由优化器自动生成索引。
●在频繁进行排序或分组（即进行group by或order by操作）的列上建立索引。
●在条件表达式中经常用到的不同值较多的列上建立检索，在不同值少的列上不要建立索引。比如在雇员表的“性别”列上只有“男”与“女”两个不同值，因此就无必要建立索引。如果建立索引不但不会提高查询效率，反而会严重降低更新速度。
●如果待排序的列有多个，可以在这些列上建立复合索引（pound index）。
●使用系统工具。如Informix数据库有一个tbcheck工具，可以在可疑的索引上进行检查。在一些数据库服务器上，索引可能失效或者因为频繁操作而使得读取效率降低，如果一个使用索引的查询不明不白地慢下来，可以试着用tbcheck工具检查索引的完整性，必要时进行修复。另外，当数据库表更新大量数据后，删除并重建索引可以提高查询速度。
2．避免或简化排序
应当简化或避免对大型表进行重复的排序。当能够利用索引自动以适当的次序产生输出时，优化器就避免了排序的步骤。以下是一些影响因素：
●索引中不包括一个或几个待排序的列；
●group by或order by子句中列的次序与索引的次序不一样；
●排序的列来自不同的表。
为了避免不必要的排序，就要正确地增建索引，合理地合并数据库表（尽管有时可能影响表的规范化，但相对于效率的提高是值得的）。如果排序不可避免，那么应当试图简化它，如缩小排序的列的范围等。
3．消除对大型表行数据的顺序存取
在嵌套查询中，对表的顺序存取对查询效率可能产生致命的影响。比如采用顺序存取策略，一个嵌套3层的查询，如果每层都查询1000行，那么这个查询就要查询10亿行数据。避免这种情况的主要方法就是对连接的列进行索引。例如，两个表：学生表（学号、姓名、年龄……）和选课表（学号、课程号、成绩）。如果两个表要做连接，就要在“学号”这个连接字段上建立索引。
还可以使用并集来避免顺序存取。尽管在所有的检查列上都有索引，但某些形式的where子句强迫优化器使用顺序存取。下面的查询将强迫对orders表执行顺序操作：
SELECT ＊ FROM orders WHERE (customer_num=104 AND order_num>1001) OR order_num=1008
虽然在customer_num和order_num上建有索引，但是在上面的语句中优化器还是使用顺序存取路径扫描整个表。因为这个语句要检索的是分离的行的 *** ，所以应该改为如下语句：
SELECT ＊ FROM orders WHERE customer_num=104 AND order_num>1001
UNION
SELECT ＊ FROM orders WHERE order_num=1008
这样就能利用索引路径处理查询。
4．避免相关子查询
一个列的标签同时在主查询和where子句中的查询中出现，那么很可能当主查询中的列值改变之后，子查询必须重新查询一次。查询嵌套层次越多，效率越低，因此应当尽量避免子查询。如果子查询不可避免，那么要在子查询中过滤掉尽可能多的行。
5．避免困难的正规表达式
MATCHES和LIKE关键字支持通配符匹配，技术上叫正规表达式。但这种匹配特别耗费时间。例如：SELECT ＊ FROM customer WHERE zipcode LIKE “98_ _ _”
即使在zipcode字段上建立了索引，在这种情况下也还是采用顺序扫描的方式。如果把语句改为SELECT ＊ FROM customer WHERE zipcode >“98000”，在执行查询时就会利用索引来查询，显然会大大提高速度。
另外，还要避免非开始的子串。例如语句：SELECT ＊ FROM customer WHERE zipcode[2，3]>“80”，在where子句中采用了非开始子串，因而这个语句也不会使用索引。
6．使用临时表加速查询
把表的一个子集进行排序并创建临时表，有时能加速查询。它有助于避免多重排序操作，而且在其他方面还能简化优化器的工作。例如：
SELECT cust.name，rcvbles.balance，……other columns
FROM cust，rcvbles
WHERE cust.customer_id = rcvlbes.customer_id
AND rcvblls.balance>0
AND cust.postcode>“98000”
ORDER BY cust.name
如果这个查询要被执行多次而不止一次，可以把所有未付款的客户找出来放在一个临时文件中，并按客户的名字进行排序：
SELECT cust.name，rcvbles.balance，……other columns
FROM cust，rcvbles
WHERE cust.customer_id = rcvlbes.customer_id
AND rcvblls.balance>0
ORDER BY cust.name
INTO TEMP cust_with_balance
然后以下面的方式在临时表中查询：
SELECT ＊ FROM cust_with_balance
WHERE postcode>“98000”
临时表中的行要比主表中的行少，而且物理顺序就是所要求的顺序，减少了磁盘I/O，所以查询工作量可以得到大幅减少。
注意：临时表创建后不会反映主表的修改。在主表中数据频繁修改的情况下，注意不要丢失数据。
7．用排序来取代非顺序存取
非顺序磁盘存取是最慢的操作，表现在磁盘存取臂的来回移动。SQL语句隐藏了这一情况，使得我们在写应用程序时很容易写出要求存取大量非顺序页的查询。
有些时候，用数据库的排序能力来替代非顺序的存取能改进查询。
实例分析
下面我们举一个制造公司的例子来说明如何进行查询优化。制造公司数据库中包括3个表，模式如下所示：
1．part表
零件号?????零件描述????????其他列
（part_num）?（part_desc）??????（other column）
102，032???Seageat 30G disk?????……
500，049???Novel 10M neork card??……
……
2．vendor表
厂商号??????厂商名??????其他列
（vendor _num）?（vendor_name） （other column）
910，257?????Seageat Corp???……
523，045?????IBM Corp?????……
……
3．parven表
零件号?????厂商号?????零件数量
（part_num）?（vendor_num）?（part_amount）
102，032????910，257????3,450,000
234，423????321，001????4，000，000
……
下面的查询将在这些表上定期运行，并产生关于所有零件数量的报表：
SELECT part_desc，vendor_name，part_amount
FROM part，vendor，parven
WHERE part.part_num=parven.part_num
AND parven.vendor_num = vendor.vendor_num
ORDER BY part.part_num
如果不建立索引，上述查询代码的开销将十分巨大。为此，我们在零件号和厂商号上建立索引。索引的建立避免了在嵌套中反复扫描。关于表与索引的统计信息如下：
表?????行尺寸???行数量?????每页行数量???数据页数量
（table）?(row size)?（Row count）?（Rows/Pages）?（Data Pages）
part????150?????10，000????25???????400
Vendor???150?????1，000???? 25???????40
Parven???13????? 15，000????300?????? 50
索引?????键尺寸???每页键数量???页面数量
（Indexes）?(Key Size)?（Keys/Page)???(Leaf Pages）
part?????4??????500???????20
Vendor????4??????500???????2
Parven????8??????250???????60
看起来是个相对简单的3表连接，但是其查询开销是很大的。通过查看系统表可以看到，在part_num上和vendor_num上有簇索引，因此索引是按照物理顺序存放的。parven表没有特定的存放次序。这些表的大小说明从缓冲页中非顺序存取的成功率很小。此语句的优化查询规划是：首先从part中顺序读取400页，然后再对parven表非顺序存取1万次，每次2页（一个索引页、一个数据页），总计2万个磁盘页，最后对vendor表非顺序存取1.5万次，合3万个磁盘页。可以看出在这个索引好的连接上花费的磁盘存取为5.04万次。
建议你直接用Jdbc好了，用batch，这样是最快的。
打开数据库
con.Open();
读取数据
OdbcDataReader reader = cmd.ExecuteReader();
把数据加载到临时表
dt.Load(reader);
在使用完毕之后，一定要关闭，要不然会出问题
reader.Close();
这个问题是这样的：
首先你要明确你的插入是正常业务需求么？如果是，那么只能接受这样的数据插入量。
其次你说数据库存不下了 那么你可以让你的数据库上限变大 这个你可以在数据库里面设置的 里面有个数据库文件属性 maxsize
最后有个方法可以使用，如果你的历史数据不会对目前业务造成很大影响 可以考虑归档处理 定时将不用的数据移入历史表 或者另外一个数据库。
注意平时对数据库的维护 定期整理索引碎片
时间维度分区表，然后定情按照规则将属于历史的分区数据迁移到，历史库上，写个存储自动维护分区表。
一次性插入大量数据，只能使用循环，
如：游标，while 循环语句
下面介绍While 循环插入数据，
SQL 代码如下：
IF OBJECT_ID('dbo.Nums') IS NOT NULL
DROP TABLE dbo.Nums;
GO
CREATE TABLE dbo.Nums(n INT NOT NULL PRIMARY KEY);
DECLARE @max AS INT, @rc AS INT;
SET @max = 5000000;
SET @rc = 1;
INSERT INTO Nums VALUES(1);
WHILE @rc * 2 <= @max
BEGIN
INSERT INTO dbo.Nums SELECT n + @rc FROM dbo.Nums;
SET @rc = @rc * 2;
END
INSERT INTO dbo.Nums SELECT n + @rc FROM dbo.Nums WHERE n + @rc <= @max;
--以上函数取自Inside SQL Server 2005: T-SQL Query一书。
INSERT dbo.Sample SELECT n, RAND(CAST(NEWID() AS BINARY(16))) FROM Nums
ini_set('max_execution_time',Ɔ');
$pdo = new PDO("mysql:host=localhost;dbname=test","root","123456");
$sql = "insert into test(name,age,state,created_time) values";
for($i=0; $i<100000; $i++){
$sql .="('zhangsan',21,1,-09-17')";
}
$sql = substr($sql,0,strlen($sql)-1);
var_mp($sql);
if($pdo -> exec($sql)){
echo "插入成功！";
echo $pdo -> lastinsertid();
}
试试吧。10万条1分钟多，我觉得还行
就是直接把DataSet 类型作为参数直接传递给服务端
WCF默认支持这么做，直接传Datatable不行。
你看一下 “服务引用设置”中你选的 *** 类型是什么，我选的是System.Array
字典 *** 类型是默认第一项 System.Collections.Generic.Dictionary
又是一个把自己架在火上烤的需求啊，
如果不考虑传输因素，可以调整wcf配置，提升传递的容量，如果是对象传递可能还要调整对象层次的深度
Ⅶ ES大数据量下的查询优化
filesystem类似于我们在mysql上建立一层redis缓存；
es的搜索引擎严重依赖于底层的filesystem cache，如果给filesystem cache更多的内存，尽量让内存可以容纳所有的indx segment file索引数据文件，那么你搜索的时候就基本都是走内存的，性能会非常高。
两者差距非常大，走磁盘和走systenfile cache的读取的性能差距可以说是秒级和毫秒级的差距了；
要让es性能要好，最佳的情况下，就是我们的机器的内存，至少可以容纳你的数据量的一半
最佳的情况下，是仅仅在es中就存少量的数据，存储要用来搜索的那些索引，内存留给filesystem cache的，如果就100G，那么你就控制数据量在100gb以内，相当于是，你的数据几乎全部走内存来搜索，性能非常之高，一般可以在1秒以内
的少数几个字段就可以了，比如说，就写入es id name age三个字段就可以了，然后你可以把其他的字段数据存在mysql里面，我们一般是建议用 es + hbase 的一个架构。
hbase的特点是适用于海量数据的在线存储，就是对hbase可以写入海量数据，不要做复杂的搜索，就是做很简单的一些根据id或者范围进行查询的这么一个操作就可以了
如果确实内存不足，但是我们又存储了比较多的数据，比如只有30g给systemfile cache，但是存储了60g数据情况，这种情况可以做数据预热；
我们可以将一些高频访问的热点数据（比如微博知乎的热榜榜单数据，电商的热门商品（旗舰版手机，榜单商品信息）等等）提前预热，定期访问刷到我们es里；（比如定期访问一下当季苹果旗舰手机关键词，比如现在的iphone12）
对于那些你觉得比较热的，经常会有人访问的数据，最好做一个专门的缓存预热子系统，就是对热数据，每隔一段时间，提前访问一下，让数据进入filesystem cache里面去。这样下次别人访问的时候，一定性能会好一些。
我们可以将冷数据写入一个索引中，然后热数据写入另外一个索引中，这样可以确保热数据在被预热之后，尽量都让他们留在filesystem os cache里，别让冷数据给冲刷掉。
尽量做到设计document的时候就把需要数据结构都做好，这样搜索的数据写入的时候就完成。对于一些太复杂的操作，比如join，nested，parent-child搜索都要尽量避免，性能都很差的。
es的分页是较坑的 ，为啥呢？举个例子吧，假如你每页是10条数据，你现在要查询第100页，实际上是会把 每个shard上存储的前1000条数据都查到 一个协调节点上，如果你有个5个shard，那么就有5000条数据，接着 协调节点对这5000条数据进行一些合并、处理，再获取到最终第100页的10条数据。
因为他是分布式的，你要查第100页的10条数据，你是不可能说从5个shard，每个shard就查2条数据？最后到协调节点合并成10条数据？这样肯定不行，因为我们从单个结点上拿的数据几乎不可能正好是所需的数据。我们必须得从每个shard都查1000条数据过来，然后根据你的需求进行排序、筛选等等操作，最后再次分页，拿到里面第100页的数据。
你翻页的时候，翻的越深，每个shard返回的数据就越多，而且协调节点处理的时间越长。非常坑爹。所以用es做分页的时候，你会发现越翻到后面，就越是慢。
我们之前也是遇到过这个问题，用es作分页，前几页就几十毫秒，翻到10页之后，几十页的时候，基本上就要5~10秒才能查出来一页数据了
你系统不允许他翻那么深的页，或者产品同意翻的越深，性能就越差
如果是类似于微博中，下拉刷微博，刷出来一页一页的，可以用scroll api
scroll api1 scroll api2
scroll会一次性给你生成所有数据的一个快照，然后每次翻页就是通过游标移动 ，获取下一页下一页这样子，性能会比上面说的那种分页性能也高很多很多
scroll的原理实际上是保留一个数据快照，然后在一定时间内，你如果不断的滑动往后翻页的时候，类似于你现在在浏览微博，不断往下刷新翻页。那么就用scroll不断通过游标获取下一页数据，这个性能是很高的，比es实际翻页要好的多的多。
缺点：
Ⅷ c# 如何提高大数据量查询速度
首先要优化查询语句，用不到的数据列尽量不要查。
然后是优化数据库，比如多建几个索引，专序列属化，应用存储过程等等。
最后是不要反复查数据库，会太慢，把查出的数据放到
XML中或是DataTable中，以后再用的时候直接到XML中去查，
这样会省出大量的时间。。。。。
Ⅸ mysql 大数据量查询如何优化，没办法去掉<>和like
其实你这个需要程序和数据库有一致的设计。可考虑分区。
通过电话前缀来分区，以下只是一个形式，不推荐用中文命名，
这样，只要用户不填写电话，那么前三字符就是xxx，自动会放入 ZFU区。
CREATE TABLE Customer
(
ID INT NOT NULL,
Mobile_PerNO CHAR(3) DEFAULT 'xxx',
Mobile VARCHAR(30)
)
PARTITION BY LIST(Mobile_PerNO)
PARTITION 联通186 VALUES IN (133),
PARTITION 移动139 VALUES IN (139),
PARTITION 电信133 VALUES IN (133),
PARTITION ZFU VALUES IN (xxx)
);
其次你过于依赖数据库而成形的程序，用点不客气的话说，那就是耦合极高的设计。
你其实完全可以在注册时，写入验证，一个手机号就能注册一次。左右打掉空格，这样手机上就能建立唯一索引。 使用LIKE ‘133%’ 至少性能上有一定的飞跃。
至于你的第二个SQL， 在时间和发送号码上可以建立索引，然后条件上写入时间。
也可以使用hash方式按照年季度分区。
理论上 性能提升百倍还是一点问题都没有的。
分区资料 看官方文档。
Ⅹ 如何使用大数据帮助搜索引擎优化
网站进行搜索引擎优化的方法是
1、程序优化。编程者在开发程序的时候，尽量不使用非常用算法，不要出现代码错误，不要使程序机构混乱不堪。少使用FRAME框架结构，少使用图片、FLASH表达内容。还有的就是，要在程序源代码里要有“关键字”“描述”功能。语言结构简化，好使用 CSS+DIV方式，而不是原先老旧的TABLE表格式。
2、网站做成静态或者伪静态的。由于搜索引擎对现实存在的网页内容，容易搜索到，而对于数据库里的东西，很难搜索到，所以好把页面做成静态的。当然，现在的网站很多是伪静态的，这个我在这里就不多说了。
3、关键字词的密度和出现的位置。你的整体内容内应该包含有你内容关键字词