标签: cost-based-optimizer

我正在处理Postgres表(称为"生命"),其中包含time_stamp,usr_id,transaction_id和lives_remaining列的记录.我需要一个查询,它将为每个usr_id提供最新的lives_remaining总数

1. 有多个用户(不同的usr_id)
   
2. time_stamp不是唯一标识符:有时用户事件(表中逐行)将以相同的time_stamp发生.
   
3. trans_id仅在非常小的时间范围内是唯一的:随着时间的推移它会重复
   
4. remaining_lives(对于给定用户)可以随时间增加或减少

例:

time_stamp|lives_remaining|usr_id|trans_id
-----------------------------------------
  07:00  |       1       |   1  |   1    
  09:00  |       4       |   2  |   2    
  10:00  |       2       |   3  |   3    
  10:00  |       1       |   2  |   4    
  11:00  |       4       |   1  |   5    
  11:00  |       3       |   1  |   6    
  13:00  |       3       |   3  |   1    

因为我需要使用每个给定的usr_id的最新数据来访问该行的其他列,所以我需要一个给出如下结果的查询:

time_stamp|lives_remaining|usr_id|trans_id
-----------------------------------------
  11:00  |       3       |   1  |   6    
  10:00  |       1       |   2  |   4    
  13:00  |       3       |   3  | …

我有这样的情况:

create table a(
  a_id number(38) not null,
  constraint pk_a primary key (id)
);

create table b(
  a_id number(38) not null
);

create index b_a_id_index on b(a_id);

现在b.a_id实际上是指外键引用a.a_id,但它没有正式声明.显然,这应该是出于诚信原因.但是,外键约束是否也会改善一般情况下或特定情况下的连接性能？如果是,对于什么类型的查询转换？

是否有关于此主题的相关文档？

我正在使用Oracle 11g(11.2.0.2.0)

我能够将连接消除工作用于简单的情况,例如一对一的关系,但不能用于稍微复杂的场景.最后我想尝试锚建模,但首先我需要找到解决这个问题的方法.我正在使用Oracle 12c企业版第12.1.0.2.0版.

我的测试用例的DDL:

drop view product_5nf;
drop table product_color cascade constraints;
drop table product_price cascade constraints;
drop table product       cascade constraints;

create table product(
   product_id number not null
  ,constraint product_pk primary key(product_id)
);

create table product_color(
   product_id  number         not null references product
  ,color       varchar2(10)   not null
  ,constraint product_color_pk primary key(product_id)
);

create table product_price(
   product_id  number   not null references product
  ,from_date   date     not null
  ,price       number   not null
  ,constraint product_price_pk primary key(product_id, from_date)
);

一些示例数据:

insert into product values(1);
insert …

我有一个成本优化请求,我不知道如何有文献.这有点难以解释,所以我提前为问题的长度道歉.

我正在访问的服务器以这种方式工作:

• 对记录(r1,... rn)和字段(f1,... fp)发出请求
• 你只能要求笛卡尔积(r1,...,rp)x(f1,... fp)
• 与此类请求相关的成本(时间和金钱)与请求的大小相关:

T((r1, ..., rn)x(f1, ..., fp) = a + b * n * p

在不失一般性的情况下(仅通过标准化),我们可以假设b=1成本是:

T((r1, ...,rn)x(f1,...fp)) = a + n * p

• 我只需要请求一对子集(r1, f(r1)), ... (rk, f(rk)),一个来自用户的请求.我的程序充当用户和服务器(外部)之间的中间人.我有很多这样的要求(每天数万).

在图形上,我们可以将其视为一个nxp稀疏矩阵,我想用矩形子矩阵覆盖非零值:

   r1 r2 r3 ... rp
   ------      ___
f1 |x  x|      |x|
f2 |x   |      ---
   ------
f3
..    ______
fn    |x  x|
      ------

有:

• 由于成本不变,子矩阵的数量保持合理
• 所有'x'必须位于子矩阵内
• 由于线性成本,所覆盖的总面积不能太大

我将g命名为我的问题的稀疏系数(所需对的数量超过总可能对​​,g = k / (n * p).我知道系数a.

有一些明显的观察:

• 如果a很小,最好的解决方案是独立请求每个(记录,字段)对,总成本为: …

我有一个深度神经网络,层之间的权重存储在列表中.

layers[j].weights我想在我的成本函数中包括岭惩罚.然后我需要使用诸如tf.nn.l2_loss(layers[j].weights**2 for j in range(self.n_layers))所有权重的平方和之类的东西 .

特别是权重定义为:

>>> avs.layers
[<neural_network.Layer object at 0x10a4b2a90>, <neural_network.Layer object at 0x10ac85080>, <neural_network.Layer object at 0x10b0f3278>, <neural_network.Layer object at 0x10b0eacf8>, <neural_network.Layer object at 0x10b145588>, <neural_network.Layer object at 0x10b165048>, <neural_network.Layer object at 0x10b155ba8>]
>>>
>>> avs.layers[0].weights
<tensorflow.python.ops.variables.Variable object at 0x10b026748>
>>> 

我怎么能在张量流中做到这一点？

甲骨文似乎不时更倾向于MERGE JOIN CARTESIAN常规操作MERGE JOIN.知道数据并查看具体的执行计划,我可以看到这个操作通常不是问题,因为其中一个连接的实体只能在手头的查询中返回一个记录.

但是,由于历史原因,我们的DBA对笛卡尔产品普遍不满意.

所以我想更好地分析这些案例,并在我的论证中备份文档.是否有关于查询转换和CBO的官方Oracle文档,我可以在其中了解Oracle更喜欢MERGE JOIN CARTESIAN(或类似)操作的情况？

在这种情况下,我正在使用Oracle 11g(11.2.0.2.0)

更新:

这些是类似的问题,但它们没有解释为什么或何时 Oracle更喜欢MJC常规MERGE JOIN:

• 为什么此查询会导致Oracle中的MERGE JOIN CARTESIAN？
• 为什么此查询会导致Oracle中的Merge Cartesian Join

是什么让错误的行估计成为 SQL 查询性能的痛点？我\xe2\x80\x99m有兴趣了解其内部原因。

通常，错误的行估计实际上会选择正确的计划，而好查询和坏查询之间的唯一区别是估计的行数。

为什么经常出现如此巨大的性能差异？

是因为 Postgres 使用行估计来分配内存吗？

鉴于我有一个数组,说:

$myArray=['12','AB','3C']

我想返回值2(这是每个数组元素的长度.)

但万一我有类似的东西

$myArray=['12','AB2','3C']

我想在数组的第二个元素之后立即停止计算/循环'AB2',让我的函数返回null.

在性能和速度有效的问题上达成此目标的最有效方法是什么？因为这样的阵列可以变长.