精华内容
下载资源
问答
  • 下面小编就为大家带来一篇explain分析sql效率的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 提高SQL效率

    2008-07-15 09:34:11
    提高SQL效率////提高SQL效率
  • 优化SQL效率

    2013-09-06 10:05:15
    优化SQL语句提高oracle执行效率(34种方法),提高你的sql执行效率,特别针对大数据。
  • ORACLE+SQL效率优化.rar

    2008-12-09 10:07:52
    ORACLE+SQL效率优化.rar,详细讲解oracle中sql语句效率优化方法和注意事项。
  • 项目开发初期,业务数据量相对较少,一些SQL的执行效率对程序运行效率影响不太明显,随着时间的积累,业务数据量越来越多,sql的执行效率对程序的运行效率影响越来越大,此时对sql的有效就很有必须,来提升整体程序...

    为什么要进行sql的优化

    项目开发初期,业务数据量相对较少,一些SQL的执行效率对程序运行效率影响不太明显,随着时间的积累,业务数据量越来越多,sql的执行效率对程序的运行效率影响越来越大,此时对sql的有效就很有必须,来提升整体程序的运行效率。

    什么情况会导致sql执行效率低及优化方式

    1、首先尽量避免全表查询,在sql中where及order by设计的列上建立索引
    2、尽量避免where语句中对字段进行null判断,否则将放弃使用索引而进行全表扫描。
    如:select id from where num is null
    或可以建表时设置num列的默认值是0,确保表中num列没有null值,然后可以这么查询:
    select id from t where num=0。这样不会放弃索引
    3、尽量避免wherer语句后使用!=或者<>操作符,否则将导致放弃索引而进行全表扫描
    4、应该尽量避免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;
    5、in和not in也要慎用,否则会进行全表查找。比如:
    select id from t where num in(1,2,3)
    对于连续的数值,能用between就不要用in,改写如下:
    select id from t where num between 1 and 3。
    6、使用like,也会进行全表扫描,比如:
    select id from t where name like ‘%abc%’
    7、应避免在where子句中对字段进行表达式操作,这样导致引擎放弃使用索引而进行全表查询,比如:
    select id from t where num/2=100
    应该为:
    select id from t where num=1002
    8、应尽量避免where字句中对字段进行函数操作,这样会导致引擎放弃索引而进行全表扫描。比如:
    select id from t where substring(name,1,3)=‘abc’
    可以改为:
    select id from t where name like ‘abc%’
    9、不要在where子句中“=”左边进行函数、算术运算或者表达式运算,否则系统安静无法正确使用所以。
    10、在使用索引字段作为条件时,如果该索引是复合索引,那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引,否则该索引不会被使用,并且应该尽可能让字段顺序与索引顺序相一致。
    11、不要写没有意义的查询,如果需要生成一个空表结构:
    select col1,col2 into #t from t where 1=0;
    这类代码不会返回任何结果集,但是会消耗系统资源,应该改为这样:
    create table #t(…)
    12、很多时候用exist是代替in是一个好的选择
    select num frim a where num in (select num from b)
    用下面语句进行替换:
    select num frm a where exists(select 1 from b where num =a.num)
    13、并不是所有索引都对查询都有效,SQL是根据表中数据来进行优化查询的,当索引列有大量数据重复时,SQL查询核能不会去利用索引,。比如一表中有字段sex时,男或女几乎各占一半,那么即使在sex上建立索引也不会对查询起到作用。
    14、索引并不是越多越好,索引固然可以提升相应的select的效率,同时会降低insert及Updata的效率。
    因为insert或者update是会重建索引,索引怎样建索引慎重考虑,视具体情况而定。一个表的索引最好不要超过6个。不要在不常用的列上面建索引。
    15、尽量使用数字型字段,若只包含数值信息的字段尽量不要设计为字符型,这样会降低查询和连接性能,并会增加存储开销。
    这是因为引擎在处理查询和连接时会逐个比较字符串中每个字符,而对数字型而言只需要比较一次就够了。
    16、尽可能的使用varchar代替char,因为首先变长字段存储空间小,可以节省存储空间。
    其次对于查询来说,相对于较小的字段内搜索效率明显提高。
    17、任何地方不要使用select * from t,用到具体字段代替"
    ",不要返回用不到的任何字段来提升效率
    18、避免频繁创建和删除临时表,以减少系统表资源的消耗。
    19、临时表并不是不可以使用,适当的使用他们可以使某些进程更加有效,例如:当需要重复引用到大型表或者常用表的某个数据集时。
    20、在新建临时表时,如果一次性插入数据量很大,那么就可以使用select into代替create table,避免生成大量log,如果一次性插入数据量不大,为了缓和系统表资源,应该先create table,然后insert。
    21、如果使用到临时表,在存储过程最后务必将所有临时表显示删除,先truncate table,然后再drop table,这样可以避免系统表的较长时间锁定。
    22、尽量避免使用游标,因为游标的效率较差,如果游标操作的数据超过1万行,那么就应该考虑改写。
    23、使用基于游标的方法或临时表方法之前,应先寻找基于集的解决方案来解决问题,基于集的方法通常更有效。
    24、与临时表一样,游标并不是不可使用。对小型数据集使用 FAST_FORWARD 游标通常要优于其他逐行处理方法,尤其是在必须引用几个表才能获得所需的数据时。
    在结果集中包括“合计”的例程通常要比使用游标执行的速度快。如果开发时间允许,基于游标的方法和基于集的方法都可以尝试一下,看哪一种方法的效果更好。
    25、尽量避免大事务操作,提高系统并发能力。
    26、尽量避免向客户端返回大数据量,若数据量过大,应该考虑相应需求是否合理。

    展开全文
  • 事务提交5000条update,耗时:13.79 秒,内存占用:17.88 MB(大量时间消耗在Query生成sql语句上) $startTime = microtime(true); $startMemory = memory_get_usage(); $transaction = \Yii::$app->db->begin...
    事务提交5000条update,耗时:13.79 秒,内存占用:17.88 MB(大量时间消耗在Query生成sql语句上)

    $startTime  = microtime(true);
    $startMemory = memory_get_usage();
    $transaction = \Yii::$app->db->beginTransaction();
    for($i=0; $i< 5000; ++$i) {
        \Yii::$app->db->createCommand()->update(UserMenu::tableName(), ['menu_id' => 4], ['user_id' => $id, 'menu_id' => 3])->execute();
    }
    $transaction->commit();
    $endTime    = microtime(true);
    $runtime    = number_format($endTime - $startTime, 2); //秒
    $endMemory  = memory_get_usage();
    $usedMemory = number_format(($endMemory - $startMemory) / 1024 / 1024, 2);    //MB
    
    echo("耗时:$runtime 秒,内存占用:$usedMemory MB");

    事务提交5000条update,耗时:9.59 秒,内存占用:16.66 MB(一次性生成sql语句)

    $transaction = \Yii::$app->db->beginTransaction();
    $sql = \Yii::$app->db->createCommand()->update(UserMenu::tableName(), ['menu_id' => 4], ['user_id' => $id, 'menu_id' => 3])->getRawSql().';';
    $startTime  = microtime(true);
    $startMemory = memory_get_usage();
    for($i=0; $i< 5000; ++$i) {
        \Yii::$app->db->createCommand($sql)->execute();
    }
    $transaction->commit();
    
    $endTime    = microtime(true);
    $runtime    = number_format($endTime - $startTime, 2); //秒
    $endMemory  = memory_get_usage();
    $usedMemory = number_format(($endMemory - $startMemory) / 1024 / 1024, 2);    //MB
    
    
    echo("耗时:$runtime 秒,内存占用:$usedMemory MB");
    
    

    合并sql提交5000条update,耗时:13.05 秒,内存占用:0.37 MB(主要时间都耗在Query生成sql语句上了)

    $startTime  = microtime(true);
    $startMemory = memory_get_usage();
    $transaction = \Yii::$app->db->beginTransaction();
    $sql = '';
    for($i=0; $i< 5000; ++$i) {
        $sql .= \Yii::$app->db->createCommand()->update(UserMenu::tableName(), ['menu_id' => 4], ['user_id' => $id, 'menu_id' => 3])->getRawSql().';';
    }
    \Yii::$app->db->createCommand($sql)->execute();
    $transaction->commit();
    $endTime    = microtime(true);
    $runtime    = number_format($endTime - $startTime, 2); //秒
    $endMemory  = memory_get_usage();
    $usedMemory = number_format(($endMemory - $startMemory) / 1024 / 1024, 2);    //MB
    
    
    echo("耗时:$runtime 秒,内存占用:$usedMemory MB");
    
    

    合并sql提交5000条update,耗时:4.84 秒,内存占用:0.00 MB(一次性生成sql语句)

    $transaction = \Yii::$app->db->beginTransaction();
    $sql = '';
    for($i=0; $i< 5000; ++$i) {
        $sql .= \Yii::$app->db->createCommand()->update(UserMenu::tableName(), ['menu_id' => 4], ['user_id' => $id, 'menu_id' => 3])->getRawSql().';';
    }
    $startTime  = microtime(true);
    $startMemory = memory_get_usage();
    \Yii::$app->db->createCommand($sql)->execute();
    $transaction->commit();
    $endTime    = microtime(true);
    $runtime    = number_format($endTime - $startTime, 2); //秒
    $endMemory  = memory_get_usage();
    $usedMemory = number_format(($endMemory - $startMemory) / 1024 / 1024, 2);    //MB
    
    
    echo("耗时:$runtime 秒,内存占用:$usedMemory MB");
    
    
    展开全文
  • hive子查询sql效率优化

    千次阅读 2018-03-21 19:27:12
    今天写了个sql跑了好久,老大过来一看指点下,多用子查询,多用where,然后在join, 提高十多倍,神奇了。想了想,还是老大经验丰富。 如果先join,就全表扫描,然后最后where最后筛选,比较耗时。 如果用子查询...

    今天写了个sql跑了好久,老大过来一看指点下,多用子查询,多用where,然后在join,
    提高十多倍,神奇了。想了想,还是老大经验丰富。

    如果先join,就全表扫描,然后最后where最后筛选,比较耗时。
    如果用子查询,就可以利用where过滤不相关的字段,不但增加了map 数量,还减少了数据量。
    以下是我的sql 对比:

    SELECT from_unixtime(cast(a.time_calc_rate_end/1000 AS BIGINT),'yyyy-MM-dd') AS p_date,
           sum(CASE
                   WHEN (a.time_calc_rate_end -a.time_calc_rate_start+1)/86400000 < f.lock_in_period_after_invest THEN b.principal
                   ELSE 0
               END) AS in_advance,
           sum(CASE
                   WHEN (a.time_calc_rate_end -a.time_calc_rate_start+1)/86400000 = f.lock_in_period_after_invest THEN b.principal
                   ELSE 0
               END) AS
    NORMAL
    FROM ods_yqg.fdm_yqg_product_to_user a
    LEFT JOIN ods_yqg.fdm_yqg_user_asset AS b ON b.dt = "${p_date}"
    AND a.product_id = b.product_id
    AND a.user_id = b.user_id
    LEFT JOIN ods_yqg.fdm_yqg_product_fixed_lock_in_period_after_invest AS f ON a.product_id = f.product_id
    AND f.dt = "${p_date}"
    WHERE a.dt = "${p_date}"
      AND from_unixtime(cast(time_calc_rate_end/1000 AS BIGINT),'yyyyMMdd') = "${p_date}"
    GROUP BY from_unixtime(cast(a.time_calc_rate_end/1000 AS BIGINT),'yyyy-MM-dd')

    优化后:

    SELECT from_unixtime(cast(a.time_calc_rate_end/1000 AS BIGINT),'yyyy-MM-dd') AS p_date,
           sum(CASE
                   WHEN (a.time_calc_rate_end -a.time_calc_rate_start+1)/86400000 < f.lock_in_period_after_invest THEN b.principal
                   ELSE 0
               END) AS in_advance,
           sum(CASE
                   WHEN (a.time_calc_rate_end -a.time_calc_rate_start+1)/86400000 = f.lock_in_period_after_invest THEN b.principal
                   ELSE 0
               END) AS
    NORMAL
    FROM
      (SELECT product_id,
              user_id,
              time_calc_rate_end,
              time_calc_rate_start
       FROM ods_yqg.fdm_yqg_product_to_user
       WHERE dt = "${p_date}"
         AND from_unixtime(cast(time_calc_rate_end/1000 AS BIGINT),'yyyyMMdd') = "${p_date}") a
    LEFT JOIN
      (SELECT product_id,
              principal,
              user_id
       FROM ods_yqg.fdm_yqg_user_asset
       WHERE dt = "${p_date}") b ON a.product_id = b.product_id
    AND a.user_id = b.user_id
    LEFT JOIN
      (SELECT product_id,
              lock_in_period_after_invest
       FROM ods_yqg.fdm_yqg_product_fixed_lock_in_period_after_invest
       WHERE dt = "${p_date}" ) AS f ON a.product_id = f.product_id
    GROUP BY from_unixtime(cast(a.time_calc_rate_end/1000 AS BIGINT),'yyyy-MM-dd');
    
    

    hive的查询注意事项以及优化总结 :

    • 1:尽量尽早地过滤数据,减少每个阶段的数据量,对于分区表要加分区,同时只选择需要使用到的字段
    select ... from A
    
    join B
    
    on A.key = B.key
    
    where A.userid>10
    
         and B.userid<10
    
            and A.dt='20120417'
    
            and B.dt='20120417';

    写成:

    select .... from (select .... from A
    
                      where dt='201200417'
    
                                        and userid>10
    
                                  ) a
    
    join ( select .... from B
    
           where dt='201200417'
    
                         and userid < 10   
    
         ) b
    
    on a.key = b.key;
    • 2、对历史库的计算经验 (这项是说根据不同的使用目的优化使用方法)

      历史库计算和使用,分区

    • 3:尽量原子化操作,尽量避免一个SQL包含复杂逻辑

    可以使用中间表来完成复杂的逻辑

    • 4 join操作 小表要注意放在join的左边(有的公司很多都小表放在join的右边)否则会引起磁盘和内存的大量消耗
    • 5:如果union all的部分个数大于2,或者每个union部分数据量大,应该拆成多个insert into 语句,实际测试过程中,执行时间能提升50%
    insert overwite table tablename partition (dt= ....)
    
    select ..... from (
    
                       select ... from A
    
                       union all
    
                       select ... from B
    
                       union all
    
                       select ... from C
    
                                   ) R
    
    where ...;
    

    可以改写为:

    insert into table tablename partition (dt= ....)
    
    select .... from A
    
    WHERE ...;
    
    
    
    insert into table tablename partition (dt= ....)
    
    select .... from B
    
    WHERE ...;
    
    
    
    insert into table tablename partition (dt= ....)
    
    select .... from C
    
    WHERE ...; 
    5:写SQL要先了解数据本身的特点,如果有join ,group操作的话,要注意是否会有数据倾斜
    关于数据倾斜的问题请到另一篇博客上
    
    如果出现数据倾斜,应当做如下处理:
    
    set hive.exec.reducers.max=200;
    
    set mapred.reduce.tasks= 200;---增大Reduce个数
    
    set hive.groupby.mapaggr.checkinterval=100000 ;--这个是group的键对应的记录条数超过这个值则会进行分拆,值根据具体数据量设置
    
    set hive.groupby.skewindata=true; --如果是group by过程出现倾斜 应该设置为true
    
    set hive.skewjoin.key=100000; --这个是join的键对应的记录条数超过这个值则会进行分拆,值根据具体数据量设置
    
    set hive.optimize.skewjoin=true;--如果是join 过程出现倾斜 应该设置为true

    (1) 启动一次job尽可能的多做事情,一个job能完成的事情,不要两个job来做

    通常来说前面的任务启动可以稍带一起做的事情就一起做了,以便后续的多个任务重用,与此紧密相连的是模型设计,好的模型特别重要.

    (2) 合理设置reduce个数

    reduce个数过少没有真正发挥hadoop并行计算的威力,但reduce个数过多,会造成大量小文件问题,数据量、资源情况只有自己最清楚,找到个折衷点,

    (3) 使用hive.exec.parallel参数控制在同一个sql中的不同的job是否可以同时运行,提高作业的并发


    2、让服务器尽量少做事情,走最优的路径,以资源消耗最少为目标

    比如:

    • 注意join的使用
      若其中有一个表很小使用map join,否则使用普通的reduce join,注意hive会将join前面的表数据装载内存,所以较小的一个表在较大的表之前,减少内存资源的消耗

    • 注意小文件的问题

      在hive里有两种比较常见的处理办法

      第一是使用Combinefileinputformat,将多个小文件打包作为一个整体的inputsplit,减少map任务数

      set mapred.max.split.size=256000000;

      set mapred.min.split.size.per.node=256000000

      set Mapred.min.split.size.per.rack=256000000

      set hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat

      第二是设置hive参数,将额外启动一个MR Job打包小文件

      hive.merge.mapredfiles = false 是否合并 Reduce 输出文件,默认为 False

      hive.merge.size.per.task = 256*1000*1000 合并文件的大小

      • 注意数据倾斜

      在hive里比较常用的处理办法

      第一通过hive.groupby.skewindata=true控制生成两个MR Job,第一个MR Job Map的输出 结果随机分配到reduce做次预汇总,减少某些key值条数过多某些key条数过小造成的数据倾斜问题

      第二通过hive.map.aggr = true(默认为true)在Map端做combiner,假如map各条数据基本上不一样, 聚合没什么意义,做combiner反而画蛇添足,hive里也考虑的比较周到通过参数hive.groupby.mapaggr.checkinterval = 100000 (默认)hive.map.aggr.hash.min.reduction=0.5(默认),预先取100000条数据聚合,如果聚合后的条数/100000>0.5,则不再聚合

      • 善用multi insert,union all

      multi insert适合基于同一个源表按照不同逻辑不同粒度处理插入不同表的场景,做到只需要扫描源表一次,job个数不变,减少源表扫描次数

      union all用好,可减少表的扫描次数,减少job的个数,通常预先按不同逻辑不同条件生成的查询union all后,再统一group by计算,不同表的union all相当于multiple inputs,同一个表的union all,相当map一次输出多条

      • 参数设置的调优

      集群参数种类繁多,举个例子比如

      可针对特定job设置特定参数,比如jvm重用,reduce copy线程数量设置(适合map较快,输出量较大)

      如果任务数多且小,比如在一分钟之内完成,减少task数量以减少任务初始化的消耗。可以通过配置JVM重用选项减少task的消耗


    关于sql优化的方面,这里有篇不错的文章,可以参考下
    https://www.cnblogs.com/xd502djj/p/3799432.html

    展开全文
  • 前言 很多人听说过LINQ TO SQL与ADO.NET Entity Framework用于不同的环境,LINQ TO SQL与ADO.NET Entity Framework也没有可比性,就像公交车与私家车一样,虽然是车但用途完全...下面一起来看LINQ TO SQL效率到底如

    前言

    很多人听说过LINQ TO SQL与ADO.NET Entity Framework用于不同的环境,LINQ TO SQL与ADO.NET Entity Framework也没有可比性,就像公交车与私家车一样,虽然是车但用途完全不同,但很少有人去探究,究竟为什么他们不同,他们不同的原因是什么,这我觉得是一个好的程序和一个普通程序最主要的区别之一。下面一起来看LINQ TO SQL效率到底如果吧。

    内容

    测试环境:net framework 4.0 + Sql Server 2008

    测试用途:100w条数据 like 查询,原因添加、修改、删除消耗资源与时间相对较少,不易测试,查询里面最消耗时间的无非就是 like 与 in查询,我们就采用like 相对比较耗时与耗时间的典型来测。

    测试数据:100w条测试数据(其中有一条数据有别于其他数据,在数据的最中央)

    测试数据图:

     

    测试脚本:

    View Code
    create database TestDB
    go
    
    use TestDB
    go
    
    
    create table gameinfo
    (
        gid int identity not null primary key,
        gamename varchar(250) not null,
        createtime datetime default getdate(),
        content text,
        gametype int
    )
    go
    
    
    declare @count int
    set @count =0
    
    while @count<1000000
        begin
            insert into gameinfo(gamename,content,gametype) 
                values('游戏战警X' ,'这游戏聊咋哩,点击链接查看游戏战警。',1);
            set @count=@count+1;
        end
    
    
    go
    
    update gameinfo set gamename='我是第一无二的Dota游戏' where gid=500000  --like查询用
    
    select COUNT(1) as 信息总数 from gameinfo

    测试项目图:

    核心代码:

    GameInfoBLL.cs

    复制代码
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Data.SqlClient;
    
    namespace LINQProject
    {
        /// <summary>
        /// 游戏信息业务处理类(LINQ TO SQL 效率测试用)
        /// 王磊(Stone)
        /// 2012.05.18
        /// </summary>
        public class GameInfoBLL
        {
    
            #region 根据游戏名称模糊查询
            /// <summary>
            /// 根据游戏名称模糊查询
            /// </summary>
            /// <param name="name">游戏名称呢个</param>
            /// <returns>List<GameInfoModel></returns>
            public static List<GameInfoModel> GetGameInfoByGname(string name)
            {
                List<GameInfoModel> list = new List<GameInfoModel>(1000000);
                string sql = "select * from gameinfo where gamename like @gamename";
                SqlDataReader dr = null;
                try
                {
                    using (dr = DBHelper.GetSqlDataReaderBySql(sql, new SqlParameter[]{
                    new SqlParameter("@gamename","%"+name+"%") }))
                    {
                        GameInfoModel game = new GameInfoModel();
                        while (dr.Read())
                        {
                            game.gid = (int)dr["gid"];
                            game.gamename = (string)dr["gamename"];
                            game.createtime = (DateTime)dr["createtime"];
                            game.content = (string)dr["content"];
                            game.gametype = (int)dr["gametype"];
                            list.Add(game);
                        }
                    }
                }
                catch (Exception ex)
                {
                    if (null != dr && !dr.IsClosed)
                    {
                        dr.Close();
                    }
                    throw ex;
                }
                return list;
            }
            #endregion
    
        }
    }
    复制代码

    DBHelper.cs

    View Code
        #region 查询信息返回SqlDataReader
        /// <summary>
        /// 查询信息返回SqlDataReader
        /// </summary>
        /// <param name="sql">查询sql</param>
        /// <param name="par">SqlParameter 可选参数数组</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader GetSqlDataReaderBySql(string sql, params SqlParameter[] par)
        {
            using (Conn)
            {
                SqlCommand cmd = new SqlCommand(sql, Conn);
                if (null != par)
                    cmd.Parameters.AddRange(par);
                try
                {
                    cmd.Connection.Open();
                    return cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
                }
                catch (Exception ex)
                {
                    cmd.Connection.Close();
                    throw ex;
                }
                finally
                {
                    cmd.Parameters.Clear();
                }
            }
        }
        #endregion

    测试类代码:

    复制代码
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Diagnostics;
    
    namespace LINQProject
    {
        class Program
        {
            static void Main(string[] args)
            {
    
                for (int i = 1; i < 10; i++)
                {
                    Test(i);
                }
                Console.Read();
            }
    
            /// <summary>
            /// 效率方法测试
            /// </summary>
            private static void Test(int testNumber)
            {
                Stopwatch linqWatch = new Stopwatch();
                linqWatch.Start();
                // LINQ 查询
                DataClasses1DataContext db = new DataClasses1DataContext();
                var glist = from g in db.gameinfo
                            where g.gamename.Contains("Dota")
                            select g;
    
                // foreach 遍历
                foreach (var item in glist)
                {
                    Console.Write("LINQ:" + item.gamename + " ");
                }
                linqWatch.Stop();
    
                Stopwatch adoWatch = new Stopwatch();
                adoWatch.Start();
                // ADO.NET Entity Framework 查询
                List<GameInfoModel> list = GameInfoBLL.GetGameInfoByGname("Dota");
                // foreach 遍历
                foreach (GameInfoModel item in list)
                {
                    Console.WriteLine("ADO.NET:" + item.gamename);
                }
                adoWatch.Stop();
    
                Console.WriteLine("================================结果" + testNumber + "=========================================");
                Console.WriteLine(String.Format("LINQ 用时:{0} \r\nADO.NET 用时:{1}",
                   linqWatch.ElapsedMilliseconds, adoWatch.ElapsedMilliseconds));
            }
        }
    }
    复制代码

    测试项目下载:点击

     惠山人才网 北仑人才网 峨眉人才网 岳麓人才网 崂山人才网

    结果

    如图:

    LINQ TO SQL第一次的时候比较消耗资源,原因LINQ第一次初始化比较耗时,之后LINQ查询与ADO.NET Entity Framework几乎一样,在100w条数据下随然数据大同小异,但已经足够说明问题,LINQ TO SQL 还是可以用的,起码中小型项目可以放心使用。

    大家如有好的建议或者意见欢迎拍板。

    展开全文
  • 记一次distinct导致的sql效率问题

    千次阅读 2020-08-17 12:58:06
    问题描述:distinct的使用可能导致SQL的性能下降,也可能是distinct和group by一起使用的原因 场景:查询有多个组织的人员数据,人员在a表有多个组织,所以查询出来是多行记录 数据量:a表65W+数据,b表54W+数据,c表...
  • 关于SQL效率优化的几个方法

    千次阅读 2018-07-19 16:46:54
    or 和 in 效率对比   《mysql数据库开发的36条军规》里面提到了or和in的效率问题,文中提到or的效率为O(n),而in的效率为O(logn), 当n越大的时候效率相差越明显   如果ax=N(a&gt;0,且a≠1),那么数x...
  • IT江湖百晓生主讲嘉宾:郑松华知数堂《SQL优化开发》课程讲师微信号:qidan3500大牛背景:资深数据库工程师对SQL优化有独到见解7年SQL开发和调优经验现任职韩国法院数据中心从事数据库技术支持原SKC&CShenyang DBM...
  • 今天试了一下,有时候用inner join效率不高啊。 (1)inner join方式:用时19秒 select p.PROBLEMID ,pe.Times from problem p left join ProblemExt pe on p.problemid=pe.problemid (2)字段用子查询方式:...
  • 参数绑定导致java执行查询sql效率

    千次阅读 2014-08-25 20:27:57
    今天在做一个分页查询的时候,发现一个sql在java端执行超级慢,原sql的格式大概
  • /*你的SQL脚本开始*/ SELECT * FROM [Receipt] where id>0 and RtSendUserId=1 for XML PATH('') /*你的SQL脚本结束*/ select [语句执行花费时间(毫秒)]=datediff(ms,@d,getdate()) declare
  • 分页代码及相应SQL效率的分析

    千次阅读 2007-06-07 21:59:00
    前阵子一直在研究一个老问题,就是分页效率问题。虽然网上代码不计其数,但是大部分都是雷同的,不尽如人意。在此我把这几天的研究成果给大家分享下,希望对各位程序开发人员有所帮助。(注:这里没有研究分页缓存...
  • $sqls="select oop.id,oop.parent_product_id,oops.one_pro_id,oop.imei,oop.pur_price,oop.sal_price,sum(oops.one_pro_status_code_id) as one_pro_status_code_id,oop.vendor_sal_price,oop.product_id,...
  • SQL 提升SQL执行效率诀窍.docx
  • SQL优化,提高效率

    2013-12-05 13:33:01
    优化sql,提高sql效率!适合有一定基础的人
  • sql的执行效率优化

    2010-12-07 09:34:06
    sql 效率优化 1.语句摆放优化 2.函数优化
  • SQL设计效率

    2008-07-15 09:34:31
    SQL设计效率///SQL设计效率
  • sql查询效率

    2012-02-08 13:30:15
    sql查询优化 编写高效的sql语句 sql语句的调优 系统性能的优化
  • sql执行效率提高

    2013-10-03 21:27:35
    使你的 SQL 语句完全优化,提高sql执行效率
  • SQL语句效率优化技巧

    2011-03-30 12:38:16
    SQL语句 效率优化 技巧 SQL语句 效率优化 技巧 SQL语句 效率优化
  • 如何提高SQL查询效率

    2013-10-23 13:58:39
    如何提高SQL查询效率,写SQL注意的地方
  • SQL艺术、提高SQL执行效率的方法总结SQL艺术、提高SQL执行效率的方法总结SQL艺术、提高SQL执行效率的方法总结SQL艺术、提高SQL执行效率的方法总结SQL艺术、提高SQL执行效率的方法总结SQL艺术、提高SQL执行效率的方法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 470,075
精华内容 188,030
关键字:

sql效率