小编Tre*_*reg的帖子

PostgreSQL中是否有命令选择到给定数据库的活动连接？

psql 说我不能删除我的一个数据库,因为它有活动的连接,所以我想看看连接是什么(以及从哪些机器)

在python 3.x中,通常使用函数的返回类型注释,例如:

def foo() -> str:
    return "bar"

"void"类型的正确注释是什么？

我正在考虑3种选择:

1. def foo() -> None:
   • 不合逻辑的IMO,因为None不是一个类型,
2. def foo() -> type(None):
   • 使用我所知道的最佳语法来获取NoneType,
3. def foo():
   • 省略显式返回类型信息.

选项2.对我来说似乎最合乎逻辑,但我已经看到了一些1的实例.

在Python 3中,我想检查value是字符串还是字符串None.

一种方法是

assert type(value) in { str, NoneType }

但是NoneTypePython的位置在哪里？

没有任何导入,使用NoneType产品NameError: name 'NoneType' is not defined.

使用Python的模块bottle,我在发布正文大小> bottle内部MEMFILE_MAX常量的请求时收到HTTP 413错误.最小的工作示例如下所示.

服务器部分(server.py):

from bottle import *

@post('/test')
def test():
    return str(len(request.forms['foo']));

def main():
    run(port=8008);

if __name__ == '__main__':
    main();

客户部分(client.py):

import requests

def main():
    url = 'http://127.0.0.1:8008/test';

    r = requests.post(url, data={ 'foo' : 100000 * 'a' });
    print(r.text);

    r = requests.post(url, data={ 'foo' : 200000 * 'a' });
    print(r.text);

if __name__ == '__main__':
    main();

第一个请求打印:

100000

第二个请求打印:

...
<body>
    <h1>Error: 413 Request Entity Too Large</h1>
    <p>Sorry, the requested URL …

我正在使用Python3 + bottle/UWSGI开发实时REST API.我的代码遇到了延迟,有时是100秒,这在我的应用程序中很重要.

使用logging模块,我试图识别代码的慢速部分,打印单个代码块运行的时间.我知道这是一种非常糟糕的分析代码的方法,但有时它能够很好地完成这项工作.

即使我发现了一些缓慢的部分,我仍然遗漏了一些东西 - 单个部分似乎需要10秒的ms,但通常它们整体上需要100秒.在一些越来越疯狂的实验让我几乎完全疯了之后,我得出以下结论:

t = round(100*time.time())
logging.info('[%s] Foo' % t)
logging.info('[%s] Bar' % t)

令人惊讶的是,它给出了:

2014-07-16 23:21:23,531  [140554568353] Foo
2014-07-16 23:21:24,312  [140554568353] Bar

虽然这似乎很难相信,但有两个后续logging.info()调用,并且由于某种原因,它们之间存在差不多800毫秒的差距.谁能告诉我发生了什么事？值得注意的是,如果有多个info()调用,则延迟仅在整个API方法中出现一次,最常见于其开始时(在第一次调用之后).我唯一的假设是磁盘延迟,有几个(但不是很多!)工作者同时运行,我正在使用旋转磁盘,没有SSD.但我认为有缓冲区,操作系统将为我异步执行磁盘刷新.我的假设错了吗？我应该避免完全记录以避免延迟吗？

编辑

根据Vinay Sajip的建议,我切换到以下初始化代码:

log_que = queue.Queue(-1)
queue_handler = logging.handlers.QueueHandler(log_que)
log_handler = logging.StreamHandler()
queue_listener = logging.handlers.QueueListener(log_que, log_handler)
queue_listener.start()
logging.basicConfig(level=logging.DEBUG, format="%(asctime)s  %(message)s", handlers=[queue_handler])

它似乎工作正常(如果我评论queue_listener.start(),没有输出),但仍然出现相同的延迟.我不知道怎么可能,呼叫应该是非阻塞的.我还在gc.collect()每个请求结束时确保问题不是由垃圾收集器引起的 - 没有任何影响.我也试图关闭整天的日志记录.延迟消失了,所以我认为他们的来源必须在logging模块中......

在PostgreSQL中,我想创建一个安全包装机制,如果发生异常,它将返回空结果.考虑以下:

SELECT * FROM myschema.mytable;

我可以在客户端应用程序中进行安全包装:

try {
    result = execute_query('SELECT value FROM myschema.mytable').fetchall();
}
catch(pg_exception) {
    result = []
}

但我可以直接在SQL中做这样的事情吗？我想使下面的代码工作,但似乎它应该被放入DO $$ ... $$块中,在这里我迷路了.

BEGIN
    SELECT * FROM myschema.mytable;
EXCEPTION WHEN others THEN
    SELECT unnest(ARRAY[]::TEXT[])
END

我正在设计应该能够接受对象数组的REST API

[
 {
   'name': 'Alice',
   'age': 15
 },
 {
   'name': 'Bob',
   'age': 20
 },
 ...
]

实际上,API可以有一个接受单个对象的方法,它将在循环中调用.但是,出于性能原因,我希望在一个请求中POST多个对象.

这样做最优雅的方式是什么？到目前为止,我唯一的想法是使用JSON,例如:

post_params = { 'data' : to_json_string([ { 'name' : 'Alice', 'age' : 15 },
                                          { 'name' : 'Bob',   'age' : 20 },
                                          ...
                                        ])
              };
post(url, post_params);

这样可以,还是应该使用一些完全不同的方法？

我有几个工作者,每个工作者都拥有自己与PostgreSQL的连接.工人们操纵着不同的桌子.

工作人员处理来自系统外部的并行请求.正在访问的表之一是用户表.当一些信息出现时,我首先需要确保表中的用户有一条记录.如果没有记录,我希望首先创建一个.

我正在使用以下成语:

if [user does not exist] then [create user]

代码[user does not exist]是:

SELECT id FROM myschema.users WHERE userId='xyz'

我测试是否返回任何行.

(简化)代码[create user]是:

INSERT INTO myschema.users VALUES ('xyz')

当我的系统处理有关同一用户的不同信息的并行流时,我经常会收到PostgreSQL错误:

Key (id)=(xyz) already exists

之所以发生这种情况是因为该SELECT命令不返回任何行,然后另一个工作程序创建用户,任何我的工作程序都尝试执行相同操作,从而导致示例性并发错

根据PostgreSQL文档,默认情况下,每当我隐式启动一个事务时,只要我不提交它,表就会被锁定.我没有使用自动提交,我只在块中提交事务,例如在整个if-else块之后.

实际上,我可以if-else直接将这些东西放入SQL中,但它并不能解决我的锁定问题.我假设"赢家全部使用"范例将起作用,并且设法执行SELECT命令的第一个工作人员将拥有锁,直到它调用COMMIT.

我在SO上已经阅读了很多不同的主题,但我仍然不确定什么是正确的解决方案.我应该使用显式锁定表,因为隐式锁定不起作用？我怎样才能确保只有一个工人拥有一张桌子？

在分析我的Python应用程序时,我发现len()使用集合时似乎非常昂贵.请参阅以下代码:

import cProfile

def lenA(s):
    for i in range(1000000):
        len(s);

def lenB(s):
    for i in range(1000000):
        s.__len__();

def main():
    s = set();
    lenA(s);
    lenB(s);

if __name__ == "__main__":
    cProfile.run("main()","stats");

根据profiler的统计数据,lenA()似乎比lenB()以下慢14倍:

 ncalls  tottime  percall  cumtime  percall  filename:lineno(function)
      1    1.986    1.986    3.830    3.830  .../lentest.py:5(lenA)
1000000    1.845    0.000    1.845    0.000  {built-in method len}
      1    0.273    0.273    0.273    0.273  .../lentest.py:9(lenB)

我错过了什么吗？目前我使用__len__()而不是len(),但代码看起来很脏:(

在PostgreSQL 9.2中,我有一个由用户评价的项目表:

   id   | userid | itemid |    rating     |      timestamp      |      !update_time
--------+--------+--------+---------------+---------------------+------------------------
 522241 | 3991   | 6887   |  0.1111111111 | 2005-06-20 03:13:56 | 2013-10-11 17:50:24.545
 522242 | 3991   | 6934   |  0.1111111111 | 2005-04-05 02:25:21 | 2013-10-11 17:50:24.545
 522243 | 3991   | 6936   | -0.1111111111 | 2005-03-31 03:17:25 | 2013-10-11 17:50:24.545
 522244 | 3991   | 6942   | -0.3333333333 | 2005-03-24 04:38:02 | 2013-10-11 17:50:24.545
 522245 | 3991   | 6951   | -0.5555555556 | 2005-06-20 03:15:35 | 2013-10-11 17:50:24.545
 ... …