标签: query-optimization

我已经在一个网络项目(asp.net)工作了大约六个月.最终产品即将投入使用.该项目使用SQL Server作为数据库.我们已经做了性能测试与一些大容量的数据,结果表明,当数据过大,性能会下降,如2万行(超时问题,延迟反应变量等).起初我们使用完全normailized数据库,但现在我们把它归部分由于性能问题(以减少联接).首先,这是正确的决定吗？另外,当数据量变得非常大时,可能的解决方案是什么？客户未来会增加多少？

我想进一步补充:

• 200万行是实体表,解析关系的表有更大的行.
• 数据+否时性能下降.用户增加
• 在识别频繁使用的查询之后进行非规范化.
• 我们还使用了大量的xml列和xquery.这可能是原因吗？
• 有点偏离主题,我的项目中的一些人说动态SQL查询比存储过程方法更快.他们已经做了某种性能测试来证明他们的观点.我认为情况恰恰相反.一些使用频繁的查询是动态创建的,因为大多数其他查询都封装在存储过程中.

我有一个非常大(超过80万行)的非规范化MySQL表.简化的架构如下所示:

+-----------+-------------+--------------+--------------+
|    ID     |   PARAM1    |   PARAM2     |   PARAM3     |
+-----------+-------------+--------------+--------------+
|    1      |   .04       |    .87       |    .78       |
+-----------+-------------+--------------+--------------+
|    2      |   .12       |    .02       |    .76       |
+-----------+-------------+--------------+--------------+
|    3      |   .24       |    .92       |    .23       |
+-----------+-------------+--------------+--------------+
|    4      |   .65       |    .12       |    .01       |
+-----------+-------------+--------------+--------------+
|    5      |   .98       |    .45       |    .65       |
+-----------+-------------+--------------+--------------+

我试图看看是否有一种优化查询的方法,其中我将权重应用于每个PARAM列(权重在0和1之间),然后将它们平均得出计算值SCORE.然后我想ORDER BY计算出的SCORE列.

例如,假设PARAM1的权重为.5,PARAM2的权重为.23,PARAM3的权重为.76,您最终会得到类似于:

SELECT ID, ((PARAM1 * .5) + (PARAM2 * .23) + (PARAM3 * .76)) / 3 …

我的查询有一个连接,看起来它使用两个索引,这使它更复杂.我不确定我是否能改进这一点,但我想我会问.

该查询生成一个记录列表,其中包含与要查询的记录类似的关键字.

这是我的查询.

SELECT match_keywords.padid,
       COUNT(match_keywords.word) AS matching_words
FROM   keywords current_program_keywords
       INNER JOIN keywords match_keywords
         ON match_keywords.word = current_program_keywords.word
WHERE  match_keywords.word IS NOT NULL
       AND current_program_keywords.padid = 25695
GROUP  BY match_keywords.padid
ORDER  BY matching_words DESC
LIMIT  0, 11  

解释

Word是varchar(40).

如果知道列的结果只有两个候选值,

ifnull(a, b) as a_or_b_1

和

coalesce(a, b) as a_or_b_2

会给出相同的结果.但哪个更快？在搜索时我发现了这篇文章,其中说ifnull更快.但这是我找到的唯一一篇文章.对此有何看法？

提前致谢 :)

我试图强制MySQL使用两个索引.我正在加入一个表,我想利用两个索引之间的交叉.具体术语是使用交叉,这里是MySQL文档的链接:

http://dev.mysql.com/doc/refman/5.0/en/index-merge-optimization.html

有没有办法强制执行此功能？我的查询是使用它(它加速了),但现在无论出于什么原因它已停止.

这是我想要做的JOIN.我希望查询使用的两个索引是scs.CONSUMER_ID_1和scs_CONSUMER_ID_2

JOIN survey_customer_similarity AS scs
    ON cr.CONSUMER_ID=scs.CONSUMER_ID_2 
    AND cal.SENDER_CONSUMER_ID=scs.CONSUMER_ID_1 
    OR cr.CONSUMER_ID=scs.CONSUMER_ID_1 
    AND cal.SENDER_CONSUMER_ID=scs.CONSUMER_ID_2

我在MySQL数据库中有下表:

CREATE TABLE `secondary_images` (
  `imgId` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `primaryId` int(10) unsigned DEFAULT NULL,
  `view` varchar(255) DEFAULT NULL,
  `imgURL` varchar(255) DEFAULT NULL,
  `imgDate` datetime DEFAULT NULL,
  PRIMARY KEY (`imgId`),
  KEY `primaryId` (`primaryId`),
  KEY `imgDate` (`imgDate`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 ;

SQL将如下:

SELECT imgURL, view FROM secondary_images 
WHERE primaryId={$imgId} ORDER BY imgDate DESC

正如您所看到的,我创建了primaryId和imgDate索引键.我背后的想法是因为该WHERE子句使用the primaryId和ORDER子句使用查询结果imgDate.

我的问题是,现在使用多重索引会更好吗？或者我应该选择多列索引(目前我还不太了解)？

这是我从EXPLAIN得到的:

id = 1   
select_type = simple      
table = secondary_images         
type = …

我使用MySQL版本5.5.14 从500万行的表中运行以下查询QUERY 1:

SELECT P.ID, P.Type, P.Name, P.cty
     , X(P.latlng) as 'lat', Y(P.latlng) as 'lng'
     , P.cur, P.ak, P.tn, P.St, P.Tm, P.flA, P.ldA, P.flN
     , P.lv, P.bd, P.bt, P.nb
     , P.ak * E.usD as 'usP' 
FROM PIG P 
  INNER JOIN EEL E 
    ON E.cur = P.cur 
WHERE act='1' 
  AND flA >= '1615' 
  AND ldA >= '0' 
  AND yr >= (YEAR(NOW()) - 100) 
  AND lv >= '0' 
  AND bd >= '3' 
  AND bt >= '2' 
  AND nb <= '5' …

我正在努力优化一些使用频繁的存储过程并遇到一个场景,提出了一个我无法找到任何答案的问题:在存储过程中评估TSQL时,SQL Server是否会使IF语句短路？

例如,假设存储过程的代码类似于:

IF @condition1 = 1
OR EXISTS(SELECT 1 FROM table1 WHERE column1 = @value1)
...

在这种情况下,SQL Server是否会使评估短路,以便EXISTS在前面的子句计算结果为true时从不执行该语句？

如果它从未或有时只是,那么我们就会有一些重写.

我刚刚向ElasticSearch介绍了重要的术语聚合,并且对这个度量标准的优秀和相关程度感到非常惊讶.对于那些不熟悉它的人来说,这是一个非常简单的概念 - 对于给定的查询(前景集),给定的属性根据背景集的统计显着性进行评分.

例如,如果我们要查询英国交通警察中最重要的犯罪类型:

C = 5,064,554 -- total number of crimes
T =    66,799 -- total number of bicycle thefts
S =    47,347 -- total number of crimes in British Transport Police
I =     3,640 -- total number of bicycle thefts in British Transport Police

通常,自行车盗窃仅占犯罪的1%(66,799/5,064,554),但对于处理铁路和车站犯罪的英国交通警察来说,7%的犯罪(3,640/47,347)是自行车盗窃.频率增加了7倍.

"自行车盗窃"的意义在于 [(I/S) - (T/C)] * [(I/S) / (T/C)] = 0.371...

哪里:

• C是集合中所有文档的编号
• S是与查询匹配的文档数
• T是具有特定术语的文档数
• 我是与S和T相交的文档数

由于实际原因(我拥有大量的数据和巨大的ElasticSearch内存要求),我希望在SQL中或直接在代码中实现重要的术语聚合.

我一直在寻找一些方法来潜在地优化这种查询,特别是降低内存需求和提高查询速度,但代价是一些错误余量 - 但到目前为止我还没有破解它.在我看来,这:

• 变量C和S …

我已经开始研究一个项目,那里有一个相当大的表(大约82,000,000行),我觉得它非常臃肿.其中一个字段定义为:

consistency character varying NOT NULL DEFAULT 'Y'::character varying

它用作布尔值,值应始终为('Y'|'N').

注意:没有检查约束等.

我试图找出理由改变这个领域的理由.这是我有的:

• 它被用作布尔值,所以就这样吧.显式优于隐式.
• 它将防止编码错误,因为现在任何可以转换为文本的内容都会在那里盲目进行.

这是我的问题.

• 尺寸/存储怎么样？db是UTF-8.所以,我认为在这方面确实没有多少节省.对于a boolean,它应该是1个字节,而对于'Y'UTF-8中的a 应该是1个字节(至少这是我在Python中检查长度时得到的).这里是否还有其他存储空间可以保存？
• 查询性能？Postgres会因" =TRUE"与" ='Y'"的原因而获得任何性能提升吗？