def test():
ctype = 'text/plain'
html = ''
html += 'Python: %s\n' % sys.version
html += 'mysql: %s\n' % mysql.get_client_info()
html += 'OPENSHIFT_MYSQL_DB: %s:%d\n' % (os.environ['OPENSHIFT_MYSQL_DB_HOST'], int(os.environ['OPENSHIFT_MYSQL_DB_PORT']))
return (ctype, html)
def _parse_connection_string(cls, connection, use_unicode=False,
charset=None, timeout=None):
""" Done as a class method to both allow access to class attribute
conv (conversion) settings while allowing for wrapping pool class
use of this method. The former is important to allow for subclasses
to override the conv settings while the latter is important so
the connection string doesn't have to be parsed for each instance
in the pool.
"""
kw_args = {'conv': cls.conv}
flags = {'kw_args': kw_args, 'connection': connection}
kw_args['use_unicode'] = use_unicode
if use_unicode:
kw_args['charset'] = cls.unicode_charset
if charset:
kw_args['charset'] = charset
items = connection.split()
flags['use_TM'] = None
if _mysql.get_client_info()[0] >= '5':
kw_args['client_flag'] = CLIENT.MULTI_STATEMENTS
if items:
lockreq, items = items[0], items[1:]
if lockreq[0] == '*':
flags['mysql_lock'] = lockreq[1:]
db_host, items = items[0], items[1:]
flags['use_TM'] = True # redundant. eliminate?
else:
flags['mysql_lock'] = None
db_host = lockreq
if '@' in db_host:
db, host = db_host.split('@', 1)
kw_args['db'] = db
if ':' in host:
host, port = host.split(':', 1)
kw_args['port'] = int(port)
kw_args['host'] = host
else:
kw_args['db'] = db_host
if kw_args['db'] and kw_args['db'][0] in ('+', '-'):
flags['try_transactions'] = kw_args['db'][0]
kw_args['db'] = kw_args['db'][1:]
else:
flags['try_transactions'] = None
if not kw_args['db']:
del kw_args['db']
if items:
kw_args['user'], items = items[0], items[1:]
if items:
kw_args['passwd'], items = items[0], items[1:]
if items:
kw_args['unix_socket'], items = items[0], items[1:]
if timeout:
kw_args['connect_timeout'] = timeout
return flags
def check_libmysqlclient_version(app_configs, **kwargs):
"""
Check mysqlclient has been compiled against a version of libmysqlclient
that isn't vulnerable to TLS stripping. See vendor-libmysqclient.sh.
"""
# get_client_info() returns the libmysqlclient version as a string of form `5.7.0`.
libmysqlclient_version = get_client_info()
if version_to_tuple(libmysqlclient_version) < (5, 7, 11):
msg = ("mysqlclient has been compiled against an insecure version "
"of libmysqlclient (%s)." % libmysqlclient_version)
hint = "If using Vagrant, run `vagrant provision` and re-login."
return [Error(msg, hint=hint, id="treeherder.E001")]
return []
def printmysqlinfo(self):
print "=============MySQL info============="
print "Connection id : "+str(self.conn.thread_id())
print "Current database : "+dbname
print "Current user : "******"SSL : "+self.mysqlvariables.strFormat('have_openssl')
#print "Current pager : "
#print "Using outfile : "
#print "Using delimiter : "
self.version=Decimal(self.mysqlvariables.strFormat('version')[0:3])
print "MySQL VERSION : "+self.mysqlvariables.strFormat('version')+" "+self.mysqlvariables.strFormat('version_comment')
print "MySQL client info : "+_mysql.get_client_info()
print "Protocol version : "+str(self.conn.get_proto_info())
print "Connection : "+self.conn.get_host_info()
print "Server characterset : "+self.mysqlvariables.strFormat('character_set_server')
print "Db characterset : "+self.mysqlvariables.strFormat('character_set_database')
print "Client characterset : "+self.mysqlvariables.strFormat('character_set_client')
print "Conn. characterset : "+self.mysqlvariables.strFormat('character_set_connection')
print "collation_connection : "+self.mysqlvariables.strFormat('collation_connection')
print "collation_database : "+self.mysqlvariables.strFormat('collation_database')
print "collation_server : "+self.mysqlvariables.strFormat('collation_server')
print "Uptime : "+self.mysqlstatus['Uptime']+"s"
def _parse_connection_string(self, connection):
kwargs = {'conv': self.conv}
items = split(connection)
self._use_TM = None
if _mysql.get_client_info()[0] >= '5':
kwargs['client_flag'] = CLIENT.MULTI_STATEMENTS
if not items: return kwargs
lockreq, items = items[0], items[1:]
if lockreq[0] == "*":
self._mysql_lock = lockreq[1:]
db_host, items = items[0], items[1:]
self._use_TM = 1
else:
self._mysql_lock = None
db_host = lockreq
if '@' in db_host:
db, host = split(db_host,'@',1)
kwargs['db'] = db
if ':' in host:
host, port = split(host,':',1)
kwargs['port'] = int(port)
kwargs['host'] = host
else:
kwargs['db'] = db_host
if kwargs['db'] and kwargs['db'][0] in ('+', '-'):
self._try_transactions = kwargs['db'][0]
kwargs['db'] = kwargs['db'][1:]
else:
self._try_transactions = None
if not kwargs['db']:
del kwargs['db']
if not items: return kwargs
kwargs['user'], items = items[0], items[1:]
if not items: return kwargs
kwargs['passwd'], items = items[0], items[1:]
if not items: return kwargs
kwargs['unix_socket'], items = items[0], items[1:]
return kwargs
def __init__(self, *args, **kwargs):
"""
Create a connection to the database. It is strongly recommended
that you only use keyword parameters. Consult the MySQL C API
documentation for more information.
host
string, host to connect
user
string, user to connect as
passwd
string, password to use
db
string, database to use
port
integer, TCP/IP port to connect to
unix_socket
string, location of unix_socket to use
conv
conversion dictionary, see MySQLdb.converters
connect_timeout
number of seconds to wait before the connection attempt
fails.
compress
if set, compression is enabled
named_pipe
if set, a named pipe is used to connect (Windows only)
init_command
command which is run once the connection is created
read_default_file
file from which default client values are read
read_default_group
configuration group to use from the default file
cursorclass
class object, used to create cursors (keyword only)
charset
If supplied, the connection character set will be changed
to this character set (MySQL-4.1 and newer).
sql_mode
If supplied, the session SQL mode will be changed to this
setting (MySQL-4.1 and newer). For more details and legal
values, see the MySQL documentation.
client_flag
integer, flags to use or 0
(see MySQL docs or constants/CLIENTS.py)
ssl
dictionary or mapping, contains SSL connection parameters;
see the MySQL documentation for more details
(mysql_ssl_set()). If this is set, and the client does not
support SSL, NotSupportedError will be raised.
local_infile
integer, non-zero enables LOAD LOCAL INFILE; zero disables
autocommit
If False (default), autocommit is disabled.
If True, autocommit is enabled.
If None, autocommit isn't set and server default is used.
There are a number of undocumented, non-standard methods. See the
documentation for the MySQL C API for some hints on what they do.
"""
from MySQLdb.constants import CLIENT, FIELD_TYPE
from MySQLdb.converters import conversions
from weakref import proxy, WeakValueDictionary
kwargs2 = kwargs.copy()
if 'conv' in kwargs:
conv = kwargs['conv']
else:
conv = conversions
conv2 = {}
for k, v in conv.items():
if isinstance(k, int) and isinstance(v, list):
conv2[k] = v[:]
else:
conv2[k] = v
kwargs2['conv'] = conv2
cursorclass = kwargs2.pop('cursorclass', self.default_cursor)
charset = kwargs2.pop('charset', 'utf8')
sql_mode = kwargs2.pop('sql_mode', '')
client_flag = kwargs.get('client_flag', 0)
client_version = tuple([ numeric_part(n) for n in _mysql.get_client_info().split('.')[:2] ])
if client_version >= (4, 1):
client_flag |= CLIENT.MULTI_STATEMENTS
if client_version >= (5, 0):
client_flag |= CLIENT.MULTI_RESULTS
kwargs2['client_flag'] = client_flag
# PEP-249 requires autocommit to be initially off
autocommit = kwargs2.pop('autocommit', False)
super(Connection, self).__init__(*args, **kwargs2)
self.cursorclass = cursorclass
self.encoders = dict([ (k, v) for k, v in conv.items()
if type(k) is not int ])
self._server_version = tuple([ numeric_part(n) for n in self.get_server_info().split('.')[:2] ])
db = proxy(self)
def _get_string_literal():
def string_literal(obj, dummy=None):
return db.string_literal(obj)
return string_literal
def _get_bytes_literal():
def bytes_literal(u, dummy=None):
return db.literal(u.decode(bytes_literal.charset))
return bytes_literal
string_literal = _get_string_literal()
self.bytes_literal = bytes_literal = _get_bytes_literal()
if not charset:
charset = self.character_set_name()
self.set_character_set(charset)
if sql_mode:
self.set_sql_mode(sql_mode)
self.encoders[str] = string_literal
self.encoders[bytes] = bytes_literal
self._transactional = self.server_capabilities & CLIENT.TRANSACTIONS
if self._transactional:
if autocommit is not None:
self.autocommit(autocommit)
self.messages = []
def test_client_info(self):
self.assertTrue(isinstance(_mysql.get_client_info(), str))
def __init__(self, *args, **kwargs):
"""
Create a connection to the database. It is strongly recommended
that you only use keyword parameters. Consult the MySQL C API
documentation for more information.
:param str host: host to connect
:param str user: user to connect as
:param str password: password to use
:param str passwd: alias of password, for backward compatibility
:param str database: database to use
:param str db: alias of database, for backward compatibility
:param int port: TCP/IP port to connect to
:param str unix_socket: location of unix_socket to use
:param dict conv: conversion dictionary, see MySQLdb.converters
:param int connect_timeout:
number of seconds to wait before the connection attempt fails.
:param bool compress: if set, compression is enabled
:param str named_pipe: if set, a named pipe is used to connect (Windows only)
:param str init_command:
command which is run once the connection is created
:param str read_default_file:
file from which default client values are read
:param str read_default_group:
configuration group to use from the default file
:param type cursorclass:
class object, used to create cursors (keyword only)
:param bool use_unicode:
If True, text-like columns are returned as unicode objects
using the connection's character set. Otherwise, text-like
columns are returned as strings. columns are returned as
normal strings. Unicode objects will always be encoded to
the connection's character set regardless of this setting.
Default to False on Python 2 and True on Python 3.
:param str charset:
If supplied, the connection character set will be changed
to this character set (MySQL-4.1 and newer). This implies
use_unicode=True.
:param str sql_mode:
If supplied, the session SQL mode will be changed to this
setting (MySQL-4.1 and newer). For more details and legal
values, see the MySQL documentation.
:param int client_flag:
flags to use or 0 (see MySQL docs or constants/CLIENTS.py)
:param dict ssl:
dictionary or mapping contains SSL connection parameters;
see the MySQL documentation for more details
(mysql_ssl_set()). If this is set, and the client does not
support SSL, NotSupportedError will be raised.
:param bool local_infile:
enables LOAD LOCAL INFILE; zero disables
:param bool autocommit:
If False (default), autocommit is disabled.
If True, autocommit is enabled.
If None, autocommit isn't set and server default is used.
:param bool binary_prefix:
If set, the '_binary' prefix will be used for raw byte query
arguments (e.g. Binary). This is disabled by default.
There are a number of undocumented, non-standard methods. See the
documentation for the MySQL C API for some hints on what they do.
"""
from MySQLdb.constants import CLIENT, FIELD_TYPE
from MySQLdb.converters import conversions
from weakref import proxy
kwargs2 = kwargs.copy()
if 'database' in kwargs2:
kwargs2['db'] = kwargs2.pop('database')
if 'password' in kwargs2:
kwargs2['passwd'] = kwargs2.pop('password')
if 'conv' in kwargs:
conv = kwargs['conv']
else:
conv = conversions
conv2 = {}
for k, v in conv.items():
if isinstance(k, int) and isinstance(v, list):
conv2[k] = v[:]
else:
conv2[k] = v
kwargs2['conv'] = conv2
cursorclass = kwargs2.pop('cursorclass', self.default_cursor)
charset = kwargs2.pop('charset', '')
if charset or not PY2:
use_unicode = True
else:
use_unicode = False
use_unicode = kwargs2.pop('use_unicode', use_unicode)
sql_mode = kwargs2.pop('sql_mode', '')
self._binary_prefix = kwargs2.pop('binary_prefix', False)
client_flag = kwargs.get('client_flag', 0)
client_version = tuple([ numeric_part(n) for n in _mysql.get_client_info().split('.')[:2] ])
if client_version >= (4, 1):
client_flag |= CLIENT.MULTI_STATEMENTS
if client_version >= (5, 0):
client_flag |= CLIENT.MULTI_RESULTS
kwargs2['client_flag'] = client_flag
# PEP-249 requires autocommit to be initially off
autocommit = kwargs2.pop('autocommit', False)
self.waiter = kwargs2.pop('waiter', None)
super(Connection, self).__init__(*args, **kwargs2)
self.cursorclass = cursorclass
self.encoders = dict([ (k, v) for k, v in conv.items()
if type(k) is not int ])
self._server_version = tuple([ numeric_part(n) for n in self.get_server_info().split('.')[:2] ])
self.encoding = 'ascii' # overriden in set_character_set()
db = proxy(self)
# Note: string_literal() is called for bytes object on Python 3 (via bytes_literal)
def string_literal(obj, dummy=None):
return db.string_literal(obj)
if PY2:
# unicode_literal is called for only unicode object.
def unicode_literal(u, dummy=None):
return db.string_literal(u.encode(db.encoding))
else:
# unicode_literal() is called for arbitrary object.
def unicode_literal(u, dummy=None):
return db.string_literal(str(u).encode(db.encoding))
def bytes_literal(obj, dummy=None):
return b'_binary' + db.string_literal(obj)
def string_decoder(s):
return s.decode(db.encoding)
if not charset:
charset = self.character_set_name()
self.set_character_set(charset)
if sql_mode:
self.set_sql_mode(sql_mode)
if use_unicode:
for t in (FIELD_TYPE.STRING, FIELD_TYPE.VAR_STRING, FIELD_TYPE.VARCHAR, FIELD_TYPE.TINY_BLOB,
FIELD_TYPE.MEDIUM_BLOB, FIELD_TYPE.LONG_BLOB, FIELD_TYPE.BLOB):
self.converter[t].append((None, string_decoder))
self.encoders[bytes] = string_literal
self.encoders[unicode] = unicode_literal
self._transactional = self.server_capabilities & CLIENT.TRANSACTIONS
if self._transactional:
if autocommit is not None:
self.autocommit(autocommit)
self.messages = []
def __init__(self, *args, **kwargs):
"""
Create a connection to the database. It is strongly recommended
that you only use keyword parameters. Consult the MySQL C API
documentation for more information.
host
string, host to connect
user
string, user to connect as
passwd
string, password to use
db
string, database to use
port
integer, TCP/IP port to connect to
unix_socket
string, location of unix_socket to use
conv
conversion dictionary, see MySQLdb.converters
connect_timeout
number of seconds to wait before the connection attempt
fails.
compress
if set, compression is enabled
named_pipe
if set, a named pipe is used to connect (Windows only)
init_command
command which is run once the connection is created
read_default_file
file from which default client values are read
read_default_group
configuration group to use from the default file
cursorclass
class object, used to create cursors (keyword only)
use_unicode
If True, text-like columns are returned as unicode objects
using the connection's character set. Otherwise, text-like
columns are returned as strings. columns are returned as
normal strings. Unicode objects will always be encoded to
the connection's character set regardless of this setting.
Default to False on Python 2 and True on Python 3.
charset
If supplied, the connection character set will be changed
to this character set (MySQL-4.1 and newer). This implies
use_unicode=True.
sql_mode
If supplied, the session SQL mode will be changed to this
setting (MySQL-4.1 and newer). For more details and legal
values, see the MySQL documentation.
client_flag
integer, flags to use or 0
(see MySQL docs or constants/CLIENTS.py)
ssl
dictionary or mapping, contains SSL connection parameters;
see the MySQL documentation for more details
(mysql_ssl_set()). If this is set, and the client does not
support SSL, NotSupportedError will be raised.
local_infile
integer, non-zero enables LOAD LOCAL INFILE; zero disables
autocommit
If False (default), autocommit is disabled.
If True, autocommit is enabled.
If None, autocommit isn't set and server default is used.
waiter
Callable accepts fd as an argument. It is called after sending
query and before reading response.
This is useful when using with greenlet and async io.
There are a number of undocumented, non-standard methods. See the
documentation for the MySQL C API for some hints on what they do.
"""
from MySQLdb.constants import CLIENT, FIELD_TYPE
from MySQLdb.converters import conversions
from weakref import proxy
kwargs2 = kwargs.copy()
if 'conv' in kwargs:
conv = kwargs['conv']
else:
conv = conversions
conv2 = {}
for k, v in conv.items():
if isinstance(k, int) and isinstance(v, list):
conv2[k] = v[:]
else:
conv2[k] = v
kwargs2['conv'] = conv2
cursorclass = kwargs2.pop('cursorclass', self.default_cursor)
charset = kwargs2.pop('charset', '')
if charset or not PY2:
use_unicode = True
else:
use_unicode = False
use_unicode = kwargs2.pop('use_unicode', use_unicode)
sql_mode = kwargs2.pop('sql_mode', '')
client_flag = kwargs.get('client_flag', 0)
client_version = tuple(
[numeric_part(n) for n in _mysql.get_client_info().split('.')[:2]])
if client_version >= (4, 1):
client_flag |= CLIENT.MULTI_STATEMENTS
if client_version >= (5, 0):
client_flag |= CLIENT.MULTI_RESULTS
kwargs2['client_flag'] = client_flag
# PEP-249 requires autocommit to be initially off
autocommit = kwargs2.pop('autocommit', False)
self.waiter = kwargs2.pop('waiter', None)
super(Connection, self).__init__(*args, **kwargs2)
self.cursorclass = cursorclass
self.encoders = dict([(k, v) for k, v in conv.items()
if type(k) is not int])
self._server_version = tuple(
[numeric_part(n) for n in self.get_server_info().split('.')[:2]])
db = proxy(self)
def _get_string_literal():
# Note: string_literal() is called for bytes object on Python 3.
def string_literal(obj, dummy=None):
return db.string_literal(obj)
return string_literal
def _get_unicode_literal():
if PY2:
# unicode_literal is called for only unicode object.
def unicode_literal(u, dummy=None):
return db.literal(u.encode(unicode_literal.charset))
else:
# unicode_literal() is called for arbitrary object.
def unicode_literal(u, dummy=None):
return db.literal(str(u).encode(unicode_literal.charset))
return unicode_literal
def _get_string_decoder():
def string_decoder(s):
return s.decode(string_decoder.charset)
return string_decoder
string_literal = _get_string_literal()
self.unicode_literal = unicode_literal = _get_unicode_literal()
self.string_decoder = string_decoder = _get_string_decoder()
if not charset:
charset = self.character_set_name()
self.set_character_set(charset)
if sql_mode:
self.set_sql_mode(sql_mode)
if use_unicode:
self.converter[FIELD_TYPE.STRING].append((None, string_decoder))
self.converter[FIELD_TYPE.VAR_STRING].append(
(None, string_decoder))
self.converter[FIELD_TYPE.VARCHAR].append((None, string_decoder))
self.converter[FIELD_TYPE.BLOB].append((None, string_decoder))
self.encoders[bytes] = string_literal
self.encoders[unicode] = unicode_literal
self._transactional = self.server_capabilities & CLIENT.TRANSACTIONS
if self._transactional:
if autocommit is not None:
self.autocommit(autocommit)
self.messages = []
def test_client_info(self):
self.assertTrue(isinstance(_mysql.get_client_info(), str))
def __init__(self, *args, **kwargs):
"""
Create a connection to the database. It is strongly recommended that
you only use keyword parameters. Consult the MySQL C API documentation
for more information.
host
string, host to connect
user
string, user to connect as
passwd
string, password to use
db
string, database to use
port
integer, TCP/IP port to connect to
unix_socket
string, location of unix_socket to use
decoders
list, SQL decoder stack
encoders
list, SQL encoder stack
connect_timeout
number of seconds to wait before the connection attempt
fails.
compress
if set, compression is enabled
named_pipe
if set, a named pipe is used to connect (Windows only)
init_command
command which is run once the connection is created
read_default_file
file from which default client values are read
read_default_group
configuration group to use from the default file
use_unicode
If True, text-like columns are returned as unicode objects
using the connection's character set. Otherwise, text-like
columns are returned as strings. columns are returned as
normal strings. Unicode objects will always be encoded to
the connection's character set regardless of this setting.
charset
If supplied, the connection character set will be changed
to this character set (MySQL-4.1 and newer). This implies
use_unicode=True.
sql_mode
If supplied, the session SQL mode will be changed to this
setting (MySQL-4.1 and newer). For more details and legal
values, see the MySQL documentation.
client_flag
integer, flags to use or 0
(see MySQL docs or constants/CLIENTS.py)
ssl
dictionary or mapping, contains SSL connection parameters;
see the MySQL documentation for more details
(mysql_ssl_set()). If this is set, and the client does not
support SSL, NotSupportedError will be raised.
local_infile
integer, non-zero enables LOAD LOCAL INFILE; zero disables
There are a number of undocumented, non-standard methods. See the
documentation for the MySQL C API for some hints on what they do.
"""
from MySQLdb.constants import CLIENT, FIELD_TYPE
from MySQLdb.converters import default_decoders, default_encoders, default_row_formatter
from MySQLdb.cursors import Cursor
import _mysql
kwargs2 = kwargs.copy()
self.cursorclass = Cursor
charset = kwargs2.pop('charset', '')
self.encoders = kwargs2.pop('encoders', default_encoders)
self.decoders = kwargs2.pop('decoders', default_decoders)
self.row_formatter = kwargs2.pop('row_formatter', default_row_formatter)
client_flag = kwargs.get('client_flag', 0)
client_version = tuple(
[ int(n) for n in _mysql.get_client_info().split('.')[:2] ])
if client_version >= (4, 1):
client_flag |= CLIENT.MULTI_STATEMENTS
if client_version >= (5, 0):
client_flag |= CLIENT.MULTI_RESULTS
kwargs2['client_flag'] = client_flag
sql_mode = kwargs2.pop('sql_mode', None)
self._db = _mysql.connection(*args, **kwargs2)
self._server_version = tuple(
[ int(n) for n in self._db.get_server_info().split('.')[:2] ])
if charset:
self._db.set_character_set(charset)
if sql_mode:
self.set_sql_mode(sql_mode)
self._transactional = bool(self._db.server_capabilities & CLIENT.TRANSACTIONS)
if self._transactional:
# PEP-249 requires autocommit to be initially off
self.autocommit(False)
self.messages = []
self._active_cursor = None
def __init__(self, *args, **kwargs):
"""
Create a connection to the database. It is strongly recommended
that you only use keyword parameters. Consult the MySQL C API
documentation for more information.
:param str host: host to connect
:param str user: user to connect as
:param str password: password to use
:param str passwd: alias of password, for backward compatibility
:param str database: database to use
:param str db: alias of database, for backward compatibility
:param int port: TCP/IP port to connect to
:param str unix_socket: location of unix_socket to use
:param dict conv: conversion dictionary, see MySQLdb.converters
:param int connect_timeout:
number of seconds to wait before the connection attempt fails.
:param bool compress: if set, compression is enabled
:param str named_pipe: if set, a named pipe is used to connect (Windows only)
:param str init_command:
command which is run once the connection is created
:param str read_default_file:
file from which default client values are read
:param str read_default_group:
configuration group to use from the default file
:param type cursorclass:
class object, used to create cursors (keyword only)
:param bool use_unicode:
If True, text-like columns are returned as unicode objects
using the connection's character set. Otherwise, text-like
columns are returned as strings. columns are returned as
normal strings. Unicode objects will always be encoded to
the connection's character set regardless of this setting.
Default to False on Python 2 and True on Python 3.
:param str charset:
If supplied, the connection character set will be changed
to this character set (MySQL-4.1 and newer). This implies
use_unicode=True.
:param str sql_mode:
If supplied, the session SQL mode will be changed to this
setting (MySQL-4.1 and newer). For more details and legal
values, see the MySQL documentation.
:param int client_flag:
flags to use or 0 (see MySQL docs or constants/CLIENTS.py)
:param dict ssl:
dictionary or mapping contains SSL connection parameters;
see the MySQL documentation for more details
(mysql_ssl_set()). If this is set, and the client does not
support SSL, NotSupportedError will be raised.
:param bool local_infile:
enables LOAD LOCAL INFILE; zero disables
:param bool autocommit:
If False (default), autocommit is disabled.
If True, autocommit is enabled.
If None, autocommit isn't set and server default is used.
:param bool binary_prefix:
If set, the '_binary' prefix will be used for raw byte query
arguments (e.g. Binary). This is disabled by default.
There are a number of undocumented, non-standard methods. See the
documentation for the MySQL C API for some hints on what they do.
"""
from MySQLdb.constants import CLIENT, FIELD_TYPE
from MySQLdb.converters import conversions
from weakref import proxy
kwargs2 = kwargs.copy()
if 'database' in kwargs2:
kwargs2['db'] = kwargs2.pop('database')
if 'password' in kwargs2:
kwargs2['passwd'] = kwargs2.pop('password')
if 'conv' in kwargs:
conv = kwargs['conv']
else:
conv = conversions
conv2 = {}
for k, v in conv.items():
if isinstance(k, int) and isinstance(v, list):
conv2[k] = v[:]
else:
conv2[k] = v
kwargs2['conv'] = conv2
cursorclass = kwargs2.pop('cursorclass', self.default_cursor)
charset = kwargs2.pop('charset', '')
if charset or not PY2:
use_unicode = True
else:
use_unicode = False
use_unicode = kwargs2.pop('use_unicode', use_unicode)
sql_mode = kwargs2.pop('sql_mode', '')
self._binary_prefix = kwargs2.pop('binary_prefix', False)
client_flag = kwargs.get('client_flag', 0)
client_version = tuple([ numeric_part(n) for n in _mysql.get_client_info().split('.')[:2] ])
if client_version >= (4, 1):
client_flag |= CLIENT.MULTI_STATEMENTS
if client_version >= (5, 0):
client_flag |= CLIENT.MULTI_RESULTS
kwargs2['client_flag'] = client_flag
# PEP-249 requires autocommit to be initially off
autocommit = kwargs2.pop('autocommit', False)
self.waiter = kwargs2.pop('waiter', None)
super(Connection, self).__init__(*args, **kwargs2)
self.cursorclass = cursorclass
self.encoders = dict([ (k, v) for k, v in conv.items()
if type(k) is not int ])
self._server_version = tuple([ numeric_part(n) for n in self.get_server_info().split('.')[:2] ])
self.encoding = 'ascii' # overriden in set_character_set()
db = proxy(self)
# Note: string_literal() is called for bytes object on Python 3 (via bytes_literal)
def string_literal(obj, dummy=None):
return db.string_literal(obj)
if PY2:
# unicode_literal is called for only unicode object.
def unicode_literal(u, dummy=None):
return db.string_literal(u.encode(db.encoding))
else:
# unicode_literal() is called for arbitrary object.
def unicode_literal(u, dummy=None):
return db.string_literal(str(u).encode(db.encoding))
def bytes_literal(obj, dummy=None):
return b'_binary' + db.string_literal(obj)
def string_decoder(s):
return s.decode(db.encoding)
if not charset:
charset = self.character_set_name()
self.set_character_set(charset)
if sql_mode:
self.set_sql_mode(sql_mode)
if use_unicode:
self.converter[FIELD_TYPE.STRING].append((None, string_decoder))
self.converter[FIELD_TYPE.VAR_STRING].append((None, string_decoder))
self.converter[FIELD_TYPE.VARCHAR].append((None, string_decoder))
self.converter[FIELD_TYPE.BLOB].append((None, string_decoder))
self.encoders[bytes] = string_literal
self.encoders[unicode] = unicode_literal
self._transactional = self.server_capabilities & CLIENT.TRANSACTIONS
if self._transactional:
if autocommit is not None:
self.autocommit(autocommit)
self.messages = []
def __init__(self, *args, **kwargs):
"""
Create a connection to the database. It is strongly recommended that
you only use keyword parameters. Consult the MySQL C API documentation
for more information.
host
string, host to connect
user
string, user to connect as
passwd
string, password to use
db
string, database to use
port
integer, TCP/IP port to connect to
unix_socket
string, location of unix_socket to use
decoders
list, SQL decoder stack
encoders
list, SQL encoder stack
connect_timeout
number of seconds to wait before the connection attempt
fails.
compress
if set, compression is enabled
named_pipe
if set, a named pipe is used to connect (Windows only)
init_command
command which is run once the connection is created
read_default_file
file from which default client values are read
read_default_group
configuration group to use from the default file
use_unicode
If True, text-like columns are returned as unicode objects
using the connection's character set. Otherwise, text-like
columns are returned as strings. columns are returned as
normal strings. Unicode objects will always be encoded to
the connection's character set regardless of this setting.
charset
If supplied, the connection character set will be changed
to this character set (MySQL-4.1 and newer). This implies
use_unicode=True.
sql_mode
If supplied, the session SQL mode will be changed to this
setting (MySQL-4.1 and newer). For more details and legal
values, see the MySQL documentation.
client_flag
integer, flags to use or 0
(see MySQL docs or constants/CLIENTS.py)
ssl
dictionary or mapping, contains SSL connection parameters;
see the MySQL documentation for more details
(mysql_ssl_set()). If this is set, and the client does not
support SSL, NotSupportedError will be raised.
local_infile
integer, non-zero enables LOAD LOCAL INFILE; zero disables
There are a number of undocumented, non-standard methods. See the
documentation for the MySQL C API for some hints on what they do.
"""
from MySQLdb.constants import CLIENT, FIELD_TYPE
from MySQLdb.converters import default_decoders, default_encoders, default_row_formatter
from MySQLdb.cursors import Cursor
import _mysql
kwargs2 = kwargs.copy()
self.cursorclass = Cursor
charset = kwargs2.pop('charset', '')
self.encoders = kwargs2.pop('encoders', default_encoders)
self.decoders = kwargs2.pop('decoders', default_decoders)
self.row_formatter = kwargs2.pop('row_formatter', default_row_formatter)
client_flag = kwargs.get('client_flag', 0)
client_version = tuple(
[ int(n) for n in _mysql.get_client_info().split('.')[:2] ])
if client_version >= (4, 1):
client_flag |= CLIENT.MULTI_STATEMENTS
if client_version >= (5, 0):
client_flag |= CLIENT.MULTI_RESULTS
kwargs2['client_flag'] = client_flag
sql_mode = kwargs2.pop('sql_mode', None)
self._db = _mysql.connection(*args, **kwargs2)
self._server_version = tuple(
[ int(n) for n in self._db.get_server_info().split('.')[:2] ])
if charset:
self._db.set_character_set(charset)
if sql_mode:
self.set_sql_mode(sql_mode)
self._transactional = bool(self._db.server_capabilities & CLIENT.TRANSACTIONS)
if self._transactional:
# PEP-249 requires autocommit to be initially off
self.autocommit(False)
self.messages = []
self._active_cursor = None
def __init__(self, user, passwd, *args, **kwargs):
"""Create a connection to the database. It is strongly recommended
that you only use keyword parameters. Consult the MySQL C API
documentation for more information.
Arguments:
user: string, user to connect as.
passwd: string, password to use.
db: string, database to use. Default same as user.
host: string, host to connect to. Default 'localhost'.
port: integer, TCP/IP port to connect to.
unix_socket: string, location of unix_socket to use.
conv: conversion dictionary, see converters module.
connect_timeout: number of seconds to wait before the connection
attempt fails.
compress: bool, enable compression. Default False
named_pipe: if set, a named pipe is used to connect (Windows only)
init_command: command which is run once the connection is created
read_default_file: file from which default client values are read
read_default_group: configuration group to use from the default file
use_unicode: If True, text-like columns are returned as unicode
objects using the connection's character set.
Otherwise, text-like columns are returned as strings.
Columns are returned as normal strings. Unicode
objects will always be encoded to the connection's
character set regardless of this setting.
charset: If supplied, the connection character set will be
changed to this character set (MySQL-4.1 and newer).
This enforces use_unicode=True.
sql_mode: If supplied, the session SQL mode will be changed to
this setting (MySQL-4.1 and newer). For more details
and legal values, see the MySQL documentation.
client_flag: integer, flags to use or 0.
(see MySQL docs or constants/CLIENTS.py)
ssl: dictionary or mapping, contains SSL connection
parameters; see the MySQL documentation for more
details (mysql_ssl_set()). If this is set, and the
client does not support SSL, NotSupportedError will
be raised.
local_infile: bool, True enables LOAD LOCAL INFILE, False disables.
Default False
There are a number of undocumented, non-standard arguments. See the
documentation for the MySQL C API for some hints on what they do.
"""
# Counters, transaction lock & timer
self.counter_transactions = 0
self.counter_queries = 0
self.queries = []
self.transaction_timer = None
self.lock = threading.Lock()
# _mysql connect args mapping
kwargs['user'] = user
kwargs['passwd'] = passwd
kwargs['host'] = kwargs.get('host', 'localhost')
kwargs['db'] = kwargs.get('db', user)
self.logger = logging.getLogger('mysql_%s' % kwargs['db'])
if kwargs.pop('debug', False):
self.debug = True
self.logger.setLevel(logging.DEBUG)
else:
self.debug = False
self.logger.setLevel(logging.WARNING)
if kwargs.pop('disable_log', False):
self.logger.disable_logger = True
self.encoders = {}
converts = {}
for key, value in converters.CONVERSIONS.iteritems():
if not isinstance(key, int):
self.encoders[key] = value
else:
if isinstance(value, list):
converts[key] = value[:]
else:
converts[key] = value
kwargs.setdefault('conv', {}).update(converts)
autocommit = kwargs.pop('autocommit', None)
charset = kwargs.pop('charset', 'utf8')
sql_mode = kwargs.pop('sql_mode', None)
use_unicode = kwargs.pop('use_unicode', False) or bool(charset)
client_version = tuple(map(int, _mysql.get_client_info().split('.')[:2]))
kwargs.setdefault('client_flag', 0)
if client_version >= (4, 1):
kwargs['client_flag'] |= constants.CLIENT.MULTI_STATEMENTS
if client_version >= (5, 0):
kwargs['client_flag'] |= constants.CLIENT.MULTI_RESULTS
# Done redefining variables for initialization. Engage _mysql!
super(Connection, self).__init__(*args, **kwargs)
self.server_version = tuple(map(int, self.get_server_info().split('.')[:2]))
if sql_mode:
self.SetSqlMode(sql_mode)
# The following voodoo is necssary to avoid double references that would
# prevent a connection object from being finalized and collected properly.
db = weakref.proxy(self)
def _GetStringLiteral():
def StringLiteral(string, _dummy=None):
"""Returns the SQL literal (safe) for the given string."""
return db.string_literal(string)
return StringLiteral
def _GetUnicodeLiteral():
def UnicodeLiteral(u_string, _dummy=None):
"""Returns the SQL (safe) literal for the given unicode object."""
return db.EscapeValues(u_string.encode(db.charset))
return UnicodeLiteral
def _GetStringDecoder():
def StringDecoder(string):
"""Returns the unicode codepoints for an encoded bytestream."""
return string.decode(db.charset)
return StringDecoder
self.string_decoder = _GetStringDecoder()
self.encoders[str] = _GetStringLiteral()
self.encoders[unicode] = self.unicode_literal = _GetUnicodeLiteral()
if use_unicode:
decoder = None, self.string_decoder
self.converter[constants.FIELD_TYPE.STRING].append(decoder)
self.converter[constants.FIELD_TYPE.VAR_STRING].append(decoder)
self.converter[constants.FIELD_TYPE.VARCHAR].append(decoder)
self.converter[constants.FIELD_TYPE.BLOB].append(decoder)
self._charset = None
self.charset = charset or self.character_set_name()
self.transactional = bool(self.server_capabilities &
constants.CLIENT.TRANSACTIONS)
self._autocommit = None
if autocommit is not None:
self.autocommit = autocommit
else:
self.autocommit = not self.transactional
def __init__(self, *args, **kwargs):
"""
Create a connection to the database. It is strongly recommended
that you only use keyword parameters. Consult the MySQL C API
documentation for more information.
host
string, host to connect
user
string, user to connect as
passwd
string, password to use
db
string, database to use
port
integer, TCP/IP port to connect to
unix_socket
string, location of unix_socket to use
conv
conversion dictionary, see MySQLdb.converters
connect_timeout
number of seconds to wait before the connection attempt
fails.
compress
if set, compression is enabled
named_pipe
if set, a named pipe is used to connect (Windows only)
init_command
command which is run once the connection is created
read_default_file
file from which default client values are read
read_default_group
configuration group to use from the default file
cursorclass
class object, used to create cursors (keyword only)
use_unicode
If True, text-like columns are returned as unicode objects
using the connection's character set. Otherwise, text-like
columns are returned as strings. columns are returned as
normal strings. Unicode objects will always be encoded to
the connection's character set regardless of this setting.
charset
If supplied, the connection character set will be changed
to this character set (MySQL-4.1 and newer). This implies
use_unicode=True.
sql_mode
If supplied, the session SQL mode will be changed to this
setting (MySQL-4.1 and newer). For more details and legal
values, see the MySQL documentation.
client_flag
integer, flags to use or 0
(see MySQL docs or constants/CLIENTS.py)
ssl
dictionary or mapping, contains SSL connection parameters;
see the MySQL documentation for more details
(mysql_ssl_set()). If this is set, and the client does not
support SSL, NotSupportedError will be raised.
local_infile
integer, non-zero enables LOAD LOCAL INFILE; zero disables
There are a number of undocumented, non-standard methods. See the
documentation for the MySQL C API for some hints on what they do.
"""
from MySQLdb.constants import CLIENT, FIELD_TYPE
from MySQLdb.converters import conversions
from weakref import proxy, WeakValueDictionary
import types
kwargs2 = kwargs.copy()
if 'conv' in kwargs:
conv = kwargs['conv']
else:
conv = conversions
conv2 = {}
for k, v in conv.items():
if isinstance(k, int) and isinstance(v, list):
conv2[k] = v[:]
else:
conv2[k] = v
kwargs2['conv'] = conv2
cursorclass = kwargs2.pop('cursorclass', self.default_cursor)
charset = kwargs2.pop('charset', '')
if charset:
use_unicode = True
else:
use_unicode = False
use_unicode = kwargs2.pop('use_unicode', use_unicode)
sql_mode = kwargs2.pop('sql_mode', '')
client_flag = kwargs.get('client_flag', 0)
client_version = tuple([ numeric_part(n) for n in _mysql.get_client_info().split('.')[:2] ])
if client_version >= (4, 1):
client_flag |= CLIENT.MULTI_STATEMENTS
if client_version >= (5, 0):
client_flag |= CLIENT.MULTI_RESULTS
kwargs2['client_flag'] = client_flag
super(Connection, self).__init__(*args, **kwargs2)
self.cursorclass = cursorclass
self.encoders = dict([ (k, v) for k, v in conv.items()
if type(k) is not int ])
self._server_version = tuple([ numeric_part(n) for n in self.get_server_info().split('.')[:2] ])
db = proxy(self)
def _get_string_literal():
def string_literal(obj, dummy=None):
return db.string_literal(obj)
return string_literal
def _get_unicode_literal():
def unicode_literal(u, dummy=None):
return db.literal(u.encode(unicode_literal.charset))
return unicode_literal
def _get_string_decoder():
def string_decoder(s):
return s.decode(string_decoder.charset)
return string_decoder
string_literal = _get_string_literal()
self.unicode_literal = unicode_literal = _get_unicode_literal()
self.string_decoder = string_decoder = _get_string_decoder()
if not charset:
charset = self.character_set_name()
self.set_character_set(charset)
if sql_mode:
self.set_sql_mode(sql_mode)
if use_unicode:
self.converter[FIELD_TYPE.STRING].append((None, string_decoder))
self.converter[FIELD_TYPE.VAR_STRING].append((None, string_decoder))
self.converter[FIELD_TYPE.VARCHAR].append((None, string_decoder))
self.converter[FIELD_TYPE.BLOB].append((None, string_decoder))
self.encoders[types.StringType] = string_literal
self.encoders[types.UnicodeType] = unicode_literal
self._transactional = self.server_capabilities & CLIENT.TRANSACTIONS
if self._transactional:
# PEP-249 requires autocommit to be initially off
self.autocommit(False)
self.messages = []
def __init__(self, *args, **kwargs):
"""
Create a connection to the database. It is strongly recommended
that you only use keyword parameters. Consult the MySQL C API
documentation for more information.
#--------------------------------------------------------------------------------------
host: string, host to connect
user: string, user to connect as
passwd: string, password to use
db: string, database to use
port: integer, TCP/IP port to connect to
unix_socket: string, location of unix_socket to use
conv: conversion dictionary, see MySQLdb.converters
connect_timeout: number of seconds to wait before the connection attempt fails.
compress: if set, compression is enabled
named_pipe: if set, a named pipe is used to connect (Windows only)
init_command: command which is run once the connection is created
read_default_file: file from which default client values are read
read_default_group: configuration group to use from the default file
cursorclass: class object, used to create cursors (keyword only)
use_unicode: If True, text-like columns are returned as unicode objects
using the connection's character set. Otherwise, text-like
columns are returned as strings. columns are returned as
normal strings. Unicode objects will always be encoded to
the connection's character set regardless of this setting.
charset: If supplied, the connection character set will be changed
to this character set (MySQL-4.1 and newer). This implies
use_unicode=True.
sql_mode: If supplied, the session SQL mode will be changed to this
setting (MySQL-4.1 and newer). For more details and legal
values, see the MySQL documentation.
client_flag: integer, flags to use or 0 (see MySQL docs or constants/CLIENTS.py)
ssl: dictionary or mapping, contains SSL connection parameters;
see the MySQL documentation for more details
(mysql_ssl_set()). If this is set, and the client does not
support SSL, NotSupportedError will be raised.
local_infile: integer, non-zero enables LOAD LOCAL INFILE; zero disables
#--------------------------------------------------------------------------------------
There are a number of undocumented, non-standard methods. See the
documentation for the MySQL C API for some hints on what they do.
"""
self._myfd = self.fd
from constants import CLIENT, FIELD_TYPE
from converters import conversions
conv,kwargs2 = conversions,kwargs.copy()
if kwargs.has_key('conv'): conv = kwargs['conv']
conv2 = {}
for k, v in conv.items():
if isinstance(k, int) and isinstance(v, list):
conv2[k] = v[:]
else: conv2[k] = v
kwargs2['conv'] = conv2
self.cursorclass = kwargs2.pop('cursorclass', self.default_cursor)
charset = kwargs2.pop('charset', '')
if charset: use_unicode = True
else: use_unicode = False
use_unicode = kwargs2.pop('use_unicode', use_unicode)
sql_mode = kwargs2.pop('sql_mode', '')
client_version = tuple([ numeric_part(n) for n in _mysql.get_client_info().split('.')[:2] ])
#
client_flag = kwargs.get('client_flag', 0)
if client_version >= (4, 1): client_flag |= CLIENT.MULTI_STATEMENTS
if client_version >= (5, 0): client_flag |= CLIENT.MULTI_RESULTS
kwargs2['client_flag'] = client_flag
#
#
super(Connection, self).__init__(*args, **kwargs2)
self.encoders = dict([ (k, v) for k, v in conv.items() if type(k) is not int ])
self._server_version = tuple([ numeric_part(n) for n in self.get_server_info().split('.')[:2] ])
db = proxy(self)
def _get_string_literal():
def string_literal(obj, dummy=None):
return db.string_literal(obj)
return string_literal
def _get_unicode_literal():
def unicode_literal(u, dummy=None):
return db.literal(u.encode(unicode_literal.charset))
return unicode_literal
def _get_string_decoder():
def string_decoder(s):
return s.decode(string_decoder.charset)
return string_decoder
string_literal = _get_string_literal()
self.unicode_literal = unicode_literal = _get_unicode_literal()
self.string_decoder = string_decoder = _get_string_decoder()
#--------charset
if not charset: charset = self.character_set_name()
self.set_character_set(charset)
#--------sql-mode
if sql_mode: self.set_sql_mode(sql_mode)
if use_unicode:
self.converter[FIELD_TYPE.STRING].append((None, string_decoder))
self.converter[FIELD_TYPE.VAR_STRING].append((None, string_decoder))
self.converter[FIELD_TYPE.VARCHAR].append((None, string_decoder))
self.converter[FIELD_TYPE.BLOB].append((None, string_decoder))
self.encoders[types.StringType] = string_literal
self.encoders[types.UnicodeType] = unicode_literal
self._transactional = self.server_capabilities & CLIENT.TRANSACTIONS
# PEP-249 requires autocommit to be initially off
if self._transactional: self.autocommit(False)
self.messages = []
#------------------------------------------------Royce
#
self._orig_query = super(Connection,self).query
self.query = self._async_query
#
self._orig_ping = super(Connection,self).ping
self.ping = self._async_ping
#
self._wait_channel = stackless.channel()
self._wait_channel.preference = 1
self._query_channel = stackless.channel()
self._release_wait(0,bInitial = True)
self._waitings = {}
def __init__(self, user, passwd, *args, **kwargs):
"""Create a connection to the database. It is strongly recommended
that you only use keyword parameters. Consult the MySQL C API
documentation for more information.
Arguments:
user: string, user to connect as.
passwd: string, password to use.
db: string, database to use. Default same as user.
host: string, host to connect to. Default 'localhost'.
port: integer, TCP/IP port to connect to.
unix_socket: string, location of unix_socket to use.
conv: conversion dictionary, see converters module.
connect_timeout: number of seconds to wait before the connection
attempt fails.
compress: bool, enable compression. Default False
named_pipe: if set, a named pipe is used to connect (Windows only)
init_command: command which is run once the connection is created
read_default_file: file from which default client values are read
read_default_group: configuration group to use from the default file
use_unicode: If True, text-like columns are returned as unicode
objects using the connection's character set.
Otherwise, text-like columns are returned as strings.
Columns are returned as normal strings. Unicode
objects will always be encoded to the connection's
character set regardless of this setting.
charset: If supplied, the connection character set will be
changed to this character set (MySQL-4.1 and newer).
This enforces use_unicode=True.
sql_mode: If supplied, the session SQL mode will be changed to
this setting (MySQL-4.1 and newer). For more details
and legal values, see the MySQL documentation.
client_flag: integer, flags to use or 0.
(see MySQL docs or constants/CLIENTS.py)
ssl: dictionary or mapping, contains SSL connection
parameters; see the MySQL documentation for more
details (mysql_ssl_set()). If this is set, and the
client does not support SSL, NotSupportedError will
be raised.
local_infile: bool, True enables LOAD LOCAL INFILE, False disables.
Default False
There are a number of undocumented, non-standard arguments. See the
documentation for the MySQL C API for some hints on what they do.
"""
# Counters, transaction lock & timer
self.counter_transactions = 0
self.counter_queries = 0
self.queries = []
self.transaction_timer = None
self.lock = threading.Lock()
# _mysql connect args mapping
kwargs['user'] = user
kwargs['passwd'] = passwd
kwargs['host'] = kwargs.get('host', 'localhost')
kwargs['db'] = kwargs.get('db', user)
self.logger = logging.getLogger('mysql_%s' % kwargs['db'])
if kwargs.pop('debug', False):
self.debug = True
self.logger.setLevel(logging.DEBUG)
else:
self.debug = False
self.logger.setLevel(logging.WARNING)
if kwargs.pop('disable_log', False):
self.logger.disable_logger = True
self.encoders = {}
converts = {}
for key, value in converters.CONVERSIONS.iteritems():
if not isinstance(key, int):
self.encoders[key] = value
else:
if isinstance(value, list):
converts[key] = value[:]
else:
converts[key] = value
kwargs.setdefault('conv', {}).update(converts)
autocommit = kwargs.pop('autocommit', None)
charset = kwargs.pop('charset', 'utf8')
sql_mode = kwargs.pop('sql_mode', None)
use_unicode = kwargs.pop('use_unicode', False) or bool(charset)
client_version = tuple(
map(int,
_mysql.get_client_info().split('.')[:2]))
kwargs.setdefault('client_flag', 0)
if client_version >= (4, 1):
kwargs['client_flag'] |= constants.CLIENT.MULTI_STATEMENTS
if client_version >= (5, 0):
kwargs['client_flag'] |= constants.CLIENT.MULTI_RESULTS
# Done redefining variables for initialization. Engage _mysql!
super(Connection, self).__init__(*args, **kwargs)
self.server_version = tuple(
map(int,
self.get_server_info().split('.')[:2]))
if sql_mode:
self.SetSqlMode(sql_mode)
# The following voodoo is necssary to avoid double references that would
# prevent a connection object from being finalized and collected properly.
db = weakref.proxy(self)
def _GetStringLiteral():
def StringLiteral(string, _dummy=None):
"""Returns the SQL literal (safe) for the given string."""
return db.string_literal(string)
return StringLiteral
def _GetUnicodeLiteral():
def UnicodeLiteral(u_string, _dummy=None):
"""Returns the SQL (safe) literal for the given unicode object."""
return db.EscapeValues(u_string.encode(db.charset))
return UnicodeLiteral
def _GetStringDecoder():
def StringDecoder(string):
"""Returns the unicode codepoints for an encoded bytestream."""
return string.decode(db.charset)
return StringDecoder
self.string_decoder = _GetStringDecoder()
self.encoders[str] = _GetStringLiteral()
self.encoders[unicode] = self.unicode_literal = _GetUnicodeLiteral()
if use_unicode:
decoder = None, self.string_decoder
self.converter[constants.FIELD_TYPE.STRING].append(decoder)
self.converter[constants.FIELD_TYPE.VAR_STRING].append(decoder)
self.converter[constants.FIELD_TYPE.VARCHAR].append(decoder)
self.converter[constants.FIELD_TYPE.BLOB].append(decoder)
self._charset = None
self.charset = charset or self.character_set_name()
self.transactional = bool(self.server_capabilities
& constants.CLIENT.TRANSACTIONS)
self._autocommit = None
if autocommit is not None:
self.autocommit = autocommit
else:
self.autocommit = not self.transactional
