我有一个非常复杂的MySQL查询,包括使用相同的子查询三次.MySQL实际上会运行子查询三次吗？(这是一个昂贵的.)如果是这样,有没有办法告诉MySQL保存或缓存结果,所以它不会这样做？我可以将数据保存在一个大型数组中,然后将其重新提供给MySQL,但我宁愿不将它移出并重新进入数据库.
这是三次出现的子查询:
SELECT id FROM programs
WHERE submitter_id=32 AND id in (
SELECT id FROM programs
WHERE feed_id=2478 AND id in (
SELECT program_id FROM playlist_program_map
WHERE playlist_id=181)))
这是查询出现的完整查询的示例:
SELECT object_id, programs.created AS created,
MATCH(text) AGAINST ('excellent ' IN BOOLEAN MODE) AS relevance
FROM comments_programs USE INDEX (text)
LEFT JOIN programs ON programs.id=object_id
WHERE object_id IN (
SELECT id FROM programs
WHERE 1 AND id IN (
SELECT id FROM programs
WHERE submitter_id=32 AND id in (
SELECT id FROM …我有两个表,一个vehicle带列的表:
idstockyearmakemodel和一个images包含列的表:
idvehicle_idnamecaptiondefault tinyint(1)我正在尝试列出车辆的信息,默认图像以及车辆的图像总数.目前我使用以下SELECT声明:
SELECT vehicle.id, vehicle.stock, vehicle.year,
vehicle.make, vehicle.model, images.name,
COUNT(images.id)
FROM vehicle
LEFT JOIN images
ON vehicle.id = images.vehicle_id
我最初使用的是:
ON vehicle.id = images.vehicle_id AND images.default = 1
但是,如果数据库中存在默认图像,则图像计数将仅为1或0.我尝试过使用UNION和其他SELECT语句,但我仍然无法得到正确的结果.我需要用两个SELECT语句或有另一种方式与处理呢JOIN还是UNION？
是否可以通过subselect实现LEFT JOIN的等效,其中需要多列.这就是我的意思.
SELECT m.*, (SELECT * FROM model WHERE id = m.id LIMIT 1) AS models FROM make m
现在这样做,这给了我一个'操作数应该包含1列'的错误.
是的我知道LEFT JOIN可以做到这一点,但我被告知可以通过subselect我很好奇它是如何完成的.
有没有办法在Oracle 11g中为子查询提供如下别名:
select *
from
(select client_ref_id, request from some_table where message_type = 1) abc,
(select client_ref_id, response from some_table where message_type = 2) defg
where
abc.client_ref_id = def.client_ref_id;
否则,有一种方法可以基于client_ref_id加入两个子查询.我意识到有一个自连接,但在数据库上我运行的自连接可能需要5分钟才能完成(在我运行的实际查询中有一些额外的逻辑,但我已确定自联接是什么导致问题).各个子查询只需几秒钟即可完成.自联接查询类似于:
select st.request, st1.request
from
some_table st, some_table st1
where
st.client_ref_id = st1.client_ref_id;
Hibernate提供(至少)两个选项来解决N + 1查询问题.一个是将FetchMode设置为Subselect,它在该IN子句中生成带有IN子句和子选择的选择.另一种是指定BatchSize,它生成一个带有包含父项ID的IN子句的select.
两者都有效但我发现Subselect选项经常遇到性能问题,因为查询父项很复杂.另一方面,使用大型BatchSize(比如1000),查询的数量和这些查询的复杂性非常小.
我的问题是:你何时会在BatchSize上使用Hibernate的Subselect FetchMode？如果您有非常多的父条目(数千),则子选择可能有意义,但是在其他任何情况下您更喜欢Subselect到BatchSize吗？
编辑:我注意到在处理急切加载时两者之间存在差异.如果您将xToMany关联设置为热切地并通过子选择加载,则会生成一个子选择,就像它是懒惰一样.但是,如果指定BatchSize,则生成的查询将使用外部联接而不是单独的查询.有没有办法迫使Hibernate在急切加载时使用单独的批量查询？
我可以用两种方式使用聚合函数编写查询:
select team, count(min) as min_count
from table
group by team
having count(min) > 500
要么
select *
from (
select team, count(min) as min_count
from table
group by team
) as A
where A.min_count > 500
这两种方法是否有任何性能优势,或者它们在功能上是否相同？
我有一个存储过程select * from book table,使用子查询我的查询是
USE [library]
GO
/****** Object: StoredProcedure [dbo].[report_r_and_l] Script Date: 04/17/2013 12:42:39 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER procedure [dbo].[report_r_and_l]
@fdate date,
@tdate date,
@key varchar(1)
as
if(@key='r')
select *
from dbo.books
where isbn =(select isbn from dbo.lending where (act between @fdate and @tdate) and (stat ='close'))
else if(@key='l')
select *
from dbo.books
where isbn =(select isbn from dbo.lending where lended_date between @fdate and @tdate)
我知道子查询返回多个查询到主查询,但我不知道如何避免这个错误,任何人都可以帮助我吗？
我试图寻找我的问题的答案,但没有得到实际帮助的答案.我写了一个sql代码,但似乎无法找到问题所在.是否可以在"FROM"部分放置子查询？
SELECT S2.ITEM,
S1.SHOP_ORDER,
S1.OPERATION_NO,
S1.START_DATE,
S1.QTY_GOODS,
S1.QTY_ENTERED,
S1.QTY_MRB
FROM (SELECT SHOP_ORD_RPT.OPERATION_NO,
SHOP_ORD_RPT.SHOP_ORDER
FROM FLAME.SHOP_ORD_RPT
WHERE SHOP_ORD_RPT.OPERATION_NO = 110
OR SHOP_ORD_RPT.OPERATION_NO = 370) AS S1
JOIN (SELECT SHOP_ORD.SHOP_ORDER
FROM FLAME.SHOP_ORD
WHERE SHOP_ORD.ITEM = '3A2375'
OR SHOP_ORD.ITEM = '3A2703')AS S2
ON S1.SHOP_ORDER = S2.SHOP_ORDER;
我在运行脚本时收到的错误是:
SQL命令未正确结束
如果有人能提供帮助我会很感激.非常感谢 - 露丝
我一遍又一遍地使用相同的SQL模式,我知道必须有更好的方法,但我无法将它拼凑在一起.这是模式的一个简单版本,我将撤回学生的信息和他们签出的最后一本书(如果存在的话):
SELECT TStudents.*,
BookName = (SELECT TOP 1 BookName
FROM TBookCheckouts
WHERE StudentID = TStudents.ID
ORDER BY DateCheckedOut DESC),
BookAuthor = (SELECT TOP 1 BookAuthor
FROM TBookCheckouts
WHERE StudentID = TStudents.ID
ORDER BY DateCheckedOut DESC),
BookCheckout = (SELECT TOP 1 DateCheckedOut
FROM TBookCheckouts
WHERE StudentID = TStudents.ID
ORDER BY DateCheckedOut DESC)
FROM TStudents
(为了这个例子,请忽略TBookCheckouts应该分成TCheckouts和TBooks的事实)
我想说明的是:我倾向于为同一个表中的列提供大量子查询.我也倾向于需要按日期对这些子查询表进行排序以获得最新记录,因此对于LEFT JOIN来说,这并不是那么简单(至少对我而言).但是请注意,除了返回哪个字段之外,我基本上做了3次相同的子查询.SQL Server可能足够聪明以优化它,但我不这么认为(我肯定需要在阅读执行计划方面做得更好......).
虽然以这种方式构造它可能是有利的(如果我有大量的子查询和子表,有时这最终会更具可读性),但这似乎并不是特别有效.
我已经考虑从派生表执行LEFT JOIN,可能包含ROW_NUMBER()和PARTITION BY,但我似乎无法将它们拼凑在一起.
好的,这里需要一个MySQL大师.我正在尝试编写一个查询,当有人对您之前评论过的项目发表评论时,该查询将作为通知系统.'drinkComment'表非常简单:
commentID, userID, drinkID, datetime, comment
我写了一个查询,它将获得我之前评论过的所有关于饮料的评论(这不是我的评论),但它仍会显示我评论之前发生的评论.这与我认为可行的一样接近,但事实并非如此.请帮忙!
select @drinkID:=drinkComments.drinkID, commentID, drinkID, userID, comment, datetime
FROM drinkComments
WHERE `drinkID` IN
( select distinct drinkID from drinkComments where drinkComments.userID = 1)
AND drinkComments.dateTime > (
/*This gets the last date user commented on the main query's drinkID*/
select datetime FROM drinkComments WHERE drinkComments.userID = 1 AND drinkComments.drinkID = @drinkID ORDER BY datetime DESC LIMIT 1
)
ORDER BY datetime DESC