我正在学习Google App Engine，并且正在尝试找出一种管理Google Cloud SQL实例的数据库连接的好方法（如果你还没有使用GC-SQL，基本上，它是云中的MySQL，有一些限制）。
我正在使用带有webapp2框架的python（2.7）GAE环境来处理请求。我知道常见问题解答说，建议每次请求都要与DB建立新的连接，但我不知道建议的关闭连接的方法是什么。每次我尝试在开发过程中删除表时，GC-SQL挂起并且“show processlist”显示有一堆进程（可能是因为我没有关闭数据库）并且其中一个正在等待锁定（可能是这个过程试图放弃表格）。这很烦人，迫使我重新启动GC-SQL实例（比如重新启动mysql-server服务，我想）。我还认为偶尔存在数据库打嗝，这与我没有真正关闭数据库连接这一事实有关。
那么，例如，我的webapp2.Requesthandler子类实例上是否应该有一个析构函数来断开与DB的连接？ GAE对象有时似乎被缓存，所以这也是需要考虑的事情。我想我可以为每个查询连接/查询/断开连接，但这似乎不是最理想的。
我知道这是一个模糊的问题，但我希望在这方面有所作为的人可以按我的方式提出一些提示。
提前致谢！
更新 我尝试使用Shay的答案作为起点，围绕需要cursot的方法实现一个包装器。我收到了GAE错误。这是一个特定于此的新问题：What are the connection limits for Google Cloud SQL from App Engine, and how to best reuse DB connections?
答案 0 :(得分：10)
以下是来自Getting Started Guide的helloworld示例应用的完整示例。它基于Shay Erlichmen和JJC的摘录，但此版本是线程安全的。
你可以像这样使用它：
@with_db_cursor(do_commit = True)
def get(self, cursor):
cursor.execute('SELECT guestName, content, entryID FROM entries')
的app.yaml
application: helloworld
version: 1
runtime: python27
api_version: 1
threadsafe: true
handlers:
- url: /.*
script: helloworld.app
helloworld.py
import cgi
import logging
import os
import threading
import webapp2
from google.appengine.api import rdbms
_INSTANCE_NAME = <name goes here>
def _db_connect():
return rdbms.connect(instance=_INSTANCE_NAME, database='guestbook')
_mydata = threading.local()
def with_db_cursor(do_commit = False):
""" Decorator for managing DB connection by wrapping around web calls.
Stores connections and open cursor count in a threadlocal
between calls. Sets a cursor variable in the wrapped function. Optionally
does a commit. Closes the cursor when wrapped method returns, and closes
the DB connection if there are no outstanding cursors.
If the wrapped method has a keyword argument 'existing_cursor', whose value
is non-False, this wrapper is bypassed, as it is assumed another cursor is
already in force because of an alternate call stack.
"""
def method_wrap(method):
def wrap(self, *args, **kwargs):
if kwargs.get('existing_cursor', False):
# Bypass everything if method called with existing open cursor.
return method(self, None, *args, **kwargs)
if not hasattr(_mydata, 'conn') or not _mydata.conn:
_mydata.conn = _db_connect()
_mydata.ref = 0
_mydata.commit = False
conn = _mydata.conn
_mydata.ref = _mydata.ref + 1
try:
cursor = conn.cursor()
try:
result = method(self, cursor, *args, **kwargs)
if do_commit or _mydata.commit:
_mydata.commit = False
conn.commit()
return result
finally:
cursor.close()
finally:
_mydata.ref = _mydata.ref - 1
if _mydata.ref == 0:
_mydata.conn = None
logging.info('Closing conn')
conn.close()
return wrap
return method_wrap
class MainPage(webapp2.RequestHandler):
@with_db_cursor(do_commit = True)
def get(self, cursor):
cursor.execute('SELECT guestName, content, entryID FROM entries')
self.response.out.write("""
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head>
<title>My Guestbook!</title>
</head>
<body>""")
self.response.out.write("""
<table style="border: 1px solid black">
<tbody>
<tr>
<th width="35%" style="background-color: #CCFFCC; margin: 5px">Name</th>
<th style="background-color: #CCFFCC; margin: 5px">Message</th>
<th style="background-color: #CCFFCC; margin: 5px">ID</th>
</tr>""")
for row in cursor.fetchall():
self.response.out.write('<tr><td>')
self.response.out.write(cgi.escape(row[0]))
self.response.out.write('</td><td>')
self.response.out.write(cgi.escape(row[1]))
self.response.out.write('</td><td>')
self.response.out.write(row[2])
self.response.out.write('</td></tr>')
self.response.out.write("""
</tbody>
</table>
<br /> No more messages!
<br /><strong>Sign the guestbook!</strong>
<form action="/sign" method="post">
<div>First Name: <input type="text" name="fname" style="border: 1px solid black"></div>
<div>Message: <br /><textarea name="content" rows="3" cols="60"></textarea></div>
<div><input type="submit" value="Sign Guestbook"></div>
</form>
</body>
</html>""")
class Guestbook(webapp2.RequestHandler):
@with_db_cursor(do_commit = True)
def post(self, cursor):
fname = self.request.get('fname')
content = self.request.get('content')
# Note that the only format string supported is %s
cursor.execute('INSERT INTO entries (guestName, content) VALUES (%s, %s)', (fname, content))
self.redirect("/")
app = webapp2.WSGIApplication(
[('/', MainPage),
('/sign', Guestbook)],
debug=True)
答案 1 :(得分：2)
我不熟悉Google Cloud SQL，但你不能使用WSGI中间件来打开和关闭连接吗？
答案 2 :(得分：2)
我写了一个装饰器来处理SQL连接，随意火焰：）
# Here is how you use the decorator from below
# the open, commit, and close is done by the decorator
@need_cursor(do_commit = True)
def get(self, cursor, request): # cursor param is added by the decorator
execute_sql(cursor, sql)
def need_cursor(do_commit = False):
def method_wrap(method):
def wrap(*args, **kwargs):
conn = os.environ.get("__data_conn")
# Recycling connection for the current request
# For some reason threading.local() didn't worked
# and yes os.environ suppose to be thread safe
if not conn:
conn = create_connection() # You need to implement this
os.environ["__data_conn"] = conn
os.environ["__data_conn_ref"] = 1
else:
os.environ["__data_conn_ref"] =
os.environ["__data_conn_ref"] + 1
try:
cursor = conn.cursor()
try:
result = method(cursor, *args, **kwargs)
if do_commit or os.environ.get("__data_conn_commit"):
os.environ["__data_conn_commit"] = False
conn.commit()
return result
finally:
cursor.close()
finally:
os.environ["__data_conn_ref"] =
os.environ["__data_conn_ref"] - 1
if os.environ["__data_conn_ref"] == 0:
os.environ["__data_conn"] = None
conn.close()
return wrap
return method_wrap
答案 3 :(得分：2)
这是我的方法，考虑可能的例外。我在生产环境中使用这种方法并且效果很好：
def _create_connection(schema):
if (os.getenv('SERVER_SOFTWARE') and
os.getenv('SERVER_SOFTWARE').startswith('Google App Engine/')):
socket = '/cloudsql/%s' % env.DB_INSTANCE_NAME
return MySQLdb.connect(unix_socket=socket, user=env.DB_APP_USER,
passwd=env.DB_APP_PASS, db=schema)
else:
return MySQLdb.connect(host='127.0.0.1', port=3306,
user=env.DB_APP_USER, passwd=env.DB_APP_PASS,
db=schema)
def with_db(commit=False, schema=env.DB_SCHEMA_NAME):
def method_wrap(method):
@functools.wraps(method)
def wrap(self, *args, **kwds):
# If needed,a connection pool can be added here.
connection = _create_connection(schema)
try:
cur = connection.cursor()
self.cur = cur
self.conn = connection
result = method(self, *args, **kwds)
if commit:
connection.commit()
except OperationalError as e:
logging.error('Operational error.\r\nSQL exception: {},\r\n'
'Last Query: {}'.format(e, cur._last_executed))
if commit and connection.open:
connection.rollback()
raise
except MySQLError as e:
try:
warns = self.conn.show_warnings()
error = self.conn.error()
except:
warns = ""
error = ""
logging.error('Try to rolling back transaction.\r\nSQL exception: {},\r\n'
'Last Query: {},\r\nConn warn: {},\r\nError: {}'
.format(e, cur._last_executed, warns, error))
if commit and connection.open:
connection.rollback()
raise
except Exception as e:
logging.error('Try to rolling back transaction. Non SQL exception: {0}'.format(e))
if commit and connection.open:
connection.rollback()
raise
finally:
connection.close()
return result
return wrap
return method_wrap
你可以像这样使用它：
@with_db(commit=True)
def update_user_phone(self, user, phone):
self.cur.execute(_SQL_UPDATE_USER_PHONE, (phone, user.id))
# add or replace existing user to cache
user.phone = phone
self._update_user_cache(user)