标签: sql-optimization

为我撰写主题名称很难.但我可以举一个例子:

WHERE   (SELECT [ID_Line] FROM [Event] WHERE [Event].[Name]  = [A].[Col]) = 2
AND     (SELECT [DataType] FROM [Event] WHERE [Event].[Name]  = [A].[Col]) = 2

在这里我正在处理2个查询,当我真的需要这样的东西时:

WHERE   (SELECT [ID_Line],[DataType] FROM [Event] WHERE [Event].[Name]  = [A].[Col]) = 2,2

但SQL不适用于元组,所以我必须在这里进行内部连接吗？

我正在使用Oracle 10g.这是我的查询

select * from Entries 
where RefKey in (select RefKey 
                 from Entries 
                 where KeyStat = 1) 
and RefKey = Key;

这里RefKey,Key和KeyStat都被编入索引.该表在另一列上分区,此列未在此处使用.在此查询中,我选择当前活动的主密钥(如果RefKey =密钥然后是主密钥)(KeyStat = 1).以下是使用SQLTools 1.21 RC3的此查询的执行计划.

----------------------------------------------------------------------------------------------------------------------
| Id  | Operation                           | Name           | Rows  | Bytes | Cost (%CPU)| Time     | Pstart| Pstop |
----------------------------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT                    |                |     1 |   270 |   218K  (1)| 00:43:37 |       |       |
|   1 |  NESTED LOOPS SEMI                  |                |     1 |   270 |   218K  (1)| 00:43:37 | …

所以我必须处理一个没有索引的数据库(不是我的设计,它让我感到沮丧).我正在运行一个大约需要三秒钟才能返回的查询,我需要它更快.

以下是相关的表格和列:

gs_pass_data          au_entry            ground_station
  -gs_pass_data_id      -au_id              -ground_station_id
  -start_time           -gs_pass_data_id    -ground_station_name
  -end_time             -comments
  -ground_station_id

我的疑问是:

SELECT DISTINCT gs_pass_data_id,start_time,end_time,
  ground_station_name FROM gs_pass_data 
  JOIN ground_station
  ON gs_pass_data.ground_station_id =
  ground_station.ground_station_id 
  JOIN au_entry ON au_entry.gs_pass_data_id =
  gs_pass_data.gs_pass_data_id
WHERE (start_time BETWEEN @prevTime AND @nextTime) 
  AND comments = 'AU is identified.'
  ORDER BY start_time

我尝试过使用EXISTS代替DISTINCT而没有任何改进.我已经阅读了关于SQL优化的所有内容,但我似乎无法将此查询缩短到合理的时间(合理的<0.5秒).任何想法将不胜感激.

我正在尝试将提示应用于我的查询,但解释计划不会更改为正在使用的提示.

我的查询

select/*+ USE_HASH(master_flight)*/ bid, b.fno, seat, flight_date from
master_booking b, master_flight f where b.fno = f.fno and rownum <
120000

解释计划

119999 COUNT STOPKEY (cr=11336 pr=446 pw=0 time=240292 us)
119999 NESTED LOOPS (cr=11336 pr=446 pw=0 time=120236 us)
800 TABLE ACCESS FULL ASS2MASTER_FLIGHT (cr=936 pr=441 pw=0 time=22455 us)
119999 TABLE ACCESS CLUSTER ASS2MASTER_BOOKING (cr=10400 pr=5 pw=0 time=6858 us)
800 INDEX UNIQUE SCAN FNO_INDEX (cr=1600 pr=5 pw=0 time=4717 us)(object id 332468)

正如您所看到的,我正在强制集群使用散列连接而不是嵌套循环.但是解释计划仍然表明它正在使用嵌套循环.

我正在为PostgresQL 9.1开发Pg/PLSQL函数.当我在SQL查询中使用变量时,优化器会构建错误的执行计划.但是如果我用它的值替换变量,那么计划就可以了.例如:

v_param := 100;
select count(*)
  into result
  from <some tables>
 where <some conditions>
       and id = v_param

在3s内完成

和

select count(*)
  into result
  from <some tables>
 where <some conditions>
       and id = 100

在300ms内完成

在第一种情况下,优化器为任何v_param值生成固定计划.

在第二种情况下,优化器基于指定的值生成计划,尽管不使用计划缓存,但它的效率明显更高.

是否可以使优化器在没有动态绑定的情况下生成计划,并在每次执行查询时生成计划？

我知道这类问题已经多次发布在这里,例如:Java方式

我在标准树模式的数据(150K +)的大量(id,parent_id,some_data)

问题:如何获取给定node_id的叶子？

表结构:

CREATE TABLE `DATA_TREE` (
  `ID` int(11) NOT NULL,
  `PARENT_ID` int(11) NOT NULL,
  `DATA` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`ID`),
  UNIQUE KEY `ID_UNIQUE` (`ID`),
  KEY `fk_DATA_TREE_1_idx` (`PARENT_ID`),
  CONSTRAINT `fk_DATA_TREE_1` FOREIGN KEY (`PARENT_ID`) REFERENCES `DATA_TREE` (`ID`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB DEFAULT CHARSET=utf

数据库: MySQL 5.1.61

我需要更新 oracle 中包含 ~40*10^6 记录的巨大表。将修改的行数约为 10^7。确定将更新的行的查询很复杂并且涉及联接。仅识别将要更新的行的 ID 就需要 30 分钟。

Select p.some_id from
(select some_id, col2,col3 from t1 where col2='someVulue' and col3 ='someValue') p 
inner join (select some_id from t2 where t2.col3='someValue') q
on p.some_id=q.some_id

现在为了进行更新，我需要添加另一个联接或使用IN语句，这将使事情变得更糟。

有没有办法并行化这个？或者进行批量更新（每次更新25*10^4行）？有没有办法告诉oracle只更新前n行？然后 n->2n，然后 2n->3n ...？

该脚本将在生产环境中运行，因此表重建不是替代方案。

更新包括将布尔列设置为 true。（如果这有帮助）

我正在进行类似这样的查询,需要6秒才能完成:

select * 
from ( select aaa."ID" 
      from "aaa"  
      where aaa."DELETED" is null 
      order by aaa."CREATED" desc ) 
where rownum <= 15;

我的表中有大约160万条记录,我尝试在已删除的列和已创建的列中添加单独的索引,我尝试添加包含已创建和已删除的colunms的索引,并尝试创建相同的索引以不同的顺序.似乎没有任何帮助.我该怎么做才能加快速度呢？

我无法更改查询因为它是由hibernate生成的

编辑:即使没有aaa."DELETED" is null查询运行速度很慢.

编辑2:

编辑3:添加我的索引定义.老实说,我不知道大多数这些数字是什么意思,我使用sqldeveloper来创建索引.甚至不知道每个索引有如此多的配置选项,我现在将查看文档.

CREATE INDEX "aaa"."aaa_CREATED_ASC" ON "aaa"."aaa"
  (
    "CREATED"
  )
  PCTFREE 10 INITRANS 2 MAXTRANS 255 STORAGE
  (
    INITIAL 65536 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645 PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 BUFFER_POOL DEFAULT
  )
  TABLESPACE "SYSTEM" ;
CREATE INDEX "aaa"."aaa_CREATED_DESC" ON "aaa"."aaa"
  (
    "CREATED" DESC
  )
  PCTFREE 10 INITRANS …

我浏览了一些其他帖子并设法使我的查询运行得更快。但是，我对如何进一步优化此查询感到茫然。我将在一个网站上使用它，它会在页面加载时执行查询，但是 5.5 秒对于等待应该更简单的东西来说太长了。最大的表大约有 4,000,000 行，其他的每行大约有 400,000。

表结构

比赛

id BIGINT PRIMARY KEY,
region TEXT,
matchType TEXT,
matchVersion TEXT

团队

matchid BIGINT REFERENCES match(id),
id INTEGER,
PRIMARY KEY(matchid, id),
winner TEXT

冠军

id INTEGER PRIMARY KEY,
version TEXT,
name TEXT

物品

id INTEGER PRIMARY KEY,
name TEXT

参与者

PRIMARY KEY(matchid, id),
id INTEGER NOT NULL,
matchid BIGINT REFERENCES match(id),
championid INTEGER REFERENCES champion(id),
teamid INTEGER,
FOREIGN KEY (matchid, teamid) REFERENCES team(matchid, id),
magicDamageDealtToChampions REAL,
damageDealtToChampions REAL,
item0 TEXT,
item1 TEXT,
item2 …

我有一个正在尝试优化的存储过程，它接受表变量作为参数。表变量具有单个列，用于传入主键列表。测试时，我创建一个虚拟表变量，运行一堆 INSERT 语句向其中添加虚拟值，然后将其传递到存储过程中。这工作正常，但是当我想查看实际的查询执行计划时，SSMS 会为所有 INSERT 语句和存储过程编译查询计划。因此，如果我有 1000 个虚拟 INSERT 语句，SSMS 将崩溃。不幸的是，表变量必须与存储过程在同一批中执行，因此我无法批量启用/禁用查询计划。

有没有办法只编译存储过程的实际查询计划，忽略批处理中的所有 INSERT 语句？

它看起来是这样的：

DECLARE @dummyIds AS PrimaryKeyTable
INSERT INTO @dummyIds VALUES(1)
INSERT INTO @dummyIds  VALUES(2)
...
INSERT INTO @dummyIds VALUES(1000)

EXEC MyStoredProc @dummyIds

如果我执行包含实际查询计划的批处理，它将生成 1001 个查询计划，而我实际上只想要 1 个。

SQL Server 实例正在运行 SQL SERVER 2014。

我有一个mysql服务器.以下是有关服务器的信息:

# Variable_name, Value
innodb_version, 5.6.19
protocol_version, 10
slave_type_conversions, 
version, 5.6.19-log
version_comment, MySQL Community Server (GPL)
version_compile_machine, x86_64
version_compile_os, Linux

到目前为止,我有这张表:

CREATE TABLE `currency_rate_hist` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `currency_rate_id` bigint(20) NOT NULL,
  `date_from` datetime NOT NULL,
  `date_to` datetime DEFAULT NULL,
  `rate` decimal(10,4) unsigned NOT NULL,
  `date` datetime NOT NULL,
  `user` varchar(100) NOT NULL,
  `spread` decimal(12,10) NOT NULL DEFAULT '1.0000000000',
  `commercial_rate` decimal(12,10) NOT NULL,
  `tourism_rate` decimal(12,10) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `idx_currency_rate_hist_fromto` (`date_from`,`date_to`),
  KEY `fk_currency_rate_hist_cr` (`currency_rate_id`),
  CONSTRAINT `fk_currency_rate_hist_cr` …

我有一个必须使用 AWS Lambda 自动执行的查询，但首先我想对其进行优化。

这对我来说似乎是合法的，但我有这种感觉我可以做一些事情来改进它。

SELECT q_name, count(*)
FROM myTable
WHERE status = 2
AND DATEDIFF(mi, create_stamp, getdate()) > 1
GROUP BY q_name