标签: query-optimization

在SQLSERVER 2005中,我使用表值函数作为从大表(传递日期范围或此类参数)对子集数据执行任意聚合的便捷方式.

我在大型查询中使用这些作为联合计算,我想知道查询计划优化器是否在每种情况下都能很好地与它们配合使用,或者我是否更好地在我的大型查询中取消这样的计算.

1. 如果有意义,查询计划优化器是否会删除表值函数？
2. 如果没有,你建议什么,以避免手动取消它们会发生代码重复？
3. 如果是,您如何从执行计划中识别出来？

代码示例:

create table dbo.customers (
    [key] uniqueidentifier
    , constraint pk_dbo_customers
        primary key ([key])
)
go

/* assume large amount of data */
create table dbo.point_of_sales (
    [key] uniqueidentifier
    , customer_key uniqueidentifier
    , constraint pk_dbo_point_of_sales
        primary key ([key])
)
go

create table dbo.product_ranges (
    [key] uniqueidentifier
    , constraint pk_dbo_product_ranges
        primary key ([key])
)
go

create table dbo.products (
    [key] uniqueidentifier
    , product_range_key uniqueidentifier
    , release_date datetime
    , constraint pk_dbo_products 
        primary key ([key])
    , constraint fk_dbo_products_product_range_key …

我在寻找最有效的方式做出那样的"abcdefghijklmnop"字符串(长于15)出现这样的"ABCDEFGHIJKLM .." - 所有这一切MySQL查询里面.我不想在我的应用程序代码中处理它.

我知道我可以使用TOP关键字来限制收到结果的数量,但是有没有办法接收下一个让1000个结果使用类似的东西<give me the next 1000 results>给我每次下一个缓存的1000个？

假设我的查询有100000,第一次运行我得到1-1000我想收到1000-2000等等.

一个简单的查询,如下面的那个,在填充了大约2M行的表上正确索引,95 rows in set (2.06 sec)比我希望的要花费更长的时间来完成.

由于这是我第一次使用这种尺寸的桌子,我是否正在调查正常行为？

查询:

  SELECT t.id, t.symbol, t.feed, t.time, 
         FLOOR(UNIX_TIMESTAMP(t.time)/(60*15)) as diff
    FROM data as t 
   WHERE t.symbol = 'XYZ' 
     AND DATE(t.time) = '2011-06-02' 
     AND t.feed = '1M' 
GROUP BY diff  
ORDER BY t.time ASC;

......和Explain:

+----+-------------+-------+------+--------------------+--------+---------+-------+--------+----------------------------------------------+
| id | select_type | table | type | possible_keys      | key    | key_len | ref   | rows   | Extra                                        |
+----+-------------+-------+------+--------------------+--------+---------+-------+--------+----------------------------------------------+
|  1 | SIMPLE      | t     | ref  | unique,feed,symbol | …

根据下面的示例表,如何使用纯MySQL检索整个组的高低范围？可能吗？

表:

string    low    high
=====================
abc         1      10
abc        11      20
def         2       5
def         3       6

基本查询:( 显然这不起作用,但会是什么？)

SELECT * from `table` GROUP BY `string`;

如果可能,我想通过MySQL到达这里:

string    low    high
=====================
abc         1      20
def         2       6

我有一个列date和列表time_spent.我想为每个日期D找到一段时间内'time_spent'值的总和:(D-7-D),即.过去一周+当天.

我无法找到一种方法来做到这一点,因为我只能找到总和的例子而不是可变时间段的总和.

这是一个数据集示例:

CREATE TABLE rolling_total
(
  date date,
  time_spent int
);

INSERT INTO rolling_total VALUES ('2013-09-01','2'),
('2013-09-02','1'),
('2013-09-03','3'),
('2013-09-04','4'),
('2013-09-05','2'),
('2013-09-06','5'),
('2013-09-07','3'),
('2013-09-08','2'),
('2013-09-09','1'),
('2013-09-10','1'),
('2013-09-11','1'),
('2013-09-12','3'),
('2013-09-13','2'),
('2013-09-14','4'),
('2013-09-15','6'),
('2013-09-16','1'),
('2013-09-17','2'),
('2013-09-18','3'),
('2013-09-19','4'),
('2013-09-20','1'),
('2013-09-21','6'),
('2013-09-22','5'),
('2013-09-23','3'),
('2013-09-24','1'),
('2013-09-25','5'),
('2013-09-26','2'),
('2013-09-27','1'),
('2013-09-28','4'),
('2013-09-29','3'),
('2013-09-30','2')

结果如下:

date       | time_spent   | rolling_week_total
2013-09-01 |           2  |         2
2013-09-02 |           1  |         3
2013-09-03 |           3  |         6
2013-09-04 |           4  |        10
2013-09-05 |           2  | …

我有以下查询，它为每个查询获取id最新的N ：observationsstation

SELECT id
FROM (
  SELECT station_id, id, created_at,
         row_number() OVER(PARTITION BY station_id
                           ORDER BY created_at DESC) AS rn
  FROM (
      SELECT station_id, id, created_at
      FROM observations
  ) s
) s
WHERE rn <= #{n}
ORDER BY station_id, created_at DESC;

我有指标的id，station_id，created_at。

这是我想出的唯一解决方案，每个站可以获取多个记录。但是，它非常慢（81000条记录的表为154.0毫秒）。

如何加快查询速度？

一位同事声称他过去使用外键来优化查询.我认为仅在插入或更新表中的数据时才使用外键.我不知道它们如何用于加速搜索.

外键如何在创建执行计划时提供帮助？我错过了什么吗？如果是这样,那么它在什么情况下有帮助？

(我们使用PostgreSQL,我没有太多的经验.它有可能与Oracle或MySQL的行为不同吗？)

我有疑问打破了我网站的一个区域.尝试加载以下SQL语句时,该站点永远旋转!我是sql语句的新手,这个特定的语句是由另一个开发人员创建的.有没有办法优化以下声明？或者将其分解为较小的语句,以便更快地运行？我很茫然!我感谢任何帮助.

SELECT
    `wp_quiz_users`.`Id`,
    `wp_quiz_users`.`SessionId`,
    `wp_quiz_users`.`Score`,
    `wp_quiz_users`.`Date`,
    `wp_quiz_users`.`Referrer`,
    `wp_quiz_users`.`ContactData`,
    (SELECT
        SUM(`wp_quiz_users_answers`.`AnswerValue`) 
    FROM
        `wp_quiz_users_answers` 
    JOIN
        `wp_quiz_questions` 
            ON `wp_quiz_users_answers`.`QuestionId` = `wp_quiz_questions`.`id` 
    WHERE
        `wp_quiz_users_answers`.`UserId` = `wp_quiz_users`.`Id` 
        AND `wp_quiz_questions`.`Category` = 1) AS `SectionOne`,
    (SELECT
        SUM(`wp_quiz_users_answers`.`AnswerValue`) 
    FROM
        `wp_quiz_users_answers` 
    JOIN
        `wp_quiz_questions` 
            ON `wp_quiz_users_answers`.`QuestionId` = `wp_quiz_questions`.`id` 
    WHERE
        `wp_quiz_users_answers`.`UserId` = `wp_quiz_users`.`Id` 
        AND `wp_quiz_questions`.`Category` = 2) AS `SectionTwo`,
    (SELECT
        SUM(`wp_quiz_users_answers`.`AnswerValue`) 
    FROM
        `wp_quiz_users_answers` 
    JOIN
        `wp_quiz_questions` 
            ON `wp_quiz_users_answers`.`QuestionId` = `wp_quiz_questions`.`id` 
    WHERE
        `wp_quiz_users_answers`.`UserId` = `wp_quiz_users`.`Id` 
        AND `wp_quiz_questions`.`Category` = 3) AS `SectionThree`,
    (SELECT
        SUM(`wp_quiz_users_answers`.`AnswerValue`) 
    FROM
        `wp_quiz_users_answers` 
    JOIN
        `wp_quiz_questions` 
            ON `wp_quiz_users_answers`.`QuestionId` = `wp_quiz_questions`.`id` 
    WHERE
        `wp_quiz_users_answers`.`UserId` …

我正在尝试从具有1.94亿条记录的表中计算记录数。使用了并行提示和索引快速扫描，但仍然很慢。请为所附查询提出其他替代或改进建议。

SELECT
 /*+ parallel(cs_salestransaction 8)
 index_ffs(cs_salestransaction CS_SALESTRANSACTION_COMPDATE)
 index_ffs(cs_salestransaction CS_SALESTRANSACTION_AK1) */
 COUNT(1)
FROM cs_salestransaction
WHERE processingunitseq=38280596832649217
AND (compensationdate BETWEEN DATE '28-06-17' AND DATE '26-01-18'
OR eventtypeseq IN (16607023626823731, 16607023626823732, 16607023626823733, 16607023626823734));

这是执行计划：

[]

查询给出了结果，但花了2个小时才计算出1.94亿。

编辑：

修改过的代码可根据Littlefoot的建议添加DATE。使用实际列名编辑的代码。我是堆栈溢出的新手，因此已将计划作为映像进行了附加。