小编zzz*_*eek的帖子

我们知道,Postgresql的OFFSET要求它扫描所有行,直到它到达你请求的位置为止,这使得通过大量结果集分页变得无用,随着OFFSET的增加而变得越来越慢.

PG 8.4现在支持窗口功能.代替:

SELECT * FROM table ORDER BY somecol LIMIT 10 OFFSET 500

你可以说:

SELECT * FROM (SELECT *, ROW_NUMBER() OVER (ORDER BY somecol ASC) AS rownum FROM table) AS foo
WHERE rownum > 500 AND rownum <= 510

后一种方法对我们有帮助吗？或者我们是否必须继续使用标识列和临时表来进行大分页？

我注意到SQLAlchemy缓慢获取(和ORMing)一些数据,使用裸骨SQL获取相当快.首先,我创建了一个包含一百万条记录的数据库:

mysql> use foo
mysql> describe Foo;
+-------+---------+------+-----+---------+-------+
| Field | Type    | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
| id    | int(11) | NO   | PRI | NULL    |       |
| A     | int(11) | NO   |     | NULL    |       |
| B     | int(11) | NO   |     | NULL    |       |
| C     | int(11) | NO   |     | NULL    |       |
+-------+---------+------+-----+---------+-------+
mysql> SELECT COUNT(*) FROM Foo;
+----------+
| COUNT(*) |
+----------+
|  1000000 …

我们使用ORA_ROWSCN伪列来定位最近修改的行,以便将所选细节复制到不同的数据源.我们知道这一列的"近似"性质,如果块中只有一行发生变化,则块内的整批行都用SCN标记,我们对此很好,相对较小批量的误报不是问题.

然而,我们观察到的是大量行似乎具有"浮动"ORA_ROWSCN值.这些数百万行当然没有变化,但每次我们开始与Oracle进行新的控制台会话时,行块每次都会获得一个全新的,最新的SCN.下面说明了几分钟内三个独立的控制台会话:

会议#1 - SCN 27501512下的400万行:

SQL> SELECT count(*), ORA_ROWSCN FROM our_table GROUP BY ORA_ROWSCN ORDER BY ORA_ROWSCN;

  COUNT(*) ORA_ROWSCN
---------- ----------
    12   27323587
    12   27415360
    20   27431509
   4057846   27501512

会议#2 - SCN 27501522下的400万行:

SQL> SELECT count(*), ORA_ROWSCN FROM our_table GROUP BY ORA_ROWSCN ORDER BY ORA_ROWSCN;

  COUNT(*) ORA_ROWSCN
---------- ----------
    12   27323587
    12   27415360
    20   27431509
   4057846   27501522

会议#3 - SCN 27501528下的400万行:

SQL> SELECT count(*), ORA_ROWSCN FROM our_table GROUP BY ORA_ROWSCN ORDER BY ORA_ROWSCN;

  COUNT(*) ORA_ROWSCN
---------- …

我打算在我的一个项目中使用SQLAlchemy,我对表的声明性语法非常感兴趣.

有人告诉我使用Elixir声明层,同时SQLAlchemy有内置的声明性扩展.

Elixir和声明性扩展之间目前的差异是什么？优点缺点？

给出两个数据帧如下:

>>> import pandas as pd

>>> df_a = pd.DataFrame([{"a": 1, "b": 4}, {"a": 2, "b": 5}, {"a": 3, "b": 6}])
>>> df_b = pd.DataFrame([{"c": 2, "d": 7}, {"c": 3, "d": 8}])
>>> df_a
   a  b
0  1  4
1  2  5
2  3  6

>>> df_b
   c  d
0  2  7
1  3  8

我们希望使用非简单的标准生成两种数据帧的SQL样式连接,比如说"df_b.c> df_a.a".从我所知,虽然merge()肯定是解决方案的一部分,但我不能直接使用它,因为它不接受"ON"标准的任意表达式(除非我遗漏了什么？).

在SQL中,结果如下所示:

# inner join
sqlite> select * from df_a join df_b on c > a;
1|4|2|7
1|4|3|8
2|5|3|8

# outer join …

具体来说,这是来自.ico文件,因此没有像gif那样的"透明""信息"属性.下面的例子说明使用正确的透明度索引"0"将Yahoo!的favicon转换为png,我猜想.如何检测ico实际上是透明的,透明度指数是0？

import urllib2
import Image
import StringIO

resp = urllib2.urlopen("http://www.yahoo.com/favicon.ico")
image = Image.open(StringIO.StringIO(resp.read()))

f = file("test.png", "w")

# I guessed that the transparent index is 0.  how to
# determine it correctly ?
image.save(f, "PNG", quality=95, transparency=0)

从性能/索引/数据管理的角度来看,使用子项上的主键作为外键与子项上的纯代理主键创建表之间的一对一关系有哪些优缺点？第一种方法似乎是减少冗余并且很好地隐式地约束一对一,而第二种方法似乎受到DBA的青睐,即使它创建了第二个索引:

create table parent (
     id integer primary key, 
     data varchar(50)
)

create table child (
     id integer primary key references parent(id), 
     data varchar(50)
)

纯替代钥匙:

create table parent (
     id integer primary key, 
     data varchar(50)
)

create table child (
     id integer primary key,
     parent_id integer unique references parent(id), 
     data varchar(50)
)

这里感兴趣的平台是Postgresql,Microsoft SQL Server.

编辑:

所以这是来自实际DBA的基本思想.主要关注的是子表上的索引碎片.假设主键为1-1000000的记录插入到父表中,子表中没有任何内容.稍后,临时操作开始使用与父表中的行相对应的行(但是以随机顺序)填充子表.令人担忧的是,这将导致插入页面拆分,导致索引碎片,并导致删除"瑞士奶酪"效果.我承认这些不是我非常熟悉的术语,当谷歌搜索它们时,点击似乎与Microsoft SQL服务器相关.这些特定于MS的问题(即,PG的分析是否可以缓解PG上的问题)？如果是这样,那么这是使用像Postgresql这样的数据库的另一个原因.

从 libxml2 2.6 升级到 2.7 时，我的某些行为发生了变化。我在他们的网站上找到了关于此更改的错误报告，其https://bugzilla.gnome.org/show_bug.cgi?id=571271。

有趣的是，他们报告说“我猜我们误解了这个选项的预期行为（尽管我仍然不是 100% 确定）”——他们不确定他们是否正确阅读了规范，但他们提交了修复程序。

我认为以前的行为是正确的，所以我想看看这里是否有人对这两个方向有了解。

基本上，是否<xs:all>elem1, elem2, ..<xs:all>意味着“必须存在 elem1、elem2 .. 中的所有或不存在”，或“可能存在 elem1、elem2 中的任何一个 ..”？尽管看起来像前者，但有两个消息来源并没有说明这一点：

http://www.w3.org/TR/xmlschema-0/#re​​f18 - “组中的所有元素可能出现一次，也可能根本不出现，它们可能以任何顺序出现。”

http://www.w3schools.com/Schema/el_all.asp - “上面的例子表明“名字”和“姓氏”元素可以以任何顺序出现，每个元素可以出现零次或一次！”

下面的脚本使用 lxml，在使用 libxml2 2.6 时报告成功，但第二个模式验证在 2.7 上失败。有人可以确认 2.7 在这里做的是对还是错？

from lxml import etree
from StringIO import StringIO

schema = """
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
 <xs:element type="parent-type" name="parent"/>
 <xs:complexType name="parent-type">
   <xs:all maxOccurs="1" minOccurs="0">
     <xs:element type="xs:int" name="int-attr"/>
     <xs:element type="xs:string" name="str-attr"/>
   </xs:all>
 </xs:complexType>
</xs:schema>
"""

xmlschema = etree.XMLSchema(etree.parse(StringIO(schema)))

# passes
doc1 = """
<parent xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.example.com/xml/schemas"> …