标签: query-optimization

当我优化我的2个单个查询以在不到0.02秒内运行然后UNION它们时,生成的查询需要超过1秒才能运行.此外,UNION ALL比UNION DISTINCT需要更长的时间.我认为允许重复会使查询运行得更快,而不是更慢.我真的最好分开运行2个查询吗？我更愿意使用UNION.

这两个陈述的表现完全不同:

mysql> explain select * from jobs  where createIndexed=false;
+----+-------------+-------+------+----------------------+----------------------+---------+-------+------+-------+
| id | select_type | table | type | possible_keys        | key                  | key_len | ref   | rows | Extra |
+----+-------------+-------+------+----------------------+----------------------+---------+-------+------+-------+
|  1 | SIMPLE      | jobs  | ref  | i_jobs_createIndexed | i_jobs_createIndexed | 1       | const |    1 |       | 
+----+-------------+-------+------+----------------------+----------------------+---------+-------+------+-------+
1 row in set (0.01 sec)

mysql> explain select * from jobs  where !createIndexed;
+----+-------------+-------+------+---------------+------+---------+------+-------+-------------+
| id | select_type | table | type | possible_keys | key …

在对具有非常高的I/O等待的服务器进行故障排除时,我注意到有很多I/O来自查询SELECT max(x) FROM t WHERE y = ?.

我的索引是btree (x, y).

我注意到查询计划执行Index Scan Backward以获得最大值.那不好吗？我应该担心这个并且可能添加另一个索引(反向)吗？或者有更好的方法来创建适合此类查询的索引吗？

这很奇怪.我正在尝试在MySQL中使用Views(对于具有Sybase和SQL Server的更多经验,我是MySQL的新手).无论如何,这个新项目我们都在使用MySQL,因为它似乎具有良好的性能.然而,为了简化Web前端的查询,我们决定创建一些视图,一切都运行良好,但它们需要永远运行.

视图非常简单,只是select语句(这些表中确实有几百万行).比如说这个查询:

SELECT CAST(classifier_results.msgDate as DATE) AS mdate
       ,classifier_results.objClass AS objClass
       ,COUNT(classifier_results.objClass) AS obj
       ,classifier_results.subjClass AS subjClass
       ,COUNT(classifier_results.subjClass) AS subj 
FROM classifier_results 
WHERE (classifier_results.msgDate >= (curdate() - 20)) 
GROUP BY 
  CAST(classifier_results.msgDate as DATE)
  ,classifier_results.objClass
  ,classifier_results.subjClass 
ORDER BY classifier_results.msgDate DESC

以正常方式运行时,大约需要1.5秒才能返回结果.

但是,当此查询被放入视图(按原样)时 - 即

CREATE VIEW  V1a_sentiment_AI_current AS    
SELECT CAST(classifier_results.msgDate as DATE) AS mdate
       ,classifier_results.objClass AS objClass
       ,COUNT(classifier_results.objClass) AS obj
       ,classifier_results.subjClass AS subjClass
       ,COUNT(classifier_results.subjClass) AS subj 
FROM classifier_results 
WHERE (classifier_results.msgDate >= (curdate() - 20)) 
GROUP BY 
  CAST(classifier_results.msgDate as …

假设我有一个像这样的SPARQL查询,寻找具有焦点资源的一些共享属性的资源,并且还获得关于焦点资源的一些其他陈述:

CONSTRUCT {
  ?focal pred:icate ?shared .
  ?other pred:icate ?shared .
}
WHERE {
  ?focal pred:icate ?shared ;
         more:info ?etc ;
         a "foobar" .
  ?other pred:icate ?shared .
}
LIMIT 500

如果有超过500个其他资源,LIMIT可能会排除该more:info语句和对象.那么,有没有办法说"我只想要最多500个?other",或者我是否必须将此查询分成多个部分？

我有这样的查询:

select * from (
    select * from TableX
    where col1 % 2 = 0
) subquery
where col1 % 4 = 0

实际的子查询更复杂.当我单独执行子查询时,它可以快速返回200个,但是当我执行整个查询时,等待时间太长.

我知道sql server在这里进行了一些优化,并将where语句合并到子查询中,并产生了效率不高的新执行计划.虽然我可以深入了解执行计划并分析为什么,如索引缺失,统计数据陈旧.

但我肯定知道,我的子查询作为BaseTable将只返回一小部分数据,所以我希望所有进一步的过滤或加入只会发生在这些小部分数据中.

我的问题是,我可以强制sql server首先执行子查询,而不关心外部where语句吗？(顺便说一句,TempTable是我的最后一个选择,CTE无效)

我有以下表和索引定义:

CREATE TABLE ticket
(
  wid bigint NOT NULL DEFAULT nextval('tickets_id_seq'::regclass),
  eid bigint,
  created timestamp with time zone NOT NULL DEFAULT now(),
  status integer NOT NULL DEFAULT 0,
  argsxml text,
  moduleid character varying(255),
  source_id bigint,
  file_type_id bigint,
  file_name character varying(255),
  status_reason character varying(255),
  ...
)

我在created时间戳上创建了一个索引,如下所示:

CREATE INDEX ticket_1_idx
  ON ticket
  USING btree
  (created );

这是我的疑问

select * from ticket 
where created between '2012-12-19 00:00:00' and  '2012-12-20 00:00:00'

这个工作正常,直到记录数量开始增长(约500万),现在它将永远回归.

解释分析揭示了这一点:

"Index Scan using ticket_1_idx on ticket  (cost=0.00..10202.64 rows=52543 …

EXPLAIN QUERY PLAN在SQLite 3中使用它有时会给我输出如

SEARCH TABLE staff AS s USING AUTOMATIC COVERING INDEX (is_freelancer=? AND sap=?) (~6 rows)

索引来自何处以及它的作用是什么？该表没有手动创建的索引.

我有这张桌子(500,000排)

CREATE TABLE IF NOT EXISTS `listings` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `type` tinyint(1) NOT NULL DEFAULT '1',
  `hash` char(32) NOT NULL,
  `source_id` int(10) unsigned NOT NULL,
  `link` varchar(255) NOT NULL,
  `short_link` varchar(255) NOT NULL,
  `cat_id` mediumint(5) NOT NULL,
  `title` mediumtext NOT NULL,
  `description` mediumtext,
  `content` mediumtext,
  `images` mediumtext,
  `videos` mediumtext,
  `views` int(10) unsigned NOT NULL,
  `comments` int(11) DEFAULT '0',
  `comments_update` int(11) NOT NULL DEFAULT '0',
  `editor_id` int(11) NOT NULL DEFAULT '0',
  `auther_name` varchar(255) DEFAULT NULL,
  `createdby_id` int(10) …

我正在使用 Postgres 数据库，我试图查看 1000000 行表上的索引扫描和顺序扫描之间的区别

描述表

\d grades 

然后解释分析 10 到 500000 之间的行

explain analyze select name from grades where pid between 10 and 500000 ; 

然后解释分析 10 到 600000 之间的行

explain analyze select name from grades where pid between 10 and 600000 ;

对我来说奇怪的是，为什么它在第一个查询中进行索引扫描，在第二个查询中进行顺序扫描，尽管它们通过索引中包含的同一列进行查询。