如果我有一个表单,用户可以在其中指定一组筛选器(例如productid > 5,can = "Applicances",Price > 3),那么做一个准备好的语句似乎很自然,比如:
SELECT *
FROM Products
WHERE
(@Price IS NULL OR Price > @Price) AND
(@Category IS NULL OR @Category = Category) AND
(@ProductID IS NULL OR Price > @Product);
然后添加@Price、@Price和@Pro
运行此查询时:
create table #test (field varchar(100))
insert into #test (field) values ('this is not a number')
insert into #test (field) values ('1234567')
select *
from ( select field
from #test
where ISNUMERIC(field) = 1
) as subquery
where
我遇到了一个特殊的脚本,它使用了一种特殊形式的equi连接。
SELECT *
FROM
per_assignments a, per_assigment_types b
WHERE
a.assignment_status_type_id + 0 = b.assignment_status_type_id
为什么在equi连接中添加了零?我知道这与避免索引搜索有关,但仍然有人可以解释相同的全貌。提前感谢
编辑:
它与表/列声明无关。据我所知,这与SQL调优有关。
我发现的是:-
在较小的索引搜索中使用--如通常所做的那样,这将一次搜索完整的表。
但是我真的不知道普通的equi连接到底有什
我在网上碰到了一个练习题,还没有找到令人满意的答案。
假设我们有两个表,如下所示
如果是这样,那么下面的SQL有什么问题呢?
SELECT Name
FROM Orders, Salesperson
WHERE Orders.salesperson_id = Salesperson.ID
GROUP BY salesperson_id
HAVING COUNT( salesperson_id ) >1
我从那里得到了这个问题
这个链接实际上有这个问题的答案和解释。
我想我理解这个解释,但我仍然认为这个查询应该运行时没有错误。而且结果也是准确的,因为没有重复的名称(salesperson
我们应该在join时检查硬编码值的条件吗?
select * from user u
inner join department d on d.id = u.id and d.id =1
where u.id = 1
如果是?“内部连接部门d on d.id = u.id and d.id = 1”和"where u.id =1“有什么不同。sql server内部发生了什么?
给定Sql Server 2012数据库中的以下视图:
create view vManyUnions as
select 1 as p, a from vSubQuery_1
union all
select 2 as p, a from vSubQuery_2
union all
select 3 as p, a from vSubQuery_3
...
union all
select n as p, a from vSubQuery_n
create view vSubQuery_1 as
select a fr
在带有where子句的select查询中,是否有可能在输出中检索一个谓词,其中一个谓词被计算为true,其中包含一个真正的元组?
例如,考虑到这个表:
Table person
name age hair_color
Tom 12 Brown
Bob 27 Black
Sam 20 Red
Ann 15 Blonde
John 30 Blonde
那个问题:
select *
from person
我正在使用的一个应用程序运行这样的查询:
SELECT
"categories"."id"
FROM
"categories"
WHERE
(
('f' )
OR categories.id NOT IN
(
SELECT
category_id
FROM
category_groups
)
);
这个查询需要非常长的时间才能完成,而且我还没有看到它完成。我们的“类别”表有659
我正在使用SQL Server2012 Standard,但在查询上使用CONTAINS子句时遇到了一些问题。
我的问题是:
select *
from
calles as c
INNER JOIN
colonias as col ON c.ID_Colonia = col.ID_Colonia
where
CONTAINS(c.Nombre,@Busqueda) OR CONTAINS(col.Nombre,@Busqueda)
如果我只使用一个包含,搜索时间大约是200ms,但如果我同时使用两个,它大约是10s (这是很长的时间)。我尝试了一种使用UNIO
考虑以下内容(半伪代码):
CREATE TABLE foobar (
id INT NOT NULL
message VARCHAR(40) NOT NULL
)
INSERT INTO foobar (1, "hello");
INSERT INTO foobar (2, "world");
my $resultset = "SELECT * FROM foobar";
while(!$resultset->EOF) {
"UPDATE foobar SET message='blah
我已经为某人接管了一个项目,目前我们正在尝试使应用程序可用,而不是担心如何才能做到这一点。尽管如此,光标似乎有一个问题,我无法弄清楚。游标中的select语句返回6行.
DECLARE testCursor cursor for
select r.fldcode, r.rescode, r.[class], f.[print], r.[r print], f.[requestor], r.[r requestor]
from field f INNER JOIN resv r
ON f.fldcode=r.fldcode
where f.requestor = &
在Server中,我似乎无法在WHERE子句中使用别名列名
这不管用
SELECT *, [dbo].[myFunc] (X.Prop1) AS Width
FROM X
WHERE Width > 0
我必须要做
SELECT *, [dbo].[myFunc] (X.Prop1) AS Width
FROM X
WHERE [dbo].[myFunc] (X.Prop1) > 0
我担心的是,SQL正在执行两次[dbo].[myFunc] (X.Prop1)。
我的问题是:
它是执行了两次还是SQL Server足够聪明?
在WHERE子句中有使用别名列的方法吗
首先,我知道使用来自table_a的值更新table_b的sql语句的形式是:
甲骨文:
UPDATE table_a
SET (col1, col2) = (SELECT cola, colb
FROM table_b
WHERE table_a.key = table_b.key)
WHERE EXISTS (SELECT *
FROM table_b
WHERE table_a.key = table_b.key)
M
我有以下LINQtoSQL语句
from t1 in __table1
join t2 in __table2 on t1.Id equals t2.OtherTableId
where t2.BranchId == branchId
&& !t1.IsPersonal
select t1.Id
这将生成以下SQL
SELECT DISTINCT [t0].[Id]
FROM [__table1] AS [t0]
INNER JOIN [__table2] AS [t1] ON [t0].[Id] = [t1].[OtherTableId]
WHERE ([t1].
在中,海报询问是否以及如何简化以下代码:
CREATE Procedure getAllEmployeesByDeptAndFlag
@Dept int,
@sal int,
@Flag int
AS
if @flag = 1
select Department, Salary
from employee
where Department = @dept and Salary > @sal
else
select Department, Salary
from employee
where Department = @dept
对此和
我有以下SQL:
IF EXISTS
(
SELECT
1
FROM
SomeTable T1
WHERE
SomeField = 1
AND SomeOtherField = 1
AND NOT EXISTS(SELECT 1 FROM SomeOtherTable T2 WHERE T2.KeyField = T1.KeyField)
)
RAISERROR ('Blech.', 16, 1)
SomeTable表大约有200,000行,而SomeOtherTable表有大约
如果where条款标准的顺序发生变化,是否有任何性能效益?
我的意思是。
我有一个选择查询,
SELECT * from mytable WHERE enabled = '1' AND type = 'pictures' AND category = 'family'
现在在上面的查询中
启用优先,在我的表中有95%的行是启用的。
类型次之,其中我的表包含75%的行,这些行的类型是图片。
类别在我的表中包含20%在家庭类别中的行之后。
所以我的问题是,如果我像这样订购where条款,我会看到任何好处吗?
SELECT * f
我有以下SQL语句:
SELECT *
FROM (
SELECT eu_dupcheck AS dupcheck
, eu_date AS threshold
FROM WF_EU_EVENT_UNPROCESSED
WHERE eu_dupcheck IS NOT NULL
UNION
SELECT he_dupcheck AS dupcheck
, he_date AS threshold
FROM WF_HE_HISTORY_EVENT
WHERE he_dupcheck IS NOT NULL
)
从同一个表中,什么是根据结果进行两种不同选择和生成布尔值的好方法。
可测
pKey | prodStatus
-----------------
1 | 0
2 | 0
,我想做这个
select count(pKey) from testable where pKey = 1 and prodStatus = 0
along with
select count(pKey) from testable where pKey = 2 and prodStatus = 0
If both results where 1 then `true` else `false`
是的,
我有一个名为MyTable的事件表,在这个表中我有一个MyTableId列,我们已经在该列上创建了索引。这个表有7000万行。现在,我已经创建了一个清除proc,它基于表类型集合MyTableCollection.清除事件。集合有100行limit.So,作为一个整体,我们可以一次清除100行。但是当我在proc中运行下面的查询时,它被卡住了40分钟。
DELETE FROM MyTable
WHERE MyTableId IN (SELECT MyTableId FROM TABLE(MyTableCollection))
当我使用硬编码值在查询上运行分析器时,
我现在正在使用一个运行在SQL server 2012上的相当神秘的DB (SAP),只选择权限,所以有些事情很难调试/优化。
我有一张大表“表1”,还有更小的表“表2”,“表3”。包含数百万行的大表将在"where“语句中最多被过滤为100行。
我得从table1开始。请您推荐:
select fields
from table1
left join table2
left join table3
where table1.field1 = 'x'
and table1.field2 = 'y'
或
Select
fields
f
我想运行一个过程来强制行上的行锁,但我不想向客户机返回结果集,也不想更新任何东西。下面是过程:
CREATE OR REPLACE PROCEDURE SP_LOCK_Row
(IDRow IN INTEGER)
IS
BEGIN
SELECT *
FROM TBLTable
WHERE IDRow = IDRow
FOR UPDATE;
END;
问题是我一直收到错误:PLS-00428: an INTO clause is expected in this SELECT statement。有没有一种方法可以锁定行,而不必真正将结果集返回给客户端?SQL Server的
我有一张有基本联系信息的人桌。我有很多条件可以从people表中选择Id值(字段称为pid)。
我想要匹配的记录(标准1或标准2)和标准3。
我希望条件语句将列添加到结果中。
我需要一种标准的方法来组装查询,因为我正在制作一个“搜索生成器”,所以我不能对每个组合进行优化。可以假定每个标准将返回零或一行。
EG1:我第一次尝试
SELECT people.*
FROM people
LEFT JOIN (criterion1 SELECT) c1 ON people.id=c1.pid
LEFT JOIN (criterion2 SELECT) c2 ON peo
假设我有一条sql语句,如下所示,在前面的代码中设置了变量@FOO:
SELECT FIELDLIST
FROM TABLE
WHERE
(FIELD = @FOO OR @FOO IS NULL)
查询优化器是否足够聪明,可以先执行OR的第二部分(@FOO为NULL),因为(另一个假设)执行null检查比进行字段比较更快?
我已经做了一些非正式的基准测试,我不仅看不到区别,而且我在尝试时得到了不同的结果时间,这使得我无法进行适当的比较。
我试图为我的上下文创建一个"AssociateWith“数据加载选项,以过滤当前用户可以访问的行。我的简单数据模型是这样的:
表
UserPermissions
PK: ID
FK: RelatedUserID可空
FK: RelatedItemID不可空
用户
PK: ID
项目
PK: ID
FK: RelatedCategoryID不可空
类别PK: ID
在我的数据文本中,我试图做这样的事情:
//dbContext is my LINQ context
//current_user_id is the id of my current logged in user
var
诚然,Title可能有点令人困惑,所以我将从一个示例开始。
我有一个包含大量数据的表。我正在将一个日期传递给一个存储过程,该存储过程将被用作非常标准的select上的where的一部分
@MinDate DATETIME
SELECT *
FROM MyTable
WHERE (@MinDate IS NULL OR DatePublished >= @MinDate)
这可以很好地工作,但是数据库是否为每条记录评估@MinDate?也就是说,它是否命中where并每次都必须检查null?如果是这样,是否可以更快地将其重构为:
@MinDate DATETIME
IF(@Min
我在SQL Server中对视图运行了一个相当复杂的查询,其形式如下:
SELECT *
FROM myview, foo, bar
WHERE shared=1 AND [joins and other stuff]
ORDER BY sortcode;
如上所示的查询计划显示了在最终SELECT之前的Sort操作,这是我所期望的。只有35条匹配记录,查询耗时不到2秒。
但是如果我添加TOP 30,查询几乎需要3分钟!使用SET ROWCOUNT同样很慢。
查看查询计划,现在似乎是在连接和筛选器之前对myview中的所有2+百万记录进行排序。
这种“排序”在查询计划上显示
我有几张桌子:
调用:行
用户:行
我需要得到所有的用户,没有电话,从日期:我如何得到它?或者哪种方式更好,为什么?
我知道三种方法:
第一:
SELECT id
FROM users
WHERE id NOT IN (SELECT user_id FROM calls where calls.created_at >= date)
第二(我认为这是不对的,但我不确定):
SELECT id
FROM users
LEFT OUTER JOIN calls
ON calls.user_id = users.id
WHERE calls.created_at >= date
是否有任何性能问题,使用操作的错过顺序?
就像1.所有的内连接先连接,然后所有的地方条件之后。
select * from
t1
inner join t2 on t1.t2Id = t2.Id
inner join t3 on t1.t3Id = t3.Id
inner join t4 on t2.t4Id = t4.Id
where
t1.Id in (1,2,3,4,5)
and t2.Id in (1,2,3,4,5,6,7)
and t3.Name like '%a'
所有表都有各自的位置
我对where条件感兴趣;如果我写:
Select * from table_name
where insert_date > '2010-01-03'
and text like '%friend%';
它是否与以下内容不同:
Select * from table_name
where text like '%friend%'
and insert_date > '2010-01-03';
我的意思是,如果表很大,有很多行,如果mysql首先接受符合条件“where insert_date >
我有一个列为table t的a int, b int, c int;复合index i (b, c)。我使用以下查询获取一些数据:
select * from t where c = 1 and b = 2;
所以问题是: MySQL和Postgres会使用索引i吗?而且,更普遍的情况是:查询组合where子句order是否会影响索引使用的可能性?
我想知道为什么分区剪枝不适用于横向连接和聚合。下面是我在PostgreSQL 12.1 (Ubuntu12.1-1.pgdg18.04+1)上测试的示例:
CREATE TABLE demo(key BIGINT) PARTITION BY LIST (key);
CREATE TABLE demo_key_1 PARTITION OF demo FOR VALUES IN (1);
CREATE TABLE demo_key_2 PARTITION OF demo FOR VALUES IN (2);
INSERT INTO demo(key) VALUES (1), (2);
ANALYZ