Meituan-Interviewfrage: Sind Sie jemals auf langsames SQL gestoßen? Wie wurde es gelöst?

Über langsames SQL haben der Interviewer und ich uns lange unterhalten. Der Interviewer war auch sehr bescheiden und nickte immer. Am Ende sagte ich noch „你先回去等通知吧！“.

Deshalb habe ich beschlossen, diesen technischen Punkt zu langsamem SQL mit Ihnen zu teilen. Ich hoffe, dass Sie das nächste Mal, wenn Sie auf ein ähnliches Vorstellungsgespräch stoßen, reibungslos und problemlos das gewünschte Angebot erhalten.

Die größte Freude im Leben ist, dass jeder sagt, dass man es nicht kann, aber man schafft es!

Was ist langsames SQL?

Das langsame Abfrageprotokoll von MySQL ist ein von MySQL bereitgestellter Protokolldatensatz. Hiermit werden Anweisungen aufgezeichnet, deren Abfragezeit in MySQL den festgelegten Schwellenwert (long_query_time) überschreitet (größer als) und im Protokoll für langsame Abfragen aufgezeichnet.

Unter diesen beträgt der Standardwert von long_query_time 10 und die Einheit ist Sekunden. Das heißt, Ihre SQL-Abfragezeit überschreitet standardmäßig 10 Sekunden, was als langsames SQL gilt.

Wie aktiviere ich das langsame SQL-Protokoll?

In MySQL ist das langsame SQL-Protokoll standardmäßig nicht aktiviert, was bedeutet, dass es Ihnen nicht mitteilt, selbst wenn langsames SQL auftritt. Wenn Sie wissen müssen, welches SQL langsam ist, müssen wir es manuell aktivieren auf dem langsamen SQL-Protokoll von.

Ob langsames SQL aktiviert ist, können wir mit dem folgenden Befehl überprüfen:

-- 查看慢查询日志是否开启
show variables like '%slow_query_log%';

Hier Bildbeschreibung einfügen

Durch den Befehl können wir sehen, dass das Element slow_query_log AUS ist, was darauf hinweist, dass unser langsames SQL-Protokoll nicht aktiviert ist. Darüber hinaus können wir auch das Verzeichnis sehen, in dem unsere langsamen SQL-Protokolle gespeichert sind, und den Namen der Protokolldatei.

Aktivieren wir das langsame SQL-Protokoll und führen den folgenden Befehl aus:

set global slow_query_log = 1;

Es ist zu beachten, dass hier unsere aktuelle Datenbank aktiviert ist und nach einem Neustart der Datenbank ungültig wird.

Überprüfen Sie nach dem Einschalten des langsamen SQL-Protokolls erneut:

slow_query_log-Element wurde eingeschaltet, was anzeigt, dass es erfolgreich aktiviert wurde.

Wie oben erwähnt, beträgt die Standardzeit für langsames SQL 10 Sekunden. Wir können die Standardzeit für unser langsames SQL mit dem folgenden Befehl sehen:

show variables like '%long_query_time%';

Bildbeschreibung hier einfügen

Wir können dies nicht immer verwenden Standardwert: Viele Unternehmen benötigen möglicherweise eine kürzere oder längere Zeit. Daher müssen wir zu diesem Zeitpunkt die Standardzeit ändern. Der Änderungsbefehl lautet wie folgt:

set long_query_time = 3;

Nach der Änderung prüfen wir, ob er auf 3 Sekunden geändert wurde.

Hier ist etwas zu beachten: Wenn Sie möchten, dass es dauerhaft wirksam wird, müssen Sie auch die Konfigurationsdatei my.cnf unter MySQL ändern.

[mysqld]
slow_query_log=1
slow_query_log_file=/var/lib/mysql/atguigu-slow.log
long_query_time=3
log_output=FILE

Hinweis: Verschiedene Betriebssysteme haben leicht unterschiedliche Konfigurationen.

Im Linux-Betriebssystem

Fügen Sie

log-slow-queries=/var/lib/mysql/slowquery.log zur MySQL-Konfigurationsdatei my.cnf hinzu (geben Sie den Speicherort der Protokolldatei an, er kann leer sein, Das System wird eine Standarddatei host_name-slow.log)

long_query_time=2 (zeichnen Sie die überschrittene Zeit auf, der Standardwert ist 10s)

log-queries-not-using-indexes (log下来没有使用索引的query,可以根据情况决定是否开启)

log-long-format (如果设置了，所有没有使用索引的查询也将被记录)

Windows操作系统中

在my.ini的[mysqld]添加如下语句：

log-slow-queries = E:\web\mysql\log\mysqlslowquery.log

long_query_time = 3(其他参数如上)

执行一条慢SQL，因为我们前面已经设置好了慢SQL时间为3秒，所以，我们只要执行一条SQL时间超过3秒即可。

SELECT SLEEP(4);

该SQL耗时4.024秒，下面我们就来查看慢SQL出现了多少条。

使用命令：

show global status like '%Slow_queries%';

查询SQL历程

找到慢SQL日志文件，打开后就会出现类似下面这样的语句；

# Time: 2021-07-20T09:17:49.791767Z
# User@Host: root[root] @ localhost []  Id:   150
# Query_time: 0.002549  Lock_time: 0.000144 Rows_sent: 1  Rows_examined: 4079
SET timestamp=1566292669;
select * from city where Name = 'Salala';

简单说明：

1.Time 该日志记录的时间

2.User @Host MySQL登录的用户和登录的主机地址

3.Query_time一行 第一个时间是查询的时间、第二个是锁表的时间、第三个是返回的行数、第四个是扫描的行数

4.SET timestamp 这一个是MySQL查询的时间

5.sql语句 这一行就很明显了，表示的是我们执行的sql语句

切记

Wenn Sie long_query_time=0 festlegen, bedeutet dies, dass alle unsere Abfrage-SQL-Anweisungen in die langsame SQL-Protokolldatei ausgegeben werden.

Wie finde ich langsames SQL?

Normalerweise gibt es für uns zwei Möglichkeiten, langsames SQL zu lokalisieren:

Der erste Weg: Langsame Abfrage lokalisieren SQL kann anhand von zwei Darstellungen beurteilt werden

• Darstellung auf Systemebene:
• Verwenden Sie den Befehl sar und den Befehl top, um den aktuellen Systemstatus anzuzeigen.
• Sie können auch die Überwachungstools Prometheus und Grafana verwenden, um den aktuellen Systemstatus anzuzeigen.
• CPU ist stark ausgelastet
• IO Warten auf ernsthafte
• Die Antwortzeit der Seite ist zu lang
• Das Projektprotokoll weist eine Zeitüberschreitung und andere Fehler auf
• SQL-Anweisungsdarstellung:
• SQLLange Anweisung
• SQL-Anweisung: Die Ausführungszeit ist zu lang
• Zweitens: Verwenden Sie je nach Datenbank unterschiedliche Methoden. Möglichkeiten, Fragen zu stellen SQL
• MySQL:
• 慢查询日志
• 测试工具loadrunner
• ptquery工具
• Oracle:
• AWR报告
• 测试工具loadrunner
• 相关内部视图vsession_wait
• GRID CONTROL监控工具

熟悉慢SQL日志分析工具吗？

如果开启了慢SQL日志后，可能会有大量的慢SQL日志产生，此时再用肉眼看，那是不太现实的，所以大佬们就给我搞了个工具：mysqldumpslow。

mysqldumpslow能将相同的慢SQL归类，并统计出相同的SQL执行的次数，每次执行耗时多久、总耗时，每次返回的行数、总行数，以及客户端连接信息等。

通过命令

mysqldumpslow --help

可以看到相关参数的说明：

~# mysqldumpslow --help
Usage: mysqldumpslow [ OPTS... ] [ LOGS... ]

Parse and summarize the MySQL slow query log. Options are

  --verbose    verbose
  --debug      debug
  --help       write this text to standard output

  -v           verbose
  -d           debug
  -s ORDER     what to sort by (al, at, ar, c, l, r, t), 'at' is default
                al: average lock time
                ar: average rows sent
                at: average query time
                 c: count
                 l: lock time
                 r: rows sent
                 t: query time  
  -r           reverse the sort order (largest last instead of first)
  -t NUM       just show the top n queries
  -a           don't abstract all numbers to N and strings to 'S'
  -n NUM       abstract numbers with at least n digits within names
  -g PATTERN   grep: only consider stmts that include this string
  -h HOSTNAME  hostname of db server for *-slow.log filename (can be wildcard),
               default is '*', i.e. match all
  -i NAME      name of server instance (if using mysql.server startup script)
  -l           don't subtract lock time from total time

比较常用的参数有这么几个：

-s 指定输出的排序方式
   t  : 根据query time(执行时间)进行排序；
   at : 根据average query time(平均执行时间)进行排序；（默认使用的方式）
   l  : 根据lock time(锁定时间)进行排序；
   al : 根据average lock time(平均锁定时间)进行排序；
   r  : 根据rows(扫描的行数)进行排序；
   ar : 根据average rows(扫描的平均行数)进行排序；
   c  : 根据日志中出现的总次数进行排序；
-t 指定输出的sql语句条数；
-a 不进行抽象显示(默认会将数字抽象为N，字符串抽象为S)；
-g 满足指定条件，与grep相似；
-h 用来指定主机名(指定打开文件，通常慢查询日志名称为“主机名-slow.log”，用-h exp则表示打开exp-slow.log文件)；

使用方式

mysqldumpslow常用的使用方式如下：

# mysqldumpslow -s c slow.log

如上一条命令，应该是mysqldumpslow最简单的一种形式，其中-s参数是以什么方式排序的意思，c指代的是以总数从大到小的方式排序。-s的常用子参数有：c: 相同查询以查询条数和从大到小排序。t: 以查询总时间的方式从大到小排序。l: 以查询锁的总时间的方式从大到小排序。at: 以查询平均时间的方式从大到小排序。al: 以查询锁平均时间的方式从大到小排序。

同样的，还可以增加其他参数，实际使用的时候，按照自己的情况来。

其他常用方式：

# 得到返回记录集最多的10 个SQL
mysqldumpslow -s r -t 10 /var/lib/mysql/atguigu-slow.log

# 得到访问次数最多的10 个SQL
mysqldumpslow -s c -t 10 /var/lib/mysql/atguigu-slow.log

# 得到按照时间排序的前10 条里面含有左连接的查询语句
mysqldumpslow -s t -t 10 -g "left join" /var/lib/mysql/atguigu-slow.log

# 另外建议在使用这些命令时结合| 和more 使用，否则有可能出现爆屏情况
mysqldumpslow -s r -t 10 /var/lib/mysql/atguigu-slow.log | more

接下，我们来个实际操作。

实操

root@yunzongjitest1:~# mysqldumpslow -s t -t 3

Reading mysql slow query log from /var/lib/mysql/exp-slow.log /var/lib/mysql/yunzongjitest1-slow.log
Count: 464  Time=18.35s (8515s)  Lock=0.01s (3s)  Rows=90884.0 (42170176), root[root]@localhost
  select ************

Count: 38  Time=11.22s (426s)  Lock=0.00s (0s)  Rows=1.0 (38), root[root]@localhost
  select *********** not like 'S'

Count: 48  Time=5.07s (243s)  Lock=0.02s (1s)  Rows=1.0 (48), root[root]@localhost
  select ********='S'

这其中的SQL语句因为涉及某些信息，所以我都用*号将主体替换了，如果希望得到具体的值，使用-a参数。

使用mysqldumpslow查询出来的摘要信息，包含了这些内容：

Count: 464 ：表示慢查询日志总共记录到这条sql语句执行的次数；

Time=18.35s (8515s)：18.35s表示平均执行时间（-s at)，8515s表示总的执行时间(-s t)；

Lock=0.01s (3s)：与上面的Time相同，第一个表示平均锁定时间(-s al)，括号内的表示总的锁定时间(-s l)（也有另一种说法，说是表示的等待锁释放的时间）；

Rows=90884.0 (42170176): Der erste Wert stellt die durchschnittliche Anzahl der gescannten Zeilen dar (-s ar), und der Wert in Klammern stellt die Gesamtanzahl der gescannten Zeilen dar (-s r).

Das obige ist der detaillierte Inhalt vonMeituan-Interviewfrage: Sind Sie jemals auf langsames SQL gestoßen? Wie wurde es gelöst?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!