精华内容
下载资源
问答
  • 它会在jOOQ代码生成器运行慢速查询以反向工程模式元信息时进行检测。 为什么? 在我们的开发和集成测试环境中,我们没有适用于所有不同性能边缘情况的庞大架构。 例如,我们没有5000个Oracle同义词。 或10000个...

    它会在jOOQ代码生成器运行慢速查询以反向工程模式元信息时进行检测。 为什么?

    在我们的开发和集成测试环境中,我们没有适用于所有不同性能边缘情况的庞大架构。 例如,我们没有5000个Oracle同义词。 或10000个过程,每个过程具有500个参数。 我们确实涵盖了一些常见的极端情况,但并未涵盖所有数据库。

    另一方面,用户往往会在一段时间后接受现状。 代码生成器是否运行缓慢? 当然,因为我们有一个庞大的架构。 懒惰的接受阻碍了我们产品的质量。 我们希望用户报告他们遇到的各种问题,因此我们鼓励他们。

    我们做到了

    在即将到来的jOOQ版本3.8(以及3.5.5、3.6.5和3.7.3的修补程序版本)中,我们在jOOQ-meta中添加了一个漂亮的ExecuteListener ,大致如下所示:

    class PerformanceListener 
        extends DefaultExecuteListener {
    
        StopWatch watch;
        class SQLPerformanceWarning 
            extends Exception {}
    
        @Override
        public void executeStart(ExecuteContext ctx) {
            super.executeStart(ctx);
            watch = new StopWatch();
        }
    
        @Override
        public void executeEnd(ExecuteContext ctx) {
            super.executeEnd(ctx);
            if (watch.split() > 5 * 1000 * 1000 * 1000)
                log.warn(
                    "Slow SQL",
                    "jOOQ Meta executed a slow query"
                  + "\n\n"
                  + "Please report this bug here: "
                  + "https://github.com/jOOQ/jOOQ/issues/new\n\n"
                  + formatted(ctx.query()),
                    new SQLPerformanceWarning());
        }
    }

    非常简单 每次我们开始执行查询时,都会启动“秒表”。 每次结束执行时,我们都会检查手表是否经过了5秒钟以上。 如果是这样,我们会记录警告,指向问题跟踪器的链接,SQL查询的格式化版本以及堆栈跟踪,以帮助查找执行慢速语句的确切位置。

    让我们运行这个

    之所以这样做,是因为我们已经看到PostgreSQL代码生成器运行一个缓慢的查询来获取所有存储过程(并生成重载索引)。 产生的错误消息是:

    [WARNING] Slow SQL                 : jOOQ Meta executed a slow query (slower than 5 seconds)
    
    Please report this bug here: https://github.com/jOOQ/jOOQ/issues/new
    
    select
      "r1"."routine_schema",
      "r1"."routine_name",
      "r1"."specific_name",
      case when exists (
            select 1 as "one"
            from "information_schema"."parameters"
            where (
              "information_schema"."parameters"."specific_schema" = "r1"."specific_schema"
              and "information_schema"."parameters"."specific_name" = "r1"."specific_name"
              and upper("information_schema"."parameters"."parameter_mode")  'IN'
            )
          ) then 'void'
           else "r1"."data_type"
      end as "data_type",
      "r1"."character_maximum_length",
      "r1"."numeric_precision",
      "r1"."numeric_scale",
      "r1"."type_udt_schema",
      "r1"."type_udt_name",
      case when exists (
            select 1 as "one"
            from "information_schema"."routines" as "r2"
            where (
              "r2"."routine_schema" in (
                'public', 'multi_schema', 'pg_catalog'
              )
              and "r2"."routine_schema" = "r1"."routine_schema"
              and "r2"."routine_name" = "r1"."routine_name"
              and "r2"."specific_name"  "r1"."specific_name"
            )
          ) then (
            select count(*)
            from "information_schema"."routines" as "r2"
            where (
              "r2"."routine_schema" in (
                'public', 'multi_schema', 'pg_catalog'
              )
              and "r2"."routine_schema" = "r1"."routine_schema"
              and "r2"."routine_name" = "r1"."routine_name"
              and "r2"."specific_name" <= "r1"."specific_name"
            )
          ) end as "overload",
      "pg_catalog"."pg_proc"."proisagg"
    from "information_schema"."routines" as "r1"
      join "pg_catalog"."pg_namespace"
      on "pg_catalog"."pg_namespace"."nspname" = "r1"."specific_schema"
      join "pg_catalog"."pg_proc"
      on (
        "pg_catalog"."pg_proc"."pronamespace" = "pg_catalog"."pg_namespace".oid
        and (("pg_catalog"."pg_proc"."proname" || '_') || cast("pg_catalog"."pg_proc".oid as varchar)) = "r1"."specific_name"
      )
    where (
      "r1"."routine_schema" in (
        'public', 'multi_schema', 'pg_catalog'
      )
      and not("pg_catalog"."pg_proc"."proretset")
    )
    order by
      "r1"."routine_schema" asc,
      "r1"."routine_name" asc,
      "overload" asc
    org.jooq.util.AbstractDatabase$1$SQLPerformanceWarning
            at org.jooq.util.AbstractDatabase$1.executeEnd(AbstractDatabase.java:230)
            at org.jooq.impl.ExecuteListeners.executeEnd(ExecuteListeners.java:163)
            at org.jooq.impl.AbstractResultQuery.execute(AbstractResultQuery.java:269)
            at org.jooq.impl.AbstractQuery.execute(AbstractQuery.java:346)
            at org.jooq.impl.AbstractResultQuery.fetch(AbstractResultQuery.java:308)
            at org.jooq.impl.SelectImpl.fetch(SelectImpl.java:2703)
            at org.jooq.util.postgres.PostgresDatabase.getRoutines0(PostgresDatabase.java:707)
            at org.jooq.util.AbstractDatabase.getRoutines(AbstractDatabase.java:1131)
            at org.jooq.util.JavaGenerator.generate(JavaGenerator.java:417)
            at org.jooq.util.JavaGenerator.generate(JavaGenerator.java:314)
            at org.jooq.util.JavaGenerator.generate(JavaGenerator.java:279)
            at org.jooq.util.GenerationTool.run(GenerationTool.java:490)
            at org.jooq.util.GenerationTool.generate(GenerationTool.java:193)
            at org.jooq.util.maven.Plugin.execute(Plugin.java:131)
            ...

    现在,我们可以轻松地修复查询。

    你也可以做到的!

    ExecuteListener的实现很简单。 您可以非常轻松地执行相同操作。 只需将一个简单的执行侦听器挂接到jOOQ Configuration ,即可测量执行速度并在完成阈值后记录警告。

    调试愉快!

    进一步阅读

    巧合的是, Square的工程团队记录了一种非常类似的方法–查询狙击手: https : //corner.squareup.com/2016/01/query-sniper.html

    翻译自: https://www.javacodegeeks.com/2016/02/detect-slow-queries-jooq.html

    展开全文
  • jooq 查询时间 刚才,我们在jOOQ的代码生成器中实现了一个不错的小功能: https : //github.com/jOOQ/jOOQ/issues/4974 它会在jOOQ代码生成器运行慢速查询以反向工程模式元信息时进行检测。 为什么? 在我们的...

    jooq 查询时间

    它会在jOOQ代码生成器运行慢速查询以反向工程模式元信息时进行检测。 为什么?

    在我们的开发和集成测试环境中,我们没有适用于所有不同性能边缘情况的庞大架构。 例如,我们没有5000个Oracle同义词。 或10000个过程,每个过程具有500个参数。 我们确实涵盖了一些常见的极端情况,但并未涵盖所有数据库。

    另一方面,用户往往会在一段时间后接受现状。 代码生成器是否运行缓慢? 当然,因为我们有一个庞大的架构。 懒惰的接受阻碍了我们产品的质量。 我们希望用户报告他们遇到的各种问题,因此我们鼓励他们。

    我们做到了

    在即将到来的jOOQ版本3.8(以及3.5.5、3.6.5和3.7.3的修补程序版本)中,我们在jOOQ-meta中添加了一个漂亮的ExecuteListener ,大致如下所示:

    class PerformanceListener 
        extends DefaultExecuteListener {
    
        StopWatch watch;
        class SQLPerformanceWarning 
            extends Exception {}
    
        @Override
        public void executeStart(ExecuteContext ctx) {
            super.executeStart(ctx);
            watch = new StopWatch();
        }
    
        @Override
        public void executeEnd(ExecuteContext ctx) {
            super.executeEnd(ctx);
            if (watch.split() > 5 * 1000 * 1000 * 1000)
                log.warn(
                    "Slow SQL",
                    "jOOQ Meta executed a slow query"
                  + "\n\n"
                  + "Please report this bug here: "
                  + "https://github.com/jOOQ/jOOQ/issues/new\n\n"
                  + formatted(ctx.query()),
                    new SQLPerformanceWarning());
        }
    }

    非常简单 每次我们开始执行查询时,都会启动“秒表”。 每次结束执行时,我们都会检查手表是否经过了5秒以上。 如果是这样,我们将记录警告,问题跟踪器的链接,SQL查询的格式化版本以及堆栈跟踪,以帮助查找执行慢速语句的确切位置。

    让我们运行

    之所以这样做,是因为我们已经看到PostgreSQL代码生成器运行一个缓慢的查询来获取所有存储过程(并生成重载索引)。 产生的错误消息是:

    [WARNING] Slow SQL                 : jOOQ Meta executed a slow query (slower than 5 seconds)
    
    Please report this bug here: https://github.com/jOOQ/jOOQ/issues/new
    
    select
      "r1"."routine_schema",
      "r1"."routine_name",
      "r1"."specific_name",
      case when exists (
            select 1 as "one"
            from "information_schema"."parameters"
            where (
              "information_schema"."parameters"."specific_schema" = "r1"."specific_schema"
              and "information_schema"."parameters"."specific_name" = "r1"."specific_name"
              and upper("information_schema"."parameters"."parameter_mode")  'IN'
            )
          ) then 'void'
           else "r1"."data_type"
      end as "data_type",
      "r1"."character_maximum_length",
      "r1"."numeric_precision",
      "r1"."numeric_scale",
      "r1"."type_udt_schema",
      "r1"."type_udt_name",
      case when exists (
            select 1 as "one"
            from "information_schema"."routines" as "r2"
            where (
              "r2"."routine_schema" in (
                'public', 'multi_schema', 'pg_catalog'
              )
              and "r2"."routine_schema" = "r1"."routine_schema"
              and "r2"."routine_name" = "r1"."routine_name"
              and "r2"."specific_name"  "r1"."specific_name"
            )
          ) then (
            select count(*)
            from "information_schema"."routines" as "r2"
            where (
              "r2"."routine_schema" in (
                'public', 'multi_schema', 'pg_catalog'
              )
              and "r2"."routine_schema" = "r1"."routine_schema"
              and "r2"."routine_name" = "r1"."routine_name"
              and "r2"."specific_name" <= "r1"."specific_name"
            )
          ) end as "overload",
      "pg_catalog"."pg_proc"."proisagg"
    from "information_schema"."routines" as "r1"
      join "pg_catalog"."pg_namespace"
      on "pg_catalog"."pg_namespace"."nspname" = "r1"."specific_schema"
      join "pg_catalog"."pg_proc"
      on (
        "pg_catalog"."pg_proc"."pronamespace" = "pg_catalog"."pg_namespace".oid
        and (("pg_catalog"."pg_proc"."proname" || '_') || cast("pg_catalog"."pg_proc".oid as varchar)) = "r1"."specific_name"
      )
    where (
      "r1"."routine_schema" in (
        'public', 'multi_schema', 'pg_catalog'
      )
      and not("pg_catalog"."pg_proc"."proretset")
    )
    order by
      "r1"."routine_schema" asc,
      "r1"."routine_name" asc,
      "overload" asc
    org.jooq.util.AbstractDatabase$1$SQLPerformanceWarning
            at org.jooq.util.AbstractDatabase$1.executeEnd(AbstractDatabase.java:230)
            at org.jooq.impl.ExecuteListeners.executeEnd(ExecuteListeners.java:163)
            at org.jooq.impl.AbstractResultQuery.execute(AbstractResultQuery.java:269)
            at org.jooq.impl.AbstractQuery.execute(AbstractQuery.java:346)
            at org.jooq.impl.AbstractResultQuery.fetch(AbstractResultQuery.java:308)
            at org.jooq.impl.SelectImpl.fetch(SelectImpl.java:2703)
            at org.jooq.util.postgres.PostgresDatabase.getRoutines0(PostgresDatabase.java:707)
            at org.jooq.util.AbstractDatabase.getRoutines(AbstractDatabase.java:1131)
            at org.jooq.util.JavaGenerator.generate(JavaGenerator.java:417)
            at org.jooq.util.JavaGenerator.generate(JavaGenerator.java:314)
            at org.jooq.util.JavaGenerator.generate(JavaGenerator.java:279)
            at org.jooq.util.GenerationTool.run(GenerationTool.java:490)
            at org.jooq.util.GenerationTool.generate(GenerationTool.java:193)
            at org.jooq.util.maven.Plugin.execute(Plugin.java:131)
            ...

    现在,我们可以轻松地修复查询。

    你也可以做到的!

    ExecuteListener的实现很简单。 您可以非常轻松地执行相同操作。 只需将一个简单的执行侦听器挂接到jOOQ Configuration ,即可测量执行速度并在完成阈值后记录警告。

    调试愉快!

    进一步阅读

    巧合的是, Square的工程团队记录了一种非常类似的方法–查询狙击手: https//corner.squareup.com/2016/01/query-sniper.html

    翻译自: https://www.javacodegeeks.com/2016/02/detect-slow-queries-jooq.html

    jooq 查询时间

    展开全文
  • 本章主要写当慢查询文件很大的时候怎样在线生成一个新的慢查询文件。 测试环境:mysql 5.6.21 二、步骤 配置慢查询 默认的my.cnf文件在/etc/目录下 vim /etc/my.cnf #slow_query slow_query_log=1#开启慢查询 slow_...
  • mysql调优-如何定位慢查询sql

    千次阅读 2019-08-06 16:36:54
    mysql调优-如何定位慢查询sql 1.业务驱动 2.测试驱动 3慢查询日志 慢查询日志配置 show variables like 'slow_query_log' set global slow_query_log = on set global slow_query_log_file = '/var/lib/...

    mysql调优-如何定位慢查询sql

    1.业务驱动

    2.测试驱动

    3慢查询日志

     

    慢查询日志配置

    show variables like 'slow_query_log'

    set global slow_query_log = on

    set global slow_query_log_file = '/var/lib/mysql/gupaoedu-slow.log'

    set global log_queries_not_using_indexes = on

    set global long_query_time = 0.1 (秒)

    慢查询日志分析

    Time :日志记录的时间

    User@Host:执行的用户及主机

    Query_time:查询耗费时间

    Lock_time 锁表时间

    Rows_sent 发送给请求方的记录 条数

    Rows_examined 语句扫描的记录条数

    SET timestamp 语句执行的时间点

    select .... 执行的具体语句

    慢查询日志分析工具

    MySQL自带的慢查询日志分析工具

    mysqldumpslow -t 10 -s at /var/lib/mysql/bbb.log

    其他工具

    mysqlsla

    pt-query-digest

    展开全文
  • 【MySQL优化之定位慢查询】 定位慢查询 问题:查找、定位慢查询,并优化:怎么查找慢查询? **在项目自验项目转测试之前,在启动mysql数据库时开启慢查询,并且把执行慢的语句写到日志中,在运行一定时间后。通过...

    定位慢查询

    问题:查找、定位慢查询,并优化:怎么查找慢查询?
    **在项目自验项目转测试之前,在启动mysql数据库时开启慢查询,并且把执行慢的语句写到日志中,在运行一定时间后。通过查看日志找到慢查询语句。

    显示慢查询:
    
    show variables like '%slow_query_log%'; 查询是否开启慢查询
    set global slow_query_log=on; 设置慢查询开启的命令
    show variables like 'long_query_time';  显示当前多长时间为慢查询(默认为10s);
    set long_query_time=0.5;  把慢查询的时间设置为0.5s;便于测试
    show variables like 'log_queries_not_using_indexes'; full index scan的sql也会被记录到慢查询日志中。通过设置log_queries_not_using_indexes开启为使用索引的监控
    set global log_queries_not_using_indexes=on
    
    show  [session | golbal] status like 'com_select';  查询的次数
    show  status like 'uptime';  mysql启动的时间
    show status like 'slow_queries';  显示慢查询的条数
    
    
    定位慢查询:(开启慢查询日志) 
    show global variables like "datadir";    确定慢查询日志路径 D:\mysql\MySQL3307\data
    1.关闭服务:net stop mysql
    2.安全模式 开启查询日志
    mysqld --safe-mode --slow-query-log
    关闭安全模式 :
    mysqladmin -uroot -padmin shut down
    
    3.执行sql语句  看日志中是否记录为慢查询语句
    
    4.通过explain来分析日志中的慢查询sql语句,可以分析mysql如何执行你的sql语句。
    

    优化手段 :

    一、表的设计合理化

    表字段定义方式:保小不保大;
    

    1.1三范式及反三范式:

    第一范式:列的不可分割(所有字段),保证字段的原子性
    第二范式:相当于主键,一个表只能描述一件事情,也就表示一个对象,只跟主键有关系的字段可以满足;(主键字段和非主键字段,非主键字段必须依赖主键,也就是跟主键有关系的字段)
    	第三范式:相当于外键,在非主键字段中,如果一个字段可以推导出另一个字段,则那另外字段不需要放入表中,否则出现冗余;
    	
    反三范式:比如地址这个字段,如果不分类汇总,不排序,仅仅是起一个字符串的作用,这时不用拆分;
    

    1.2存储引擎的合理选择

    一、如何选择mysql的存储引擎:
    
    myisam存储:如果表对于事务要求不高,同时是以查询和添加为主的,考虑使用myisam(比如BBS中的发帖表,回复表等)
    注意:在使用myisam引擎时,需要定时优化整理碎片:optimize table 表名;
    
    InnoDB存储:对事物要求高,保存的数据都是重要数据,我们建议使用innodb(比如订单表,账号表)
    
    memory存储:对于数据变化繁忙,不需要入库,同时又频繁的查询和修改,考虑使用memory引擎,速度极快
    
    二、myisam 和 InnoDB 的区别
    
    1.事务安全
    2.查询和添加速度
    3.支持全文索引
    4.锁机制
    5.外键
    

    二、给表添加适合的索引,如何使用索引

    一、为什么创建索引速度就会变快?
    
    索引 是一个基于二叉树和hash算法的数据结构,在创建索引的时候会生成这张表的索引库,(也可以说是生成了一张索引表)每次在检索的时候会通过二叉树查找sql条件的物理位置
    
    二、索引的代价:
    1.占用磁盘空间
    2.对dml(update,delete,insert)语句的效率有影响,因为对原表进行了更改,我们上面所述的索引库也会进行发生改变,从而影响dml语句的效率,但是网站都是查询很多,所以这个代价是值得的。
    
    三、在哪些字段上面适合添加索引:
    1.在where条件较为频繁的作为查询条件的字段应该创建索引
    2.唯一性太差的字段不适合创建索引(比如sex  只有男女两种)
    3.更新的非常频繁的字段不适合建索引(比如status  经常发生变化)
    
    四、如何查询索引的使用情况:
    show status like 'Handler_read%';
    Handler_read_key: 越大越好
    Handler_read_rnd_next: 越小越好
    

    三、分表技术(垂直分表,水平分表)

    当一张表的数据比较多或者一张表的某些字段的值比较多并且很少使用时,采用水平分表和垂直分表来优化

    水平分表(按行):(在插入和查询的时候需要根据分表的字段进行取模 比如:唯一id分表:查询时需要管理好是从哪张表里获取数据,即从 从表获取id%分表数)
    
        1.按时间分表
        这种分表方式有一定的局限性,当数据有较强的实效性,如微博发送记录、微信消息记录等,这种数据很少有用户会查询几个月前的数据,就可以按月字段分表。
    
        2.按区间范围分表
        一般在有严格的自增id需求上,如按照user_id水平分表:
        table_1  user_id从1~100w 
        table_2  user_id从101~200w 
        table_3  user_id从201~300w 
        3.hash分表*****
        通过一个原始目标的ID或者名称通过一定的hash算法计算出数据存储表的表名,然后访问相应的表。
    
    垂直分表(按列):把某张表的某些字段,这些字段在查询时,并不是经常关心,且字段值(长文本、二进制等)数据量很大,建议把这些字段单独的放到另外一张表,从而提高效率,关联关系不变,通过外键关联起来!
    (比如:考试详情,一般我们只关注分数,不关注详情!)
    

    四、缓存

    使用redis等第三方缓存技术来进行缓存优化
    

    五、读写分离

    当一台服务器不能满足需求时,采用读写分离的方式进行集群。
    

    六、定时清理垃圾数据,定时进行碎片整理

    七、对mysql配置进行一些优化

    八、mysql服务硬件升级

    九、其他的优化技巧

    一、对于group by 语句,不想进行它内部排序机制(group by排序机制:插入到mysql中的记录会存在B+tree的叶子节点上面进行排序),可以使用order by null来增加性能
    
    -----------------------------------------------------------------------------------------
    1)数据库设计方面 
      a. 对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立索引。  
      
      b. 应尽量避免在 where 子句中对字段进行 null 值判断,否则将导致引擎放弃使用索引而进行全表扫描,
    如: select id from t where num is null 可以在num上设置默认值0,确保表中num列没有null值,然后这样查
    询: select id from t where num=0 
    
      c. 并不是所有索引对查询都有效,SQL是根据表中数据来进行查询优化的,当索引列有大量数据重复时,查询
    可能不会去利用索引,如一表中有字段sex,male、female几乎各一半,那么即使在sex上建了索引也对查询效
    率起不了作用。 
    
      d. 索引并不是越多越好,索引固然可以提高相应的 select 的效率,但同时也降低了 insert 及 update 的
    效率,因为 insert 或 update 时有可能会重建索引,所以怎样建索引需要慎重考虑,视具体情况而定。一个表
    的索引数最好不要超过6个,若太多则应考虑一些不常使用到的列上建的索引是否有必要。 另外索引也会占用磁盘.
    
      e. 应尽可能的避免更新索引数据列,因为索引数据列的顺序就是表记录的物理存储顺序,一旦该列值改变将
    导致整个表记录的顺序的调整,会耗费相当大的资源。若应用系统需要频繁更新索引数据列,那么需要考虑是否
    应将该索引建为索引。 
    
      f. 尽量使用数字型字段,若只含数值信息的字段尽量不要设计为字符型,这会降低查询和连接的性能,并会
    增加存储开销。这是因为引擎在处理查询和连接时会逐个比较字符串中每一个字符,而对于数字型而言只需要比
    较一次就够了。 
    
      g. 尽可能的使用 varchar/nvarchar 代替 char/nchar ,因为首先变长字段存储空间小,可以节省存储空间,
    其次对于查询来说,在一个相对较小的字段内搜索效率显然要高些。 
    
      h. 尽量使用表变量来代替临时表。如果表变量包含大量数据,请注意索引非常有限(只有主键索引)。 
      
      i. 避免频繁创建和删除临时表,以减少系统表资源的消耗。 
      
      j. 临时表并不是不可使用,适当地使用它们可以使某些例程更有效,例如,当需要重复引用大型表或常用表
    中的某个数据集时。但是,对于一次性事件,最好使用导出表。 
    
      k. 在新建临时表时,如果一次性插入数据量很大,那么可以使用 select into 代替 create table,避免造成
    大量 log ,以提高速度;如果数据量不大,为了缓和系统表的资源,应先create table,然后insert。 
    
      l. 如果使用到了临时表,在存储过程的最后务必将所有的临时表显式删除,先 truncate table ,然后 drop 
    table ,这样可以避免系统表的较长时间锁定。 
    
    -----------------------------------------------------------------------------------------
    2)SQL语句方面 
      a. 应尽量避免在 where 子句中使用!=或<>操作符,否则将引擎放弃使用索引而进行全表扫描。
      
      b. 应尽量避免在 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 
    
      c. 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 
    
      d. 下面的查询也将导致全表扫描: select id from t where name like ‘%abc%’ 
      
      e. 如果在 where 子句中使用参数,也会导致全表扫描。因为SQL只有在运行时才会解析局部变量,但优化
    程序不能将访问计划的选择推迟到运行时;它必须在编译时进行选择。然而,如果在编译时建立访问计划,变量的
    值还是未知的,因而无法作为索引选择的输入项。如下面语句将进行全表扫描: select id from t where 
    num=@num 可以改为强制查询使用索引: select id from t with(index(索引名)) where num=@num 
    
      f. 应尽量避免在 where 子句中对字段进行表达式操作,这将导致引擎放弃使用索引而进行全表扫描。如: 
    select id from t where num/2=100 应改为: select id from t where num=100*2 
    
      g. 应尽量避免在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′ 
    
      h. 不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算,否则系统将可能无法正确使用
    索引。
    
      i. 不要写一些没有意义的查询,如需要生成一个空表结构: select col1,col2 into #t from t where 1=0 这类代码不会返回任何结果集,但是会消耗系统资源的,应改成这样: create table #t(…) 
      
      j. 很多时候用 exists 代替 in 是一个好的选择: select num from a where num in(select num from b) 
    用下面的语句替换: select num from a where exists(select 1 from b where num=a.num) 
    
      k. 任何地方都不要使用 select * from t ,用具体的字段列表代替“*”,不要返回用不到的任何字段。 
      
      l. 尽量避免使用游标,因为游标的效率较差,如果游标操作的数据超过1万行,那么就应该考虑改写。 
      
      m. 尽量避免向客户端返回大数据量,若数据量过大,应该考虑相应需求是否合理。 
    
      n. 尽量避免大事务操作,提高系统并发能力。 
      
    -----------------------------------------------------------------------------------------
    3)java方面:重点内容 
    
      a.尽可能的少造对象。 
      
      b.合理摆正系统设计的位置。大量数据操作,和少量数据操作一定是分开的。大量的数据操作,肯定不是ORM
    框架搞定的。
    
      c.使用JDBC连接数据库操作数据
     
      d.控制好内存,让数据流起来,而不是全部读到内存再处理,而是边读取边处理; 
      
      e.合理利用内存,有的数据要缓存
    
    展开全文
  • 在项目开发中,那些开发大佬经常会写出一些SQL语句,一条糟糕的SQL语句可能让你测试的整个程序都非常慢,超过10秒的话,我觉得一般用户就...那么如何应用慢查询呢? 1、开启MySQL的慢查询日志功能默认情况下,MySQ...
  • 今天在测试4000000条记录的mysql慢查询,数据库安装在windows上,百度了很多,都没有个测试可行的的解决方案或者经验之谈,可能是因为mysql版本不一样吧!这里做个记录以备忘记时候可以查看,也让其他朋友借鉴一下。...
  • Mysql慢查询日志

    2020-03-27 20:27:38
    如何定位慢查询sql (1) 业务驱动 (2) 测试驱动 (3) 慢查询日志 慢查询日志配置 (1) show variables like ‘slow_query_log’ //查看慢查询日志开关及路径 (2) set global slow_query_log = on //打开慢查询 (3) set...
  • 问题:明明建立了索引,为何Like模糊查询速度还是特别? Like是否使用索引?  1、like %keyword 索引失效,使用全表扫描。但可以通过翻转函数+like前模糊查询+建立翻转函数索引=走翻转函数索引,不走全表扫描。 ...
  • MySQL--慢查询

    2016-03-04 09:56:00
    mysql服务器有一项功能,可以检测到哪条sql语句查询得比较慢,就是慢查询slowlog,现在介绍如何开启。 在[mysqld]下面增加如下代码: long_query_time = 1 log-slow-queries = /usr/local/mysql/data/slow.log ...
  • http://www.cnblogs.com/iixiaowei/articles/2341680.htmlmysql服务器有一项功能,可以检测到哪条sql语句查询得比较慢,就是慢查询slowlog,现在介绍如何开启。在[mysqld]下面增加如下代码:long_query_time = 1log-...
  • Mysql服务器有一项功能,可以检测到哪条sql语句查询得比较慢,就是慢查询slowlog,现在介绍如何开启。 在[mysqld]下面增加如下代码: long_query_time = 1 #定义超过1秒的查询计数到变量Slow_queries log-slow-...
  • 如何检测MySQL是否命中索引?

    千次阅读 2019-12-21 18:06:16
    在日常工作中,我们有时会开慢查询去记录一些执行时间比较久的SQL语句,找出这些SQL语句并不意味着完事了,此时我们常常用到explain这个命令来查看一个这些SQL语句的执行计划,查看该SQL语句有没有使用上了索引,有...
  • php-fpm日志查询

    2018-07-13 15:42:18
    问:如何来查看检测比较的php脚本呢?答:查看php-fpm日志。1.先查找到配置文件存放地址find / -name php-fpm.confvi /usr/servers/php/etc/php-fpm.conf打开看看你的日志是否开启,或者开启的日志存放在...
  • 转载--MySQL调优三步曲--慢查询、explain、profile mysql profile explain slow_query_log分析优化查询 在做性能测试中经常会遇到一些sql的问题,其实做性能测试这几年遇到问题最多还是数据库这块,要么就是IO高要么...
  • 描述:该优化案例是想表达要了解各个参数的含义,结合业务的分析以及逻辑实现、以及创建索引和列顺序是如何选择的等(这里...大致分析如下:通过mloginfo统计查看日志中慢查询的分类(将生产系统日志scp到测试服务器...
  • 问题描述:在项目中优化动态查询分页接口时,发现count查询(数据量大概30万),那如何解决这个问题呢? 解决方法:添加索引,多个查询条件可以添加复合索引 二、测试对比 1. 未加索引时 count所用时间:1810...
  • 如何知道自己的电脑是不是中木马或者中毒了?仅仅从反映来判断是很武断的,那么您可以通过如下方法来知道您的电脑是不是已经中毒了。1.最简单,最有效,最直观用杀毒软件。2,用系统自带的命令,netstat -an。查看...
  • 日志-php-fpm日志查询

    万次阅读 2017-02-17 20:49:50
    如何来查看检测比较的php脚本呢? 查看php-fpm日志。 1.先查找到配置文件存放地址 ...2.如果没有开启日志查询,先开启 默认的 request_slowlog_timeout 是0,php的脚本日志是关闭的,因此
  • 日志php-fpm日志查询

    2018-11-24 08:57:49
    项目用php开发,在生产运行的过程中,应该一段时间监测下php脚本运行状态,哪些php进程速度太,有哪些错误日志。...问:如何来查看检测比较的php脚本呢? 答:查看php-fpm...
  • mysql profile explain slow_query_log分析优化查询 ...1、慢查询(分析出问题的sql) 2、Explain(显示了sql如何使用索引来处理select语句以及连接表。可以帮助选择更好的索引和写出更优化的查询...
  • 在做性能测试中经常会遇到一些sql的问题,其实做性能测试这几年...1、慢查询 (分析出现出问题的sql) 2、Explain (显示了mysql如何使用索引来处理select语句以及连接表。可以帮助选择更好的索引和写出更优化的...
  • 做性能测试定位瓶颈的时候,定位到是因为某些 SQL 语句的查询慢所影响的,此时我们提出优化方案,肯定希望验证下优化后的 SQL,此时需要借助 JMeter 的 JDBC 请求,那么我们就需要学习 JMeter 如何与 MySQL 进行整合...

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 301
精华内容 120
关键字:

如何测慢查询