1. Python’s MySQLdb and pymysql are two basic database operation packages. The installation of MySQLdb is very troublesome. If there is a c++ related environment, python3 cannot be installed.
Python3 generally installs pymysql. This package is highly replaceable with the MySQLdb package. As long as you learn the api of one library, the operation method of the other library is exactly the same, and you don’t need to learn a new api.
But both of these are low-level, and the flaw is that the public query method is not easy to use, because the execution is cursor.excute, but the result needs to be operated on the cursor twice, so in general, most people will perform the second operation. subpackage.
2. torndb is such a library. It does not require the caller to care about the database cursor. Each public method returns the result directly. This is also the goal of secondary packaging of the database under normal circumstances. With torndb, there is no need to suffer I forced myself to encapsulate the database operation, just like having useful requests, 70% of the scenarios do not need to encapsulate urllib anymore, and there are special cases, I performed a second encapsulation based on the Session class of requests to make it more Easy to use, after encapsulation, only a small amount of external code is required outside the class, and the result can be obtained by calling the encapsulated method.
3. The pain point is that torndb relies on MySQLdb, which is difficult to install, and there are several python syntaxes in python2, but pyhton3 is removed. The last official update was in 2014. It is estimated that the official does not plan to update to be compatible with py3.
I modified it to rely on pymysql, compatible with python3, and published it on the official website of pypi. You can use pip install torndb_for_python3 to install this package, or you can copy the following code yourself.
torndb_for_python3 is fully compatible with the torndb package, and the api is exactly the same. To use the torndb_for_python3 package, just go to Baidu to search for torndb.
The lines with #TODO comments in the following code are the lines that have been modified from the official code.
Code for torndb_for_python3.py.
#!/usr/bin/env python
#
# Copyright 2009 Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""A lightweight wrapper around MySQLdb.
Originally part of the Tornado framework. The tornado.database module
is slated for removal in Tornado 3.0, and it is now available separately
as torndb.
The official torndb needs to be matched with the MySQLdb package, which is mainly modified to match with pymysql. The lines with TODO comments are all modified on the official basis, in order to be compatible with the parameters of pymsql and compatible with python3
"""
from __future__ import absolute_import, division, with_statement
import copy
import itertools
import logging
import os
import time
import pymysql # TODO need to install pymysql
pymysql.install_as_MySQLdb() # TODO Use monkey technology to replace the MySQLdb package with the pymsql package, so there is no need to replace MySQLdb with pymsql in the code. The main classes of pymsql and MySQLdb are ducks.
try:
import MySQLdb.constants
import MySQLdb.converters
import MySQLdb.cursors
except ImportError:
# If MySQLdb isn't available this module won't actually be useable,
# but we want it to at least be importable on readthedocs.org,
# which has limitations on third-party modules.
if 'READTHEDOCS' in os.environ:
MySQLdb = None
else:
raise
version = "0.3"
version_info = (0, 3, 0, 0)
class Connection(object):
"""A lightweight wrapper around MySQLdb DB-API connections.
The main value we provide is wrapping rows in a dict/object so that
columns can be accessed by name. Typical usage::
db = torndb.Connection("localhost", "mydatabase")
for article in db.query("SELECT * FROM articles"):
print article.title
Cursors are hidden by the implementation, but other than that, the methods
are very similar to the DB-API.
We explicitly set the timezone to UTC and assume the character encoding to
UTF-8 (can be changed) on all connections to avoid time zone and encoding errors.
The sql_mode parameter is set by default to "traditional", which "gives an error instead of a warning"
(http://dev.mysql.com/doc/refman/5.0/en/server-sql-mode.html). However, it can be set to
any other mode including blank (None) thereby explicitly clearing the SQL mode.
"""
def __init__(self, host, database, user=None, password=None,
max_idle_time=7 * 3600, connect_timeout=30, # TODO changed from 0 to 30, because pymsql must be greater than 0
time_zone="+0:00", charset="utf8", sql_mode="TRADITIONAL"):
self.host = host
self. database = database
self.max_idle_time = float(max_idle_time)
args = dict(conv=CONVERSIONS, use_unicode=True, charset=charset,
db=database, init_command=('SET time_zone = "%s"' % time_zone),
connect_timeout=connect_timeout, sql_mode=sql_mode)
if user is not None:
args["user"] = user
if password is not None:
args["passwd"] = password
# We accept a path to a MySQL socket file or a host(:port) string
if "/" in host:
args["unix_socket"] = host
else:
self.socket = None
pair = host. split(":")
if len(pair) == 2:
args["host"] = pair[0]
args["port"] = int(pair[1])
else:
args["host"] = host
args["port"] = 3306
self._db = None
self._db_args = args
self._last_use_time = time.time()
try:
self. reconnect()
except Exception:
logging.error("Cannot connect to MySQL on %s", self.host,
exc_info=True)
def __del__(self):
self. close()
def close(self):
"""Closes this database connection."""
if getattr(self, "_db", None) is not None:
self._db.close()
self._db = None
def reconnect(self):
"""Closes the existing database connection and re-opens it."""
self. close()
self._db = MySQLdb.connect(**self._db_args)
self._db.autocommit(True)
def iter(self, query, *parameters, **kwparameters):
"""Returns an iterator for the given query and parameters."""
self._ensure_connected()
cursor = MySQLdb.cursors.SSCursor(self._db)
try:
self._execute(cursor, query, parameters, kwparameters)
column_names = [d[0] for d in cursor.description]
for row in cursor:
yield Row(zip(column_names, row))
finally:
cursor. close()
def query(self, query, *parameters, **kwparameters):
"""Returns a row list for the given query and parameters."""
cursor = self._cursor()
try:
self._execute(cursor, query, parameters, kwparameters)
column_names = [d[0] for d in cursor.description]
# return [Row(itertools.izip(column_names, row)) for row in cursor] # TODO modified this line
return [Row(itertools.zip_longest(column_names, row)) for row in cursor]
finally:
cursor. close()
def get(self, query, *parameters, **kwparameters):
"""Returns the (singular) row returned by the given query.
If the query has no results, returns None. If it has
more than one result, raises an exception.
"""
rows = self. query(query, *parameters, **kwparameters)
if not rows:
return None
elif len(rows) > 1:
raise Exception("Multiple rows returned for Database. get() query")
else:
return rows[0]
# rowcount is a more reasonable default return value than lastrowid,
# but for historical compatibility execute() must return lastrowid.
def execute(self, query, *parameters, **kwparameters):
"""Executes the given query, returning the lastrowid from the query."""
return self. execute_lastrowid(query, *parameters, **kwparameters)
def execute_lastrowid(self, query, *parameters, **kwparameters):
"""Executes the given query, returning the lastrowid from the query."""
cursor = self._cursor()
try:
self._execute(cursor, query, parameters, kwparameters)
return cursor.lastrowid
finally:
cursor. close()
def execute_rowcount(self, query, *parameters, **kwparameters):
"""Executes the given query, returning the rowcount from the query."""
cursor = self._cursor()
try:
self._execute(cursor, query, parameters, kwparameters)
return cursor.rowcount
finally:
cursor. close()
def executemany(self, query, parameters):
"""Executes the given query against all the given param sequences.
We return the last rowid from the query.
"""
return self. executemany_lastrowid(query, parameters)
def executemany_lastrowid(self, query, parameters):
"""Executes the given query against all the given param sequences.
We return the last rowid from the query.
"""
cursor = self._cursor()
try:
cursor.executemany(query, parameters)
return cursor.lastrowid
finally:
cursor. close()
def executemany_rowcount(self, query, parameters):
"""Executes the given query against all the given param sequences.
We return the rowcount from the query.
"""
cursor = self._cursor()
try:
cursor.executemany(query, parameters)
return cursor.rowcount
finally:
cursor. close()
update = execute_rowcount
updatemany = executemany_rowcount
insert = execute_lastrowid
insertmany = executemany_lastrowid
def _ensure_connected(self):
# Mysql by default closes client connections that are idle for
# 8 hours, but the client library does not report this fact until
# you try to perform a query and it fails. Protect against this
# case by preemptively closing and reopening the connection
# if it has been idle for too long (7 hours by default).
if (self._db is None or
(time.time() - self._last_use_time > self.max_idle_time)):
self. reconnect()
self._last_use_time = time.time()
def _cursor(self):
self._ensure_connected()
return self._db.cursor()
def _execute(self, cursor, query, parameters, kwparameters):
try:
return cursor. execute(query, kwparameters or parameters)
except OperationalError:
logging.error("Error connecting to MySQL on %s", self.host)
self. close()
raise
def __str__(self):
return f'{type(self)} -> [{self.database} library of {self.host} machine]' # TODO
class Row(dict):
"""A dict that allows for object-like property access syntax."""
def __getattr__(self, name):
try:
return self[name]
except KeyError:
raise AttributeError(name)
if MySQLdb is not None:
# Fix the access conversions to properly recognize unicode/binary
FIELD_TYPE = MySQLdb.constants.FIELD_TYPE
FLAG = MySQLdb.constants.FLAG
CONVERSIONS = copy.copy(MySQLdb.converters.conversions)
field_types = [FIELD_TYPE.BLOB, FIELD_TYPE.STRING, FIELD_TYPE.VAR_STRING]
if 'VARCHAR' in vars(FIELD_TYPE):
field_types.append(FIELD_TYPE.VARCHAR)
for field_type in field_types:
# CONVERSIONS[field_type] = [(FLAG.BINARY, str)] + CONVERSIONS[field_type] # TODO modified this line
CONVERSIONS[field_type] = [(FLAG.BINARY, str)].append(CONVERSIONS[field_type])
# Alias some common MySQL exceptions
IntegrityError = MySQLdb. IntegrityError
OperationalError = MySQLdb. OperationalError
Usage, give an example:
# pip install torndb_for_python3
mysql_conn = torndb_for_python3.Connection(host='localhost', database='test', user='root', password='123456', charset='utf8')<br>print(mysql_conn.query('SELECT * FROM test.tablexx'))