标签: query-optimization

每个sql语句都有提示吗？我们有一个关于它的dba,并要求我们在存储过程中的每个选择和更新语句上添加提示.这真的有必要吗？

在Pavel的页面上有以下功能:

CREATE OR REPLACE FUNCTION makedate(year int, dayofyear int)
RETURNS date AS $$
SELECT (date '0001-01-01' + ($1 - 1) * interval '1 year' + ($2 - 1) * interval '1 day'):: date
$$ LANGUAGE sql;

我有以下代码:

makedate(y.year,1)

PostgreSQL在给定年份的1月1日创建日期的最快方法是什么？

帕维尔的功能会让我相信它是:

date '0001-01-01' + y.year * interval '1 year' + interval '1 day';

我的想法更像是:

to_date( y.year||'-1-1', 'YYYY-MM-DD');

我正在寻找使用PostgreSQL 8.4的最快方式.(使用日期函数的查询可以选择100,000到100万条记录,因此需要速度.)

谢谢!

在Oracle查询中是否有任何方法可以在其外部的子查询中引用列,或者即使通过不同的方式实现该效果？到目前为止,我在网上看到的所有东西都没有帮助.

例如(这是我想要的事情):

SELECT a.product_code, b.received, b.issued
FROM productinfo a,
 (SELECT SUM(qty_received) AS received, SUM(qty_issued) AS issued
  FROM productdetail b WHERE b.product_code = a.product_code AND active = 1);

我已经尝试了大量不同的变体/组合当我得到像ORA-00904这样的错误:与WHERE子句关系有关的无效标识符.

目前,如果我作为单独的查询运行,例如:

SELECT product_code FROM productinfo;

然后为每个记录:

SELECT SUM(qty_received) AS received, SUM(qty_issued) AS issued FROM productdetail
WHERE product_code = '(specified)' AND active = 1;

这可能需要半个多小时来运行8000个记录,这只是简单的愚蠢.

用完头发,任何帮助赞赏!! 谢谢.

我在Oracle数据库中有一个表,其中包含时间戳列nextTime和字符串列destName.还有更多列,但在这种情况下只有这两个列相关.我正在尝试设计一个查询,它将在特定的时间间隔内返回具有nextTime的不同destName,并且返回的行数应该最多为1000.当区间内有超过一千个不同的destName时,我希望查询返回一千行,而不是更多或更少.

我实际上有一个正在运行的查询,但它太慢了:

select destName 
from (select /*+ index(tblDestNames tbldestnames_destname)*/ distinct destName
from (select /*+ index(tblDestNames tbldestnames_nextTime)*/ destName
from tblDestNames 
where nextTime < :1 and nextTime >= :2 and destName is not null)) 
where rownum <= 1000; 

关于如何设计更智能的查询或如何优化这种现有查询的任何想法都非常感谢.

我可以重复使用复杂的选择Where子句到不同的组吗？

我在做什么:

(Select X, Count(*) From [Big where clause with many tables] Group By X)
Union All
(Select Y, Count(*) From [Big where clause with many tables] Group By Y)

我怎么能选择这个呢？

我正在使用SQL Server 2008,这将进入一个函数,但可能是一个存储过程.

我正在尝试运行我认为对相当大的数据集进行简单查询,并且需要很长时间才能执行 - 它在"发送数据"状态中停留3-4小时或更长时间.

该表如下所示:

CREATE TABLE `transaction` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
`uuid` varchar(36) NOT NULL,
`userId` varchar(64) NOT NULL,
`protocol` int(11) NOT NULL,
... A few other fields: ints and small varchars
`created` datetime NOT NULL,
PRIMARY KEY (`id`),
KEY `uuid` (`uuid`),
KEY `userId` (`userId`),
KEY `protocol` (`protocol`),
KEY `created` (`created`)
) ENGINE=InnoDB AUTO_INCREMENT=61 DEFAULT CHARSET=utf8 ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=4 COMMENT='Transaction audit table'

查询在这里:

select protocol, count(distinct userId) as count from transaction
where created > '2012-01-15 23:59:59' and created …

我的数据库有以下架构:

class Product(models.Model):
    pass

class Tag(models.Model):
    product = models.ForeignKey(Product)
    attr1 = models.CharField()
    attr2 = models.CharField()
    attr3 = models.CharField()

class AlternatePartNumber(models.Model):
    product = models.ForeignKey(Product)

换句话说,a Product有很多Tags,而a Product有很多AlternatePartNumbers. Tags是一组属性的集合Product.

给定a中的三个属性Tag,我想选择Product匹配的s(可能多于一个),以及AlternatePartNumber每个产品的所有s.

目前我这样做:

# views.py
results = Tag.objects.
    filter(attr1=attr1).
    filter(attr2=attr2).
    filter(attr3=attr3)

# a template
{% for result in results %}
    {% for alternate in result.product.alternatepartnumber_set.all %}
        {{ alternate.property }}
    {% endfor %}
{% endfor %}

这可以运行数千个查询,具体取决于匹配的数量.有没有一种优化方法？我试过使用Tag.objects.select_related().filter...,这有些帮助,但它没有帮助.

浏览器在生成jasper报告[PDF格式]时被绞死,该报告运行查询,其解释计划如下.

请帮忙分析查询,这个查询花了太多时间吗？我们还注意到在生成此报告时卡住了线程.

我需要提高此查询的性能：

Select 
   t1.column1, t1.column2 
From
   table1 t1, table2 t2
Where 
   t1.id = t2.id and
   t1.some_column = t2.some_column
--------
minus
--------
Select 
   t1.column1, t1.column2 
From
   table1 t1, table2 t2, table3 t3
Where 
   t1.id = t2.id and
   t1.some_column = t2.some_column and
   t1.id = t3.id

我正在尝试使用“不存在”而不是“减号”重写此查询。有人可以给我建议吗？

我想知道是否有人可以确认PostgreSQL Inlining的预期行为？

从Microsoft SQL的世界来看，任何确定为内联的函数都将在多个行的单个迭代中使用（该函数主体实质上已注入到调用程序语句中，使其成为基于集合的[一个调用]，而不是每个输入数据行都有一个探针（多次调用））。

我和我的团队正在努力在没有诸如MSSQL之类的Profiler的情况下证明这一点，但我们最终得以证明这一点，并发现我们认为函数内联的迭代次数与它所处的行数成正比。运作。

为此，我们在函数（pg_sleep）中引入了有意的等待，在其中我们可以看到等待N秒会导致Rows * N的总执行时间，即输入6行，等待1秒就是6秒，等待2是12，依此类推。

因此，我们的问题是：

1. PostgreSQL内联是我们的想法吗（相当于MSSQLs内联函数[Type ='IF']）？
2. 有没有可以像MSSQL中的Profiler一样清楚地显示这一点的分析工具？
3. 我们是否可以查看任何元数据标记来确认/否认我们的功能确实可以内联？