标签: common-table-expression

CTE(普通表表达式)vs Temp tables或Table variables,哪个更快？

我试图返回一个数据页面,并在一个存储过程中的所有数据的行计数,如下所示:

WITH Props AS
(
    SELECT *,
    ROW_NUMBER() OVER (ORDER BY PropertyID) AS RowNumber
    FROM Property
    WHERE PropertyType = @PropertyType AND ...
)   

SELECT * FROM Props 
WHERE RowNumber BETWEEN ((@PageNumber - 1) * @PageSize) + 1 AND (@PageNumber * @PageSize);

我无法返回行计数(最高行号).

我知道这已经讨论过了(我已经看过了: 使用row_number从查询中获取@@ rowcount的有效方法)但是当我在CTE中添加COUNT(x)OVER(PARTITION BY 1)性能降低并且上面的查询通常没有时间需要永远执行.我估计这是因为计算了每一行的数量？我似乎无法在另一个查询中重用CTE.Table Props有100k记录,CTE返回5k记录.

考虑以下

;WITH GetParentOfChild AS
    (
        SELECT 
            Rn = ROW_NUMBER() Over(Order By (Select 1))
            ,row_id AS Parents
            ,parent_account_id  As ParentId 
        FROM siebelextract..account
        WHERE row_id = @ChildId
        UNION ALL
        SELECT 
            Rn + 1
            ,a.row_id as Parents
            ,a.parent_account_id As ParentId    
        FROM siebelextract..account a
        JOIN GetParentOfChild gp on a.row_id = gp.ParentId
    )

SELECT TOP 1 @ChildId = Parents 
FROM GetParentOfChild
ORDER BY Rn DESC

它的作用是,给定任何一个孩子,它将返回根级父... ....程序完全正常工作...

出于好奇/实验的缘故,我将JOIN更改为Left Outer Join并报告

消息462,级别16,状态1,过程GetParent,第9行在递归公用表表达式'GetParentOfChild'的递归部分中不允许外连接.

我的问题是为什么CTE的递归部分不能接受Left Outer Join？它是按设计的吗？

谢谢

我有一组存储在我的数据库中的依赖项.我希望找到所有依赖于当前对象的对象,无论是直接还是间接.由于对象可以依赖于零个或多个其他对象,因此对象1依赖于对象9两次(9取决于4和5,两者都取决于1)是完全合理的.我想得到所有依赖于当前对象的对象的列表而不重复.

如果有循环,这会变得更复杂.没有循环,可以使用DISTINCT,虽然不止一次只通过长链来剔除它们仍然是一个问题.然而,对于循环,RECURSIVE CTE不会与它已经看到的东西结合变得很重要.

所以我到目前为止看起来像这样:

WITH RECURSIVE __dependents AS (
  SELECT object, array[object.id] AS seen_objects
  FROM immediate_object_dependents(_objectid) object
  UNION ALL
  SELECT object, d.seen_objects || object.id
  FROM __dependents d
  JOIN immediate_object_dependents((d.object).id) object
    ON object.id <> ALL (d.seen_objects)
) SELECT (object).* FROM __dependents;

(它在存储过程中,所以我可以传入_objectid)

不幸的是,当我之前在当前链中看到它时,这只是省略了一个给定的对象,如果递归CTE正在深度优先完成,那将会很好,但是当它是广度优先时,它会变得有问题.

理想情况下,解决方案将是SQL而不是PLPGSQL,但任何一个都可以.

举个例子,我在postgres中设置了这个:

create table objectdependencies (
  id int,
  dependson int
);

create index on objectdependencies (dependson);

insert into objectdependencies values (1, 2), (1, 4), (2, 3), (2, 4), (3, 4);

然后我尝试运行这个:

with recursive rdeps as ( …

当我尝试执行特定的递归CTE时,我收到以下错误:

Msg 240, Level 16, State 1, Line 8
Types don't match between the anchor and the recursive part in column "data_list" of recursive query "CTE".

这是无稽之谈.每个字段都明确地转换为VARCHAR(MAX).请帮我.我已经在这里和其他地方读过很多关于这个问题的答案,所有这些答案都明确地建议了这个问题.我已经这样做了,仍然得到错误.

此代码将重现错误:

if object_id('tempdb..#tOwner') IS NOT NULL drop table #tOwner;
CREATE TABLE #tOwner(id int identity(1,1), email varchar(max) );
insert into #towner values ( cast('123@123.321'  as varchar(max)));
insert into #towner values ( cast('tsql rage'    as varchar(max)));
insert into #towner values ( cast('another@e.c'  as varchar(max)));
insert into #towner values ( cast('einstein.x.m' as varchar(max)));

;WITH …

我正在尝试仅选择每个ID具有最高seq的行

ID  |  Seq   |  Age
-------------------
 A      1       20   
 A      2       30
 B      1       25
 B      2       32
 B      3       44
 B      4       48
 C      1       11

这似乎有效

SELECT ID, Age
FROM Persons a
WHERE Seq = (SELECT MAX(Seq) FROM Persons b WHERE a.ID = b.ID)

但这是最好的方式,唯一的方法吗？我不喜欢使用子查询,如果我不需要,我记得你可以使用一些东西,但我忘了它是什么.任何的想法？

只是感兴趣,为什么下面(简化)的例子以这种方式工作.

CREATE TABLE test (id SERIAL, val INT NOT NULL, PRIMARY KEY(id));
INSERT INTO test (val) VALUES (1);

WITH t AS ( UPDATE test SET val = 1 RETURNING id ) 
DELETE FROM test WHERE id IN ( SELECT id FROM t);

结果:
DELETE 0

问题:
为什么DELETE没有找到要删除的行？

PostgreSql版本9.2.1
事务隔离=读取提交

谢谢!

我正在开发一个店面Web应用程序.当潜在客户在网站上查看产品时,我想自动从数据库中建议一组类似的产品(与要求人员明确输入产品相似性数据/映射相比).

实际上,当您考虑它时,大多数店面数据库已经有很多可用的相似性数据.在我的情况下Products可能是:

• 映射到Manufacturer(又名Brand),
• 映射到一个或多个Categories,和
• 映射到一个或多个Tags(aka Keywords).

通过计算产品与所有其他产品之间共享属性的数量,您可以计算"SimilarityScore",以便将其他产品与客户正在查看的产品进行比较.这是我最初的原型实现:

;WITH ProductsRelatedByTags (ProductId, NumberOfRelations)
AS
(
    SELECT  t2.ProductId, COUNT(t2.TagId)
    FROM    ProductTagMappings AS t1 INNER JOIN
                ProductTagMappings AS t2 ON t1.TagId = t2.TagId AND t2.ProductId != t1.ProductId
    WHERE   t1.ProductId = '22D6059C-D981-4A97-8F7B-A25A0138B3F4'
    GROUP BY t2.ProductId
), ProductsRelatedByCategories (ProductId, NumberOfRelations)
AS
(
    SELECT  t2.ProductId, COUNT(t2.CategoryId)
    FROM    ProductCategoryMappings AS t1 INNER JOIN
                ProductCategoryMappings AS t2 ON t1.CategoryId = t2.CategoryId AND t2.ProductId != t1.ProductId
    WHERE   t1.ProductId = …

如何执行WITHsqlalchemy 中使用的SQL查询？

WITH foo AS (...), bar as (...) SELECT (...)

http://www.postgresql.org/docs/9.1/static/queries-with.html

使用postgres.

我有两个表(它们在下面定义,您可以使用下面的SQL来构建它们)

IF EXISTS (SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'ETab')
DROP TABLE ETab;
GO

CREATE TABLE ETab 
    ([MRN] varchar(20), [LSPEC] varchar(2), [ADT] DATETIME, [SDT] DATETIME, [Source] varchar(20), [Enum] varchar(20));
GO

INSERT INTO ETab ([MRN], [LSPEC], [ADT], [SDT], [Source], [Enum]) 
VALUES 
    ('HOMECARE',    'HM',       CONVERT(datetime, '2017-04-01 00:00:00.000', 20),   CONVERT(datetime, '2017-04-30 00:00:00.000', 20),   'PRODPAT',  'HOMEBLD04'),
    ('HOMECARE',    'HM',       CONVERT(datetime, '2017-05-01 00:00:00.000', 20),   CONVERT(datetime, '2017-05-31 00:00:00.000', 20),   'PRODPAT',  'HOMEBLD05'),
    ('HOMECARE',    'HM',       CONVERT(datetime, '2017-06-01 00:00:00.000', 20),   CONVERT(datetime, '2017-06-30 00:00:00.000', 20),   'PRODPAT',  'HOMEBLD06'),
    ('HOMECARE',    'HM',       CONVERT(datetime, …