标签: query-optimization

我对以下内容感到困惑.我有一个大约1000万行的数据库,并且(在其他索引中)1列(campaignid_int)是一个索引.

现在我有700k行,其中campaignid确实是3835

对于所有这些行,connectionid是相同的.

我只是想找出这个连接.

 use messaging_db;
 SELECT     TOP (1) connectionid
 FROM         outgoing_messages WITH (NOLOCK)
 WHERE     (campaignid_int = 3835)

现在这个查询大约需要30秒才能执行!

我(用我的小数据库知识)会期望它会占用任何行,并返回给我那个connectionid

如果我为只有1个条目的广告系列测试同样的查询,那么它的速度非常快.因此索引有效.

我该如何解决这个问题,为什么这不起作用？

编辑:

estimated execution plan:

select (0%) - top (0%) - clustered index scan (100%)

我有一个MySQL查询(Ubu 10.04,Innodb,Core i7,16Gb RAM,SSD驱动器,MySQL params优化):

SELECT
COUNT(DISTINCT subscriberid)
FROM
em_link_data
WHERE
linkid in (SELECT l.id FROM em_link l WHERE l.campaignid = '2900' AND l.link != 'open')

表em_link_data有大约7百万行,em_link有几千行.此查询大约需要18秒才能完成.但是,如果我替换子查询的结果并执行此操作:

SELECT
COUNT(DISTINCT subscriberid)
FROM
em_link_data
WHERE
linkid in (24899,24900,24901,24902);

那么查询将在不到1毫秒的时间内运行.子查询单独运行不到1毫秒,列linkid被索引.

如果我将查询重写为连接,也不到1毫秒.为什么"IN"查询的子查询速度如此之慢以及为什么这么快的值？我无法重写查询(购买软件)所以我希望有一些调整或提示来加速这个查询!任何帮助表示赞赏.

我一直在构建rails应用程序,但不幸的是,我的应用程序都没有大量的数据或流量.但现在我有一个正在获得动力.因此,我首先考虑扩展和优化我的应用程序.

似乎第一个也是最简单的步骤是使用数据库索引.我有一个很好的索引列表,应该涵盖几乎所有的查询,但当我通过迁移将它们添加到我的数据库时,它只需要几秒钟来添加它们.出于某种原因,我认为他们必须经历我的所有条目(其中有数千条)并将它们编入索引.

这是否意味着我的索引尚未应用于我现有的数据？它们只会添加到新条目中吗？

另外,我正在研究其他扩展解决方案,例如memcached,以及减少我的查询等等.

如果有人能指出一些优秀的资源来优化我的rails 3 app我会非常感激!

谢谢!

编辑:

感谢关于数据库索引的所有好答案!在优化和扩展我的应用程序方面,我还应该注意什么？Memcached的？在优化方面,最佳性能提升/努力比是多少？

我读了包裹了很多SELECT入BEGIN TRANSACTION/COMMIT是一个有趣的优化.

但是,如果我PRAGMA journal_mode = OFF之前使用" ",这些命令真的是必要的吗？(如果我记得的话,禁用日志,显然也禁用交易系统.)

我的情况:

• 查询搜索大约90,000辆车
• 每次查询都需要很长时间
• 我已经在所有正在加入的字段上都有索引.

我该如何优化它？

这是查询:

SELECT vehicles.make_id,
       vehicles.fuel_id,
       vehicles.body_id,
       vehicles.transmission_id,
       vehicles.colour_id,
       vehicles.mileage,
       vehicles.vehicle_year,
       vehicles.engine_size,
       vehicles.trade_or_private,
       vehicles.doors,
       vehicles.model_id,
       Round(3959 * Acos(Cos(Radians(51.465436)) *
                         Cos(Radians(vehicles.gps_lat)) *
                                           Cos(
                                           Radians(vehicles.gps_lon) - Radians(
                                           -0.296482)) +
                               Sin(
                                      Radians(51.465436)) * Sin(
                               Radians(vehicles.gps_lat)))) AS distance
FROM   vehicles
       INNER JOIN vehicles_makes
         ON vehicles.make_id = vehicles_makes.id
       LEFT JOIN vehicles_models
         ON vehicles.model_id = vehicles_models.id
       LEFT JOIN vehicles_fuel
         ON vehicles.fuel_id = vehicles_fuel.id
       LEFT JOIN vehicles_transmissions
         ON vehicles.transmission_id = vehicles_transmissions.id
       LEFT JOIN vehicles_axles
         ON vehicles.axle_id = vehicles_axles.id
       LEFT JOIN vehicles_sub_years
         ON vehicles.sub_year_id = …

我试图得到以下查询可能需要多长时间的粗略(数量级)估计:

mysql> EXPLAIN SELECT t1.col1, t1_col4 FROM t1 LEFT JOIN t2 ON t1.col1=t2.col1 WHERE col2=0 AND col3 IS NULL;
+----+-------------+--------------------+------+---------------+------------+---------+-----------------------------+---------+--------------------------+
| id | select_type | table              | type | possible_keys | key        | key_len | ref                         | rows    | Extra                    |
+----+-------------+--------------------+------+---------------+------------+---------+-----------------------------+---------+--------------------------+
|  1 | SIMPLE      | t1                 | ref  | foobar        | foobar     | 4       | const                       | 9715129 |                          | 
|  1 | SIMPLE      | t2                 | ref  | col1          | col1       | 4       | db2.t1.col1                 |   42318 …

我有以下JOIN查询:

SELECT
    table1.*, 
    table2.*
FROM 
    Table1 AS table1 
LEFT JOIN 
    Table2 AS table2 
USING 
    (col1)
LEFT JOIN 
    Table3 as table3 
USING 
    (col1) 
WHERE 
    3963.191 * 
    ACOS(
    (SIN(PI() * $usersLatitude / 180) * SIN(PI() * table3.latitude / 180)) 
    +
    (COS(PI() * $usersLatitude / 180) * COS(PI() * table3.latitude / 180) * COS(PI() * table3.longitude / 180 - PI() * 37.1092162 / 180))
    ) <= 10 
AND 
    table1.col1 != '1' 
AND 
    table1.col2 LIKE 'A' 
AND 
    (table1.col3 LIKE 'X' OR table1.col3 LIKE 'X-Y') …

编辑:我已经更新了示例代码并提供了完整的表和视图实现以供参考,但基本问题仍未改变.

我在数据库中有一个相当复杂的视图,我试图查询.当我尝试通过将WHERE子句硬编码为特定外键值从视图中检索一组行时,视图执行速度非常快,并且具有最佳执行计划(正确使用索引等)

SELECT * 
FROM dbo.ViewOnBaseTable
WHERE ForeignKeyCol = 20

但是,当我尝试向查询添加参数时,我的执行计划突然崩溃了.当我运行下面的查询时,我正在获取索引扫描而不是遍布整个地方并且查询性能非常差.

DECLARE @ForeignKeyCol int = 20

SELECT * 
FROM dbo.ViewOnBaseTable
WHERE ForeignKeyCol = @ForeignKeyCol 

我正在使用SQL Server 2008 R2.什么给这里？使用导致次优计划的参数有什么用？任何帮助将不胜感激.

作为参考,这里是我得到错误的对象定义.

CREATE TABLE [dbo].[BaseTable]
(
    [PrimaryKeyCol] [uniqueidentifier] PRIMARY KEY,
    [ForeignKeyCol] [int] NULL,
    [DataCol] [binary](1000) NOT NULL
)

CREATE NONCLUSTERED INDEX [IX_BaseTable_ForeignKeyCol] ON [dbo].[BaseTable]
(
    [ForeignKeyCol] ASC
)

CREATE VIEW [dbo].[ViewOnBaseTable]
AS
SELECT
    PrimaryKeyCol,
    ForeignKeyCol,
    DENSE_RANK() OVER (PARTITION BY ForeignKeyCol ORDER BY PrimaryKeyCol) AS ForeignKeyRank,
    DataCol
FROM
    dbo.BaseTable

我确定窗口函数是问题,但我通过窗口函数分区的单个值过滤我的查询,所以我希望优化器先过滤然后运行窗口函数.它在硬编码示例中执行此操作,但不是参数化示例.以下是两个查询计划.最佳计划是好的,底层计划是坏的.

以下两个查询是子查询.两者都是一样的,两者都适合我.但问题是方法1查询需要大约10秒才能执行,而方法2查询需要不到1秒.

我能够将方法1查询转换为方法2,但我不明白查询中发生了什么.我一直试图弄清楚自己.我真的想了解下面两个查询之间的区别是什么以及性能增益是如何发生的？它背后的逻辑是什么？

我是这些先进技术的新手.我希望有人能在这里帮助我.鉴于我阅读的文档没有给我一些线索.

方法1:

SELECT
   *       
FROM
   tracker       
WHERE
   reservation_id IN (
      SELECT
         reservation_id                                 
      FROM
         tracker                                 
      GROUP  BY
         reservation_id                                 
      HAVING
         (
            method = 1                                          
            AND type = 0                                          
            AND Count(*) > 1 
         )                                         
         OR (
            method = 1                                              
            AND type = 1                                              
            AND Count(*) > 1 
         )                                         
         OR (
            method = 2                                              
            AND type = 2                                              
            AND Count(*) > 0 
         )                                         
         OR (
            method = 3                                              
            AND type = 0                                              
            AND Count(*) > 0 
         )                                         
         OR (
            method …

我试图理解火花的物理计划,但我不理解某些部分,因为它们看起来与传统的rdbms不同.例如,在下面的这个计划中,它是关于对hive表的查询的计划.查询是这样的:

select
        l_returnflag,
        l_linestatus,
        sum(l_quantity) as sum_qty,
        sum(l_extendedprice) as sum_base_price,
        sum(l_extendedprice * (1 - l_discount)) as sum_disc_price,
        sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge,
        avg(l_quantity) as avg_qty,
        avg(l_extendedprice) as avg_price,
        avg(l_discount) as avg_disc,
        count(*) as count_order
    from
        lineitem
    where
        l_shipdate <= '1998-09-16'
    group by
        l_returnflag,
        l_linestatus
    order by
        l_returnflag,
        l_linestatus;


== Physical Plan ==
Sort [l_returnflag#35 ASC,l_linestatus#36 ASC], true, 0
+- ConvertToUnsafe
   +- Exchange rangepartitioning(l_returnflag#35 ASC,l_linestatus#36 ASC,200), None
      +- ConvertToSafe
         +- TungstenAggregate(key=[l_returnflag#35,l_linestatus#36], functions=[(sum(l_quantity#31),mode=Final,isDistinct=false),(sum(l_extendedpr#32),mode=Final,isDistinct=false),(sum((l_extendedprice#32 * (1.0 - …