标签: sql-optimization

我有一个大数据表.该表中有1000万条记录.

这个查询的最佳方法是什么？

   Delete LargeTable where readTime < dateadd(MONTH,-7,GETDATE())

我有以下查询:

SELECT 
    analytics.source AS referrer, 
    COUNT(analytics.id) AS frequency, 
    SUM(IF(transactions.status = 'COMPLETED', 1, 0)) AS sales
FROM analytics
LEFT JOIN transactions ON analytics.id = transactions.analytics
WHERE analytics.user_id = 52094 
GROUP BY analytics.source 
ORDER BY frequency DESC 
LIMIT 10 

分析表有60M行,事务表有3M行.

当我EXPLAIN在这个查询上运行时,我得到:

+------+--------------+-----------------+--------+---------------------+-------------------+----------------------+---------------------------+----------+-----------+-------------------------------------------------+
| # id |  select_type |      table      |  type  |    possible_keys    |        key        |        key_len       |            ref            |   rows   |   Extra   |                                                 |
+------+--------------+-----------------+--------+---------------------+-------------------+----------------------+---------------------------+----------+-----------+-------------------------------------------------+
| '1'  |  'SIMPLE'    |  'analytics'    |  'ref' |  'analytics_user_id | analytics_source' |  'analytics_user_id' …

我们可以获得一系列基本优化技术(从建模到查询,创建索引,视图到查询优化).有一个列表,每个答案一个技术,这将是很好的.作为一个业余爱好者,我会发现这非常有用,谢谢.

为了不太模糊,假设我们使用的是MySQL或Oracle等maintstream数据库,并且数据库将在~10个表中包含500,000-1m左右的记录,其中一些具有外键约束,所有使用最典型的存储引擎(例如:InnoDB for MySQL).当然,定义PK等基础知识以及FK约束.

I have to update many columns in many rows in PostgreSQL 9.1. I'm currently doing it with many different UPDATE queries, each one that works on a different row (based on the primary key):

UPDATE mytable SET column_a = 12, column_b = 6 WHERE id = 1;
UPDATE mytable SET column_a = 1, column_b = 45 WHERE id = 2;
UPDATE mytable SET column_a = 56, column_b = 3 WHERE id = 3;

我必须做几千个这样的查询.

无论如何,我可以在PostgreSQL的一个查询中"批量更新"大量行吗？如果你正在使用INSERT,你可以一次插入多行:( INSERT INTO mytable …

我想从选择记录'2013-04-01 00:00:00'到'today',但是,每一天都有很多的价值,因为他们节省每次15分钟的值,所以我想只能从每天的第一个或最后一个值.

表模式:

CREATE TABLE IF NOT EXISTS `value_magnitudes` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `value` float DEFAULT NULL,
  `magnitude_id` int(11) DEFAULT NULL,
  `sdi_belongs_id` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
  `reading_date` datetime DEFAULT NULL,
  `created_at` datetime DEFAULT NULL,
  `updated_at` datetime DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=1118402 ;

错误的SQL:

SELECT value FROM `value_magnitudes` WHERE `value_magnitudes`.`reading_date` BETWEEN '2013-04-01 00:00:00' AND '2013-04-02 00:00:00' AND (`value_magnitudes`.magnitude_id = 234) LIMIT 1
SELECT value FROM `value_magnitudes` WHERE `value_magnitudes`.`reading_date` …

我相信我可以通过使用Left Outer Joins的case语句来优化这个sql语句.

但是我一直很难设置案例,一个用于总结代码类型AB,CD,另一个用于所有其他代码.

感谢您可以给我的任何帮助或提示.

update billing set payments = isnull(bd1.amount, payments)
, payments = case 
       when payments is null then 0 
       else payments 
     end
, charges = case 
        when bd2.amount is not null then charges 
        when charges is null then 0 
        else charges 
      end
, balance = round(charges + isnull(bd1.amount, bi.payments), 2) 
from billing bi 

left outer join (select inv, round(sum(bd1.bal), 2) amount 
                from "bill" bd1 
                where code_type = 'AB'
                 or code_type = 'CD' 
                group by inv) bd1 
                on …

我有以下数据库(简化):

CREATE TABLE `tracking` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `manufacture` varchar(100) NOT NULL,
  `date_last_activity` datetime NOT NULL,
  `date_created` datetime NOT NULL,
  `date_updated` datetime NOT NULL,
  PRIMARY KEY (`id`),
  KEY `manufacture` (`manufacture`),
  KEY `manufacture_date_last_activity` (`manufacture`, `date_last_activity`),
  KEY `date_last_activity` (`date_last_activity`),
) ENGINE=InnoDB AUTO_INCREMENT=401353 DEFAULT CHARSET=utf8

CREATE TABLE `tracking_items` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `tracking_id` int(11) NOT NULL,
  `tracking_object_id` varchar(100) NOT NULL,
  `tracking_type` int(11) NOT NULL COMMENT 'Its used to specify the type of each item, e.g. car, bike, etc',
  `date_created` …

我们在使用特定的SQL查询时遇到了性能问题，我们正在尝试找出如何在此处进行改进。它的执行时间大约是20-100秒！

这是查询，并进行了说明：

SELECT  "jobs".* FROM "jobs"
  WHERE "jobs"."status" IN (1, 2, 3, 4)
  ORDER BY "jobs"."due_date" ASC
  LIMIT 5;


Limit  (cost=0.42..1844.98 rows=5 width=2642) (actual time=16927.150..18151.643 rows=1 loops=1)
   ->  Index Scan using index_jobs_on_due_date on jobs  (cost=0.42..1278647.41 rows=3466 width=2642) (actual time=16927.148..18151.641 rows=1 loops=1)
         Filter: (status = ANY ('{1,2,3,4}'::integer[]))
         Rows Removed by Filter: 595627
 Planning time: 0.205 ms
 Execution time: 18151.684 ms

我们正在AWS RDS上使用PostgreSQL 9.6.11。

在一个表中，我们有约50万行。实现查询的字段是：

• due_date（没有时区的时间戳，可以为null）
• 状态（整数，不为null）

我们有以下索引：

CREATE INDEX index_jobs_on_due_date ON public.jobs USING btree (due_date)
CREATE INDEX index_jobs_on_due_date_and_status ON public.jobs USING …

我在优化 SQL Server 上的查询时遇到了我意想不到的问题。tblEvent数据库中有一个表，其中包含IntegrationEventStateId和ModifiedDateUtc。这些列有一个索引：

create index IX_tblEvent_IntegrationEventStateId_ModifiedDateUtc
on dbo.tblEvent (
    IntegrationEventStateId,
    ModifiedDateUtc
)

当我执行以下语句时：

select *
from dbo.tblEvent e
where
    e.IntegrationEventStateId = 1
    or e.IntegrationEventStateId = 2
    or e.IntegrationEventStateId = 5
    or (e.IntegrationEventStateId = 4 and e.ModifiedDateUtc >= dateadd(minute, -5, getutcdate()))

我得到了这个执行计划（注意索引没有被使用）：

但是当我执行这个语句时：

select *
from dbo.tblEvent e
where
    1 = e.IntegrationEventStateId
    or 2 = e.IntegrationEventStateId
    or 5 = e.IntegrationEventStateId
    or (4 = e.IntegrationEventStateId and e.ModifiedDateUtc >= dateadd(minute, -5, getutcdate()))

我得到了这个执行计划（注意索引确实被使用了）：

两个语句之间的唯一区别是where子句中的比较顺序。谁能解释为什么我得到不同的执行计划？ …

Spark-SQL我是读表格的新手Hive。我想知道Spark是如何执行多表的 Join。我在某处读到建议始终将最大的表保留在Join顺序的顶部等等，这样有利于Join效率。我读到，在 Join 中，Spark 按顺序将第一个表（最大的）加载到内存中，并流式传输另一个表，这有助于提高 Join 性能。但是，我对这种策略如何提高性能感到困惑，因为最大的表（在大多数情况下）无法容纳在内存中并溢出到磁盘上。

任何人都可以澄清并解释 Spark 在连接 [ largevs medium]、[ largevs small] 和 [ largevs large] 表时在连接类型 ( inner& outer) 和连接性能方面所采用的连接机制。我想知道在连接表排序方面应遵循的最佳实践，以实现 Spark 使用的所有连接策略（SMJ、ShuffleHash 和 Broadcast）的最佳性能。让我们假设以下查询：

select 
a.id, 
b.cust_nm, 
c.prod_nm
from large_tab a
join medium_tab b
on a.id = b.id
join small_tab c
on a.pid = c.pid;

注意：我们使用Spark 2.4

任何帮助深表感谢。谢谢。