2. 程式人生 > >如何提高MySql資料庫子查詢的效率

如何提高MySql資料庫子查詢的效率

阿新 • • 發佈：2018-11-02

做django的專案，用python語言寫查詢資料庫的語句，使用OuterRef, Subquery，Exists，F建立複雜的查詢語句：

資料庫模型：

from django.db import models


# 經緯度唯一表
class LngLat(models.Model):
    lng = models.DecimalField(max_digits=10, decimal_places=7, default=0.0)
    lat = models.DecimalField(max_digits=9, decimal_places=7, default=0.0)

    class Meta:
        unique_together = ("lng", "lat")

    def __str__(self):
        return str(self.lng) + "," + str(self.lat)


# 浙江新建站小區物件
class ZJenb(models.Model):
    enbname = models.CharField(max_length=100, default=None)
    enbid = models.IntegerField()


# 浙江新建站小區物件
class ZJcell(models.Model):
    # ECI (28 Bits) = eNB ID(20 Bits) + Cell ID(8 Bits)（邏輯小區id，範圍0~255）
    eci = models.IntegerField(primary_key=True, default=None)
    cgi = models.CharField(max_length=100, default=None, unique=True)
    cellid = models.IntegerField(default=None)
    cellname = models.CharField(max_length=100, default=None)
    # 頻段，如F1,F2,D1,D2,D3
    freq = models.CharField(max_length=100, default=None)
    pci = models.IntegerField()
    lnglat = models.ForeignKey(LngLat, on_delete=models.CASCADE, default=None)
    # 天線方位角
    azimuth = models.IntegerField()
    # 模3值
    m3 = models.IntegerField(null=True)
    # 鄰區關係，相當於單向鄰區，雖然可以反向查詢，但不是雙向鄰區。
    # symmetrical=True表示對稱，加了正向，反向自動新增
    adj = models.ManyToManyField("self", symmetrical=False, through='ZJadjacent', through_fields=('cellfrom', 'cellto'))
    enb = models.ForeignKey(ZJenb, on_delete=models.CASCADE, default=None, null=True)

    def __str__(self):
        return self.cellname


# 鄰區多對多關係表
class ZJadjacent(models.Model):
    cellfrom = models.ForeignKey(ZJcell, on_delete=models.CASCADE, default=None, related_name='adj_from_cell')
    # 因為有兩個ZJcell外來鍵，必須對這兩個外來鍵命名為不同的名字，否則出現報錯fields.E304
    cellto = models.ForeignKey(ZJcell, on_delete=models.CASCADE, default=None, related_name='adj_to_cell')
    # 兩個鄰區間的距離
    distance = models.IntegerField(default=None)
    # 站在源小區，看目標小區的方位角
    azi1 = models.IntegerField(default=None)
    # 站在目標小區，看源小區的方位角
    azi2 = models.IntegerField(default=None)
    # 是否存在反向鄰區default=None, null=True
    # Like BooleanField with null=True.
    # Use that instead of this field as it’s likely to be deprecated in a future version of Django.
    has_inverse_adj = models.NullBooleanField()
    # 唯一標識，源小區的cgi&目的小區的cgi，如 460-00-325632-129&460-00-325632-130,避免資料庫中出現重複資料
    # , null=False 這個引數加不加對資料庫沒有更改，因為False是預設值
    # (venv) C:\\Users\Administrator\PycharmProjects\cellsmap>py manage.py makemigrations
    # No changes detected
    source_target_cgi = models.BigIntegerField(primary_key=True, default=None)
    # models.CharField(max_length=100, default=None, unique=True)

    def __str__(self):
        return str(self.source_target_cgi)

 解釋一下：

一共4張表，小區表ZJcell是主表，有兩個外來鍵（經緯度表LngLat，基站表ZJenb），還有一個多對多關係（鄰區ZJadjacent），其中ZJcell有31965條資料，ZJadjacent有838118條資料。

需要提取ZJadjacent鄰區關係中，只有單向鄰區的資料或有雙向鄰區的資料，將其資料中預設為空的has_inverse_adj項分別設定為False或True。

根據django官網子查詢的例子，寫了一個子查詢邏輯，用以判斷每條鄰區資料是否反向鄰區：

from django.db.models import OuterRef, Subquery
from dbbackend.models import ZJcell, LngLat, ZJenb, ZJadjacent
from django.db.models import F
from django.db.models import Exists
inverseadj = ZJadjacent.objects.annotate(iadj=2**32*F('cellto_id') + F('cellfrom_id')).filter(iadj=OuterRef('source_target_cgi'))

symmetricaladj = ZJadjacent.objects.annotate(equaladj=Subquery(inverseadj.values('source_target_cgi')))

解釋一下：

ZJadjacent原表中的source_target_cgi欄位（列）表示（源小區eci乘以2的32次方+目標小區eci）的和，想要與此表中其他條目的（目標eci乘以2的32次方+源小區eci）的和進行比對，如果能找出相等的項，說明存在雙向鄰區，否則只存在單向鄰區。

由於（目標eci乘以2的32次方+源小區eci）在原表中不存在，需要在比對前新增這一列，於是使用語句：

annotate(iadj=2**32*F('cellto_id') + F('cellfrom_id'))

等效sql語言：

SELECT 
    `dbbackend_zjadjacent`.`cellfrom_id`, 
    `dbbackend_zjadjacent`.`cellto_id`, 
    `dbbackend_zjadjacent`.`distance`, 
    `dbbackend_zjadjacent`.`azi1`, 
    `dbbackend_zjadjacent`.`azi2`, 
    `dbbackend_zjadjacent`.`has_inverse_adj`, 
    `dbbackend_zjadjacent`.`source_target_cgi`, 
    (SELECT U0.`cellfrom_id`, 
            U0.`cellto_id`, 
            U0.`distance`, 
            U0.`azi1`, U0.`azi2`, 
            U0.`has_inverse_adj`, 
            U0.`source_target_cgi`, 
            ((4294967296 * U0.`cellto_id`) + U0.`cellfrom_id`) AS `iadj` 
        FROM `dbbackend_zjadjacent` U0 
        WHERE 
            ((4294967296 * U0.`cellto_id`) + U0.`cellfrom_id`) = 
            (`dbbackend_zjadjacent`.`source_target_cgi`)
    ) AS `equaladj` 
FROM `dbbackend_zjadjacent`

實際查詢時，發現效率很低，只是計數symmetricaladj.count()都很慢。

第一次改進，使用Exists（）函式：

from django.db.models import OuterRef, Subquery
from dbbackend.models import ZJcell, LngLat, ZJenb, ZJadjacent
from django.db.models import F
from django.db.models import Exists
inverseadj = ZJadjacent.objects.annotate(iadj=2**32*F('cellto_id') + F('cellfrom_id')).filter(iadj=OuterRef('source_target_cgi'))


symmetricaladjsource = ZJadjacent.objects.annotate(equaladj=Exists(inverseadj))

等效sql：

SELECT 
    `dbbackend_zjadjacent`.`cellfrom_id`, 
    `dbbackend_zjadjacent`.`cellto_id`, 
    `dbbackend_zjadjacent`.`distance`, 
    `dbbackend_zjadjacent`.`azi1`, 
    `dbbackend_zjadjacent`.`azi2`, 
    `dbbackend_zjadjacent`.`has_inverse_adj`, 
    `dbbackend_zjadjacent`.`source_target_cgi`, 
    EXISTS(SELECT U0.`cellfrom_id`, 
            U0.`cellto_id`, 
            U0.`distance`, 
            U0.`azi1`, U0.`azi2`, 
            U0.`has_inverse_adj`, 
            U0.`source_target_cgi`, 
            ((4294967296 * U0.`cellto_id`) + U0.`cellfrom_id`) AS `iadj` 
        FROM `dbbackend_zjadjacent` U0 
        WHERE 
            ((4294967296 * U0.`cellto_id`) + U0.`cellfrom_id`) = 
            (`dbbackend_zjadjacent`.`source_target_cgi`)
    ) AS `equaladj` 
FROM `dbbackend_zjadjacent`

測試結果依然很慢，仔細分析sql語句，發現sql語句類似於迴圈，父查詢時外部迴圈，子查詢是內部迴圈，父查詢每執行一次都會執行一遍子查詢，整體相當於執行了 838118次子查詢，所以子查詢的語句需要儘量精簡，否則嚴重影響效率。

第二次修改，將annotate(iadj=2**32*F('cellto_id') + F('cellfrom_id'))從子查詢移出，放到父查詢中：

inverseadj = ZJadjacent.objects.filter(source_target_cgi=OuterRef('iadj'))

symmetricaladjsource = ZJadjacent.objects.annotate(iadj=2**32*F('cellto_id') + F('cellfrom_id')).annotate(equaladj=Exists(inverseadj))

等效sql：

SELECT 
    `dbbackend_zjadjacent`.`cellfrom_id`, 
    `dbbackend_zjadjacent`.`cellto_id`, 
    `dbbackend_zjadjacent`.`distance`, 
    `dbbackend_zjadjacent`.`azi1`, 
    `dbbackend_zjadjacent`.`azi2`, 
    `dbbackend_zjadjacent`.`has_inverse_adj`, 
    `dbbackend_zjadjacent`.`source_target_cgi`, 
    ((4294967296 * `dbbackend_zjadjacent`.`cellto_id`) + 
    `dbbackend_zjadjacent`.`cellfrom_id`) AS `iadj`, 
    EXISTS(SELECT U0.`cellfrom_id`, 
            U0.`cellto_id`, 
            U0.`distance`, 
            U0.`azi1`, 
            U0.`azi2`, 
            U0.`has_inverse_adj`, 
            U0.`source_target_cgi` 
        FROM `dbbackend_zjadjacent` U0 
        WHERE 
            U0.`source_target_cgi` = 
            (((4294967296 * `dbbackend_zjadjacent`.`cellto_id`) + 
            `dbbackend_zjadjacent`.`cellfrom_id`))
    ) AS `equaladj` 
FROM `dbbackend_zjadjacent`

再次後，效率明顯提升，執行count（）函式只需等待n秒左右。

symmetricaladjsource
<QuerySet [<ZJadjacent: 358036724510097538>, <ZJadjacent: 358036724510097539>, <ZJadjacent: 358036724510099847>, <ZJadjacent: 358036724510129025>, <ZJadjacent: 358036724510131843>, <ZJadjacent: 358036724510413443>, <ZJadjacent: 358036724510439042>, <ZJadjacent: 358036724510448771>, <ZJadjacent: 358036724510570881>, <ZJadjacent: 358036724532486657>, <ZJadjacent: 358036724532486659>, <ZJadjacent: 358036724532487426>, <ZJadjacent: 358036724532487427>, <ZJadjacent: 358036724532488449>, <ZJadjacent: 358036724532488450>, <ZJadjacent: 358036724532488451>, <ZJadjacent: 358036724532489217>, <ZJadjacent: 358036724532489218>, <ZJadjacent: 358036724532494337>, <ZJadjacent: 358036724532494342>, '...(remaining elements truncated)...']>
symmetricaladjsource[:100]
<QuerySet [<ZJadjacent: 358036724510097538>, <ZJadjacent: 358036724510097539>, <ZJadjacent: 358036724510099847>, <ZJadjacent: 358036724510129025>, <ZJadjacent: 358036724510131843>, <ZJadjacent: 358036724510413443>, <ZJadjacent: 358036724510439042>, <ZJadjacent: 358036724510448771>, <ZJadjacent: 358036724510570881>, <ZJadjacent: 358036724532486657>, <ZJadjacent: 358036724532486659>, <ZJadjacent: 358036724532487426>, <ZJadjacent: 358036724532487427>, <ZJadjacent: 358036724532488449>, <ZJadjacent: 358036724532488450>, <ZJadjacent: 358036724532488451>, <ZJadjacent: 358036724532489217>, <ZJadjacent: 358036724532489218>, <ZJadjacent: 358036724532494337>, <ZJadjacent: 358036724532494342>, '...(remaining elements truncated)...']>
symmetricaladjsource[:1000]
<QuerySet [<ZJadjacent: 358036724510097538>, <ZJadjacent: 358036724510097539>, <ZJadjacent: 358036724510099847>, <ZJadjacent: 358036724510129025>, <ZJadjacent: 358036724510131843>, <ZJadjacent: 358036724510413443>, <ZJadjacent: 358036724510439042>, <ZJadjacent: 358036724510448771>, <ZJadjacent: 358036724510570881>, <ZJadjacent: 358036724532486657>, <ZJadjacent: 358036724532486659>, <ZJadjacent: 358036724532487426>, <ZJadjacent: 358036724532487427>, <ZJadjacent: 358036724532488449>, <ZJadjacent: 358036724532488450>, <ZJadjacent: 358036724532488451>, <ZJadjacent: 358036724532489217>, <ZJadjacent: 358036724532489218>, <ZJadjacent: 358036724532494337>, <ZJadjacent: 358036724532494342>, '...(remaining elements truncated)...']>
symmetricaladjsource.count()
838118
symmetricaladjsource.filter(equaladj=True)
<QuerySet [<ZJadjacent: 358036724510097538>, <ZJadjacent: 358036724510097539>, <ZJadjacent: 358036724510099847>, <ZJadjacent: 358036724510131843>, <ZJadjacent: 358036724510413443>, <ZJadjacent: 358036724510448771>, <ZJadjacent: 358036724510570881>, <ZJadjacent: 358036724532486657>, <ZJadjacent: 358036724532486659>, <ZJadjacent: 358036724532487426>, <ZJadjacent: 358036724532487427>, <ZJadjacent: 358036724532488449>, <ZJadjacent: 358036724532488450>, <ZJadjacent: 358036724532488451>, <ZJadjacent: 358036724532489217>, <ZJadjacent: 358036724532489218>, <ZJadjacent: 358036724532494337>, <ZJadjacent: 358036724532494342>, <ZJadjacent: 358036724532498690>, <ZJadjacent: 358036724532498691>, '...(remaining elements truncated)...']>
symmetricaladjsource.filter(equaladj=True).count()
711252
symmetricaladjsource.filter(equaladj=False).count()
126866

 

相關django官方手冊連結：

Subquery() expressions

https://docs.djangoproject.com/en/2.1/ref/models/expressions/#subquery-expressions

Exists() subqueries

https://docs.djangoproject.com/en/2.1/ref/models/expressions/#exists-subqueries 

等效sql在pycharm中的位置：

相關推薦

如何提高MySql資料庫子查詢的效率

做django的專案，用python語言寫查詢資料庫的語句，使用OuterRef, Subquery，Exists，F建立複雜的查詢語句： 資料庫模型： from django.db import models # 經緯度唯一表 class LngLat(models.Model):

mysql in 子查詢 效率慢 優化（轉）

現在的CMS系統、部落格系統、BBS等都喜歡使用標籤tag作交叉連結，因此我也嚐鮮用了下。但用了後發現我想查詢某個tag的文章列表時速度很慢，達到5秒之久！百思不解(後來終於解決)，我的表結構是下面這樣的，文章只有690篇。 文章表article(id,title,content) 標籤表tag(tid,

讓天下沒有難用的資料庫 » 淺談mysql的子查詢

mysql的子查詢的優化一直不是很友好，一直有受業界批評比較多,也是我在sql優化中遇到過最多的問題之一，你可以點選這裡 ，這裡來獲得一些資訊，mysql在處理子查詢的時候，會將子查詢改寫,通常情況下，我們希望由內到外，也就是先完成子查詢的結果，然後在用子查詢來驅動外查詢的表，完成查詢，但是恰恰相反

讓天下沒有難用的資料庫 » 生產庫中遇到mysql的子查詢

使用過oracle或者其他關係資料庫的DBA或者開發人員都有這樣的經驗，在子查詢上都認為資料庫已經做過優化，能夠很好的選擇驅動表執行，然後在把該經驗移植到mysql資料庫上，但是不幸的是，mysql在子查詢的處理上有可能會讓你大失所望，在我們的生產系統上就由於碰到了這個問題： select  i_i

Mysql 子查詢效率優化

一、MySQL子查詢的位置        當一個查詢是另一個查詢的子部分是，稱之為子查詢（查詢語句中巢狀含有查詢語句）。子查詢也是使用頻率比較高的一種查詢型別。因此，優化子查詢，對於整個系統的效能也有直接的影響。        從查詢出現在SQL語句的位置

MySQL--5子查詢與連接小結

outer 比較運算符 limit 現在 order by select date ner 多表刪除 子查詢：出現在其他sql語句中的 SELECT，必須出現在小括號內，子查詢外層可以是常見的SELECT語句，INSERT語句 UPDATE語句 DELETE語句，在子查詢中

提高數據庫查詢效率的有效方法

效率 _for 字符型 獲得 強制 顯式 系統資源 blog nchar 1．對查詢進行優化，應盡量避免全表掃描，首先應考慮在 where 及 order by 涉及的列上建立索引。 2．應盡量避免在 where 子句中對字段進行 null 值判斷，否則將導致引擎放棄使

生產庫中遇到mysql的子查詢

.org href hid dba 情況 人員 使用 優化 弱點 使用過oracle或者其他關系數據庫的DBA或者開發人員都有這樣的經驗，在子查詢上都認為數據庫已經做過優化，能夠很好的選擇驅動表執行，然後在把該經驗移植到mysql數據庫上，但是不幸的是，mysql在子查詢的

mysql之子查詢作業

group by 準備 姓名 arch lte exists ins 語句 sql #數據準備drop table if exists class;create table class( class_no int(2) unsigned zerofill primar

MySQL資料庫時間查詢

1 /*當前時間加1毫秒*/ 2 SELECT DATE_ADD(NOW(),INTERVAL 1 MICROSECOND); 3 4 /*當前時間減1毫秒*/ 5 SELECT DATE_ADD(NOW(),INTERVAL -1 MICROSECOND); 6 7 /*當前時間加1

c# MVC框架 對mysql資料庫的查詢

using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Web.Mvc; using demo2.Models; using MySql.Data.

如何從mysql資料庫中查詢指定欄位且符合條件的資料 ，然後拼接成json字串，最後匯出json檔案

SELECT CONCAT("{'name':'",IFNULL(Name,''),"',","'sex':'",IFNULL(Sex,''),"',","'age':'",IFNULL(Age,''),"',", "'phone':'",IFNULL(Phon

mysql資料庫和查詢語句中欄位型別不匹配出現異常，查詢或更新多條的原因

說明 表結構和where查詢的欄位型別一致，均為字串或者是整數，不會型別轉化 表結構和where查詢的欄位型別不一致： 一個為TIMESTAMP或者是DATETIME，另一個為常量，常量會轉化為TIMESTAMP，再進行比較 一個為DECIMAL或者是整數，整數會轉化

資料庫SQL查詢效率in、exists、left join on、right join on 適用場景與比較

in 與 join例 select t1.id,sum(t1.num) from (select * from t2 where num =2) as t3 LEFT JOIN t1 on t3.id=t1.id GROUP BY t1.id; join 時間: 0.005

MySql資料庫連線查詢與自關聯(七)

先看個問題 問：查詢每個學生每個科目的分數 分析：學生姓名來源於students表，科目名稱來源於subjects，分數來源於scores表，怎麼將3個表放到一起查詢，並將結果顯示在同一個結果集中呢

MySql資料庫中查詢修改表中字元編碼（charset）的方法

MySQL字符集多種多樣，下面為您列舉了其中三種最常見的MySQL字符集檢視方法，該方法供您參考，希望對您學習MySQL資料庫能有所啟迪。 一、檢視MySQL資料庫伺服器和資料庫MySQL字符集。 mysql> show variables like '%char%

mysql資料庫模糊查詢(包含特使字元時)

mysql裡查詢 json 資料 1.mysql裡有個欄位儲存的是json格式的資料， 2.現在需要從頁面傳遞引數到php再進行搜尋匹配關鍵字， 3.將關鍵字頁json_encode後，去like匹配這個欄位，匹配不到   解決方案： 1.只針對中文搜尋，存的資料一

MYSQl資料庫的查詢手冊

–01 mysql 資料庫的操作 -- 連結資料庫 mysql -uroot -pmysql; -- 不顯示密碼 mysql -uroot -p -- 退出資料庫 --quit/exit/ctrl + d exit -- sql語句最後需要有分號;結尾

眼睜睜地踩到 MySQL in 子查詢的“坑”

前言 MySQL是專案中常用的資料庫，其中in查詢也是很常用。最近專案除錯過程中，遇到一個出乎意料的select查詢，竟然用了33秒！ 一、表結構 1. userinfo 表 2. article 表 二、問題SQL例項 select*fromuserinfowhereidin(selectau

mysql---where子查詢、form子查詢、exists子查詢

create table article(article_id int(3),article_title varchar(50),article_content text,article_comments int(3),articlecategory_id int(3) ); insert into arti