├── README.md
├── asynctorndb
    ├── __init__.py
    ├── _compat.py
    ├── _socketio.py
    ├── charset.py
    ├── connection.py
    ├── constants
    │   ├── CLIENT.py
    │   ├── COMMAND.py
    │   ├── ER.py
    │   ├── FIELD_TYPE.py
    │   ├── FLAG.py
    │   ├── SERVER_STATUS.py
    │   └── __init__.py
    ├── converters.py
    ├── cursors.py
    ├── err.py
    ├── tcpclient.py
    ├── times.py
    └── util.py
└── setup.py


/README.md:
--------------------------------------------------------------------------------
 1 | AsyncTorndb(inactive)
 2 | =====================
 3 | 
 4 | Async mysql client for tornado base on [PyMySQL](https://github.com/PyMySQL/PyMySQL).
 5 | 
 6 | Documentation
 7 | ===========
 8 | 
 9 | AsyncTorndb behavior is almost like torndb behavior, but async. Refer to [torndb](http://torndb.readthedocs.org)
10 | and have a try.
11 | 
12 | Requirements
13 | ===========
14 | 
15 |  * [tornado](https://github.com/tornadoweb/tornado) with latest
16 | 
17 | Demo
18 | ===========
19 | 
20 | Here is a simple "Hello, world" example web app for AsyncTorndb::
21 | 
22 |     import tornado.ioloop
23 |     import tornado.web
24 |     import tornado.gen
25 |     import asynctorndb
26 |     
27 |     class MainHandler(tornado.web.RequestHandler):
28 |         @tornado.gen.coroutine
29 |         def get(self):
30 |             conn = asynctorndb.Connect(user='demo', passwd='demo', database='demo')
31 |             yield conn.connect()
32 |             result = yield conn.query('select * from user')
33 |             # do something with result
34 |             self.write("Hello, world")
35 | 
36 |     application = tornado.web.Application([
37 |         (r"/", MainHandler),
38 |     ])
39 | 
40 |     if __name__ == "__main__":
41 |         application.listen(8888)
42 |         tornado.ioloop.IOLoop.instance().start()
43 | 
44 | License
45 | ===========
46 | 
47 | AsyncTorndb is released under the MIT License. See LICENSE for more information.
48 | 


--------------------------------------------------------------------------------
/asynctorndb/__init__.py:
--------------------------------------------------------------------------------
  1 | '''
  2 | PyMySQL: A pure-Python MySQL client library.
  3 | 
  4 | Copyright (c) 2010, 2013 PyMySQL contributors
  5 | 
  6 | Permission is hereby granted, free of charge, to any person obtaining a copy
  7 | of this software and associated documentation files (the "Software"), to deal
  8 | in the Software without restriction, including without limitation the rights
  9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 | copies of the Software, and to permit persons to whom the Software is
 11 | furnished to do so, subject to the following conditions:
 12 | 
 13 | The above copyright notice and this permission notice shall be included in
 14 | all copies or substantial portions of the Software.
 15 | 
 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 22 | THE SOFTWARE.
 23 | 
 24 | '''
 25 | 
 26 | VERSION = (0, 6, 2, None)
 27 | 
 28 | from ._compat import text_type, JYTHON, IRONPYTHON
 29 | from .constants import FIELD_TYPE
 30 | from .converters import escape_dict, escape_sequence, escape_string
 31 | from .err import Warning, Error, InterfaceError, DataError, \
 32 |      DatabaseError, OperationalError, IntegrityError, InternalError, \
 33 |      NotSupportedError, ProgrammingError, MySQLError
 34 | from .times import Date, Time, Timestamp, \
 35 |     DateFromTicks, TimeFromTicks, TimestampFromTicks
 36 | 
 37 | import sys
 38 | 
 39 | 
 40 | threadsafety = 1
 41 | apilevel = "2.0"
 42 | paramstyle = "format"
 43 | 
 44 | class DBAPISet(frozenset):
 45 | 
 46 | 
 47 |     def __ne__(self, other):
 48 |         if isinstance(other, set):
 49 |             return super(DBAPISet, self).__ne__(self, other)
 50 |         else:
 51 |             return other not in self
 52 | 
 53 |     def __eq__(self, other):
 54 |         if isinstance(other, frozenset):
 55 |             return frozenset.__eq__(self, other)
 56 |         else:
 57 |             return other in self
 58 | 
 59 |     def __hash__(self):
 60 |         return frozenset.__hash__(self)
 61 | 
 62 | 
 63 | STRING    = DBAPISet([FIELD_TYPE.ENUM, FIELD_TYPE.STRING,
 64 |                      FIELD_TYPE.VAR_STRING])
 65 | BINARY    = DBAPISet([FIELD_TYPE.BLOB, FIELD_TYPE.LONG_BLOB,
 66 |                      FIELD_TYPE.MEDIUM_BLOB, FIELD_TYPE.TINY_BLOB])
 67 | NUMBER    = DBAPISet([FIELD_TYPE.DECIMAL, FIELD_TYPE.DOUBLE, FIELD_TYPE.FLOAT,
 68 |                      FIELD_TYPE.INT24, FIELD_TYPE.LONG, FIELD_TYPE.LONGLONG,
 69 |                      FIELD_TYPE.TINY, FIELD_TYPE.YEAR])
 70 | DATE      = DBAPISet([FIELD_TYPE.DATE, FIELD_TYPE.NEWDATE])
 71 | TIME      = DBAPISet([FIELD_TYPE.TIME])
 72 | TIMESTAMP = DBAPISet([FIELD_TYPE.TIMESTAMP, FIELD_TYPE.DATETIME])
 73 | DATETIME  = TIMESTAMP
 74 | ROWID     = DBAPISet()
 75 | 
 76 | def Binary(x):
 77 |     """Return x as a binary type."""
 78 |     if isinstance(x, text_type) and not (JYTHON or IRONPYTHON):
 79 |         return x.encode()
 80 |     return bytes(x)
 81 | 
 82 | def Connect(*args, **kwargs):
 83 |     """
 84 |     Connect to the database; see connection.Connection.__init__() for
 85 |     more information.
 86 |     """
 87 |     from .connection import Connection
 88 |     return Connection(*args, **kwargs)
 89 | 
 90 | from asynctorndb import connection as _orig_conn
 91 | if _orig_conn.Connection.__init__.__doc__ is not None:
 92 |     Connect.__doc__ = _orig_conn.Connection.__init__.__doc__ + ("""
 93 | See connection.Connection.__init__() for information about defaults.
 94 | """)
 95 | del _orig_conn
 96 | 
 97 | def get_client_info():  # for MySQLdb compatibility
 98 |     return '.'.join(map(str, VERSION))
 99 | 
100 | connect = Connection = Connect
101 | 
102 | # we include a doctored version_info here for MySQLdb compatibility
103 | version_info = (1,2,2,"final",0)
104 | 
105 | NULL = "NULL"
106 | 
107 | __version__ = get_client_info()
108 | 
109 | def thread_safe():
110 |     return True # match MySQLdb.thread_safe()
111 | 
112 | def install_as_MySQLdb():
113 |     """
114 |     After this function is called, any application that imports MySQLdb or
115 |     _mysql will unwittingly actually use
116 |     """
117 |     sys.modules["MySQLdb"] = sys.modules["_mysql"] = sys.modules["pymysql"]
118 | 
119 | __all__ = [
120 |     'BINARY', 'Binary', 'Connect', 'Connection', 'DATE', 'Date',
121 |     'Time', 'Timestamp', 'DateFromTicks', 'TimeFromTicks', 'TimestampFromTicks',
122 |     'DataError', 'DatabaseError', 'Error', 'FIELD_TYPE', 'IntegrityError',
123 |     'InterfaceError', 'InternalError', 'MySQLError', 'NULL', 'NUMBER',
124 |     'NotSupportedError', 'DBAPISet', 'OperationalError', 'ProgrammingError',
125 |     'ROWID', 'STRING', 'TIME', 'TIMESTAMP', 'Warning', 'apilevel', 'connect',
126 |     'connection', 'constants', 'converters', 'cursors',
127 |     'escape_dict', 'escape_sequence', 'escape_string', 'get_client_info',
128 |     'paramstyle', 'threadsafety', 'version_info',
129 | 
130 |     "install_as_MySQLdb",
131 | 
132 |     "NULL","__version__",
133 |     ]
134 | 


--------------------------------------------------------------------------------
/asynctorndb/_compat.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | 
 3 | PY2 = sys.version_info[0] == 2
 4 | PYPY = hasattr(sys, 'pypy_translation_info')
 5 | JYTHON = sys.platform.startswith('java')
 6 | IRONPYTHON = sys.platform == 'cli'
 7 | 
 8 | if PY2:
 9 |     range_type = xrange
10 |     text_type = unicode
11 |     long_type = long
12 |     str_type = basestring
13 | else:
14 |     range_type = range
15 |     text_type = str
16 |     long_type = int
17 |     str_type = str
18 | 


--------------------------------------------------------------------------------
/asynctorndb/_socketio.py:
--------------------------------------------------------------------------------
  1 | """
  2 | SocketIO imported from socket module in Python 3.
  3 | 
  4 | Copyright (c) 2001-2013 Python Software Foundation; All Rights Reserved.
  5 | """
  6 | 
  7 | from socket import *
  8 | import io
  9 | import errno
 10 | 
 11 | __all__ = ['SocketIO']
 12 | 
 13 | EINTR = errno.EINTR
 14 | _blocking_errnos = { errno.EAGAIN, errno.EWOULDBLOCK }
 15 | 
 16 | class SocketIO(io.RawIOBase):
 17 | 
 18 |     """Raw I/O implementation for stream sockets.
 19 | 
 20 |     This class supports the makefile() method on sockets.  It provides
 21 |     the raw I/O interface on top of a socket object.
 22 |     """
 23 | 
 24 |     # One might wonder why not let FileIO do the job instead.  There are two
 25 |     # main reasons why FileIO is not adapted:
 26 |     # - it wouldn't work under Windows (where you can't used read() and
 27 |     #   write() on a socket handle)
 28 |     # - it wouldn't work with socket timeouts (FileIO would ignore the
 29 |     #   timeout and consider the socket non-blocking)
 30 | 
 31 |     # XXX More docs
 32 | 
 33 |     def __init__(self, sock, mode):
 34 |         if mode not in ("r", "w", "rw", "rb", "wb", "rwb"):
 35 |             raise ValueError("invalid mode: %r" % mode)
 36 |         io.RawIOBase.__init__(self)
 37 |         self._sock = sock
 38 |         if "b" not in mode:
 39 |             mode += "b"
 40 |         self._mode = mode
 41 |         self._reading = "r" in mode
 42 |         self._writing = "w" in mode
 43 |         self._timeout_occurred = False
 44 | 
 45 |     def readinto(self, b):
 46 |         """Read up to len(b) bytes into the writable buffer *b* and return
 47 |         the number of bytes read.  If the socket is non-blocking and no bytes
 48 |         are available, None is returned.
 49 | 
 50 |         If *b* is non-empty, a 0 return value indicates that the connection
 51 |         was shutdown at the other end.
 52 |         """
 53 |         self._checkClosed()
 54 |         self._checkReadable()
 55 |         if self._timeout_occurred:
 56 |             raise IOError("cannot read from timed out object")
 57 |         while True:
 58 |             try:
 59 |                 return self._sock.recv_into(b)
 60 |             except timeout:
 61 |                 self._timeout_occurred = True
 62 |                 raise
 63 |             except error as e:
 64 |                 n = e.args[0]
 65 |                 if n == EINTR:
 66 |                     continue
 67 |                 if n in _blocking_errnos:
 68 |                     return None
 69 |                 raise
 70 | 
 71 |     def write(self, b):
 72 |         """Write the given bytes or bytearray object *b* to the socket
 73 |         and return the number of bytes written.  This can be less than
 74 |         len(b) if not all data could be written.  If the socket is
 75 |         non-blocking and no bytes could be written None is returned.
 76 |         """
 77 |         self._checkClosed()
 78 |         self._checkWritable()
 79 |         try:
 80 |             return self._sock.send(b)
 81 |         except error as e:
 82 |             # XXX what about EINTR?
 83 |             if e.args[0] in _blocking_errnos:
 84 |                 return None
 85 |             raise
 86 | 
 87 |     def readable(self):
 88 |         """True if the SocketIO is open for reading.
 89 |         """
 90 |         if self.closed:
 91 |             raise ValueError("I/O operation on closed socket.")
 92 |         return self._reading
 93 | 
 94 |     def writable(self):
 95 |         """True if the SocketIO is open for writing.
 96 |         """
 97 |         if self.closed:
 98 |             raise ValueError("I/O operation on closed socket.")
 99 |         return self._writing
100 | 
101 |     def seekable(self):
102 |         """True if the SocketIO is open for seeking.
103 |         """
104 |         if self.closed:
105 |             raise ValueError("I/O operation on closed socket.")
106 |         return super().seekable()
107 | 
108 |     def fileno(self):
109 |         """Return the file descriptor of the underlying socket.
110 |         """
111 |         self._checkClosed()
112 |         return self._sock.fileno()
113 | 
114 |     @property
115 |     def name(self):
116 |         if not self.closed:
117 |             return self.fileno()
118 |         else:
119 |             return -1
120 | 
121 |     @property
122 |     def mode(self):
123 |         return self._mode
124 | 
125 |     def close(self):
126 |         """Close the SocketIO object.  This doesn't close the underlying
127 |         socket, except if all references to it have disappeared.
128 |         """
129 |         if self.closed:
130 |             return
131 |         io.RawIOBase.close(self)
132 |         self._sock._decref_socketios()
133 |         self._sock = None
134 | 
135 | 


--------------------------------------------------------------------------------
/asynctorndb/charset.py:
--------------------------------------------------------------------------------
  1 | MBLENGTH = {
  2 |         8:1,
  3 |         33:3,
  4 |         88:2,
  5 |         91:2
  6 |         }
  7 | 
  8 | 
  9 | class Charset(object):
 10 |     def __init__(self, id, name, collation, is_default):
 11 |         self.id, self.name, self.collation = id, name, collation
 12 |         self.is_default = is_default == 'Yes'
 13 | 
 14 |     @property
 15 |     def encoding(self):
 16 |         name = self.name
 17 |         if name == 'utf8mb4':
 18 |             return 'utf8'
 19 |         return name
 20 | 
 21 |     @property
 22 |     def is_binary(self):
 23 |         return self.id == 63
 24 | 
 25 | 
 26 | class Charsets:
 27 |     def __init__(self):
 28 |         self._by_id = {}
 29 | 
 30 |     def add(self, c):
 31 |         self._by_id[c.id] = c
 32 | 
 33 |     def by_id(self, id):
 34 |         return self._by_id[id]
 35 | 
 36 |     def by_name(self, name):
 37 |         name = name.lower()
 38 |         for c in list(self._by_id.values()):
 39 |             if c.name == name and c.is_default:
 40 |                 return c
 41 | 
 42 | _charsets = Charsets()
 43 | """
 44 | Generated with:
 45 | 
 46 | mysql -N -s -e "select id, character_set_name, collation_name, is_default
 47 | from information_schema.collations order by id;" | python -c "import sys
 48 | for l in sys.stdin.readlines():
 49 |         id, name, collation, is_default  = l.split(chr(9))
 50 |         print '_charsets.add(Charset(%s, \'%s\', \'%s\', \'%s\'))' \
 51 |                 % (id, name, collation, is_default.strip())
 52 | "
 53 | 
 54 | """
 55 | _charsets.add(Charset(1, 'big5', 'big5_chinese_ci', 'Yes'))
 56 | _charsets.add(Charset(2, 'latin2', 'latin2_czech_cs', ''))
 57 | _charsets.add(Charset(3, 'dec8', 'dec8_swedish_ci', 'Yes'))
 58 | _charsets.add(Charset(4, 'cp850', 'cp850_general_ci', 'Yes'))
 59 | _charsets.add(Charset(5, 'latin1', 'latin1_german1_ci', ''))
 60 | _charsets.add(Charset(6, 'hp8', 'hp8_english_ci', 'Yes'))
 61 | _charsets.add(Charset(7, 'koi8r', 'koi8r_general_ci', 'Yes'))
 62 | _charsets.add(Charset(8, 'latin1', 'latin1_swedish_ci', 'Yes'))
 63 | _charsets.add(Charset(9, 'latin2', 'latin2_general_ci', 'Yes'))
 64 | _charsets.add(Charset(10, 'swe7', 'swe7_swedish_ci', 'Yes'))
 65 | _charsets.add(Charset(11, 'ascii', 'ascii_general_ci', 'Yes'))
 66 | _charsets.add(Charset(12, 'ujis', 'ujis_japanese_ci', 'Yes'))
 67 | _charsets.add(Charset(13, 'sjis', 'sjis_japanese_ci', 'Yes'))
 68 | _charsets.add(Charset(14, 'cp1251', 'cp1251_bulgarian_ci', ''))
 69 | _charsets.add(Charset(15, 'latin1', 'latin1_danish_ci', ''))
 70 | _charsets.add(Charset(16, 'hebrew', 'hebrew_general_ci', 'Yes'))
 71 | _charsets.add(Charset(18, 'tis620', 'tis620_thai_ci', 'Yes'))
 72 | _charsets.add(Charset(19, 'euckr', 'euckr_korean_ci', 'Yes'))
 73 | _charsets.add(Charset(20, 'latin7', 'latin7_estonian_cs', ''))
 74 | _charsets.add(Charset(21, 'latin2', 'latin2_hungarian_ci', ''))
 75 | _charsets.add(Charset(22, 'koi8u', 'koi8u_general_ci', 'Yes'))
 76 | _charsets.add(Charset(23, 'cp1251', 'cp1251_ukrainian_ci', ''))
 77 | _charsets.add(Charset(24, 'gb2312', 'gb2312_chinese_ci', 'Yes'))
 78 | _charsets.add(Charset(25, 'greek', 'greek_general_ci', 'Yes'))
 79 | _charsets.add(Charset(26, 'cp1250', 'cp1250_general_ci', 'Yes'))
 80 | _charsets.add(Charset(27, 'latin2', 'latin2_croatian_ci', ''))
 81 | _charsets.add(Charset(28, 'gbk', 'gbk_chinese_ci', 'Yes'))
 82 | _charsets.add(Charset(29, 'cp1257', 'cp1257_lithuanian_ci', ''))
 83 | _charsets.add(Charset(30, 'latin5', 'latin5_turkish_ci', 'Yes'))
 84 | _charsets.add(Charset(31, 'latin1', 'latin1_german2_ci', ''))
 85 | _charsets.add(Charset(32, 'armscii8', 'armscii8_general_ci', 'Yes'))
 86 | _charsets.add(Charset(33, 'utf8', 'utf8_general_ci', 'Yes'))
 87 | _charsets.add(Charset(34, 'cp1250', 'cp1250_czech_cs', ''))
 88 | _charsets.add(Charset(35, 'ucs2', 'ucs2_general_ci', 'Yes'))
 89 | _charsets.add(Charset(36, 'cp866', 'cp866_general_ci', 'Yes'))
 90 | _charsets.add(Charset(37, 'keybcs2', 'keybcs2_general_ci', 'Yes'))
 91 | _charsets.add(Charset(38, 'macce', 'macce_general_ci', 'Yes'))
 92 | _charsets.add(Charset(39, 'macroman', 'macroman_general_ci', 'Yes'))
 93 | _charsets.add(Charset(40, 'cp852', 'cp852_general_ci', 'Yes'))
 94 | _charsets.add(Charset(41, 'latin7', 'latin7_general_ci', 'Yes'))
 95 | _charsets.add(Charset(42, 'latin7', 'latin7_general_cs', ''))
 96 | _charsets.add(Charset(43, 'macce', 'macce_bin', ''))
 97 | _charsets.add(Charset(44, 'cp1250', 'cp1250_croatian_ci', ''))
 98 | _charsets.add(Charset(45, 'utf8mb4', 'utf8mb4_general_ci', 'Yes'))
 99 | _charsets.add(Charset(46, 'utf8mb4', 'utf8mb4_bin', ''))
100 | _charsets.add(Charset(47, 'latin1', 'latin1_bin', ''))
101 | _charsets.add(Charset(48, 'latin1', 'latin1_general_ci', ''))
102 | _charsets.add(Charset(49, 'latin1', 'latin1_general_cs', ''))
103 | _charsets.add(Charset(50, 'cp1251', 'cp1251_bin', ''))
104 | _charsets.add(Charset(51, 'cp1251', 'cp1251_general_ci', 'Yes'))
105 | _charsets.add(Charset(52, 'cp1251', 'cp1251_general_cs', ''))
106 | _charsets.add(Charset(53, 'macroman', 'macroman_bin', ''))
107 | _charsets.add(Charset(54, 'utf16', 'utf16_general_ci', 'Yes'))
108 | _charsets.add(Charset(55, 'utf16', 'utf16_bin', ''))
109 | _charsets.add(Charset(57, 'cp1256', 'cp1256_general_ci', 'Yes'))
110 | _charsets.add(Charset(58, 'cp1257', 'cp1257_bin', ''))
111 | _charsets.add(Charset(59, 'cp1257', 'cp1257_general_ci', 'Yes'))
112 | _charsets.add(Charset(60, 'utf32', 'utf32_general_ci', 'Yes'))
113 | _charsets.add(Charset(61, 'utf32', 'utf32_bin', ''))
114 | _charsets.add(Charset(63, 'binary', 'binary', 'Yes'))
115 | _charsets.add(Charset(64, 'armscii8', 'armscii8_bin', ''))
116 | _charsets.add(Charset(65, 'ascii', 'ascii_bin', ''))
117 | _charsets.add(Charset(66, 'cp1250', 'cp1250_bin', ''))
118 | _charsets.add(Charset(67, 'cp1256', 'cp1256_bin', ''))
119 | _charsets.add(Charset(68, 'cp866', 'cp866_bin', ''))
120 | _charsets.add(Charset(69, 'dec8', 'dec8_bin', ''))
121 | _charsets.add(Charset(70, 'greek', 'greek_bin', ''))
122 | _charsets.add(Charset(71, 'hebrew', 'hebrew_bin', ''))
123 | _charsets.add(Charset(72, 'hp8', 'hp8_bin', ''))
124 | _charsets.add(Charset(73, 'keybcs2', 'keybcs2_bin', ''))
125 | _charsets.add(Charset(74, 'koi8r', 'koi8r_bin', ''))
126 | _charsets.add(Charset(75, 'koi8u', 'koi8u_bin', ''))
127 | _charsets.add(Charset(77, 'latin2', 'latin2_bin', ''))
128 | _charsets.add(Charset(78, 'latin5', 'latin5_bin', ''))
129 | _charsets.add(Charset(79, 'latin7', 'latin7_bin', ''))
130 | _charsets.add(Charset(80, 'cp850', 'cp850_bin', ''))
131 | _charsets.add(Charset(81, 'cp852', 'cp852_bin', ''))
132 | _charsets.add(Charset(82, 'swe7', 'swe7_bin', ''))
133 | _charsets.add(Charset(83, 'utf8', 'utf8_bin', ''))
134 | _charsets.add(Charset(84, 'big5', 'big5_bin', ''))
135 | _charsets.add(Charset(85, 'euckr', 'euckr_bin', ''))
136 | _charsets.add(Charset(86, 'gb2312', 'gb2312_bin', ''))
137 | _charsets.add(Charset(87, 'gbk', 'gbk_bin', ''))
138 | _charsets.add(Charset(88, 'sjis', 'sjis_bin', ''))
139 | _charsets.add(Charset(89, 'tis620', 'tis620_bin', ''))
140 | _charsets.add(Charset(90, 'ucs2', 'ucs2_bin', ''))
141 | _charsets.add(Charset(91, 'ujis', 'ujis_bin', ''))
142 | _charsets.add(Charset(92, 'geostd8', 'geostd8_general_ci', 'Yes'))
143 | _charsets.add(Charset(93, 'geostd8', 'geostd8_bin', ''))
144 | _charsets.add(Charset(94, 'latin1', 'latin1_spanish_ci', ''))
145 | _charsets.add(Charset(95, 'cp932', 'cp932_japanese_ci', 'Yes'))
146 | _charsets.add(Charset(96, 'cp932', 'cp932_bin', ''))
147 | _charsets.add(Charset(97, 'eucjpms', 'eucjpms_japanese_ci', 'Yes'))
148 | _charsets.add(Charset(98, 'eucjpms', 'eucjpms_bin', ''))
149 | _charsets.add(Charset(99, 'cp1250', 'cp1250_polish_ci', ''))
150 | _charsets.add(Charset(101, 'utf16', 'utf16_unicode_ci', ''))
151 | _charsets.add(Charset(102, 'utf16', 'utf16_icelandic_ci', ''))
152 | _charsets.add(Charset(103, 'utf16', 'utf16_latvian_ci', ''))
153 | _charsets.add(Charset(104, 'utf16', 'utf16_romanian_ci', ''))
154 | _charsets.add(Charset(105, 'utf16', 'utf16_slovenian_ci', ''))
155 | _charsets.add(Charset(106, 'utf16', 'utf16_polish_ci', ''))
156 | _charsets.add(Charset(107, 'utf16', 'utf16_estonian_ci', ''))
157 | _charsets.add(Charset(108, 'utf16', 'utf16_spanish_ci', ''))
158 | _charsets.add(Charset(109, 'utf16', 'utf16_swedish_ci', ''))
159 | _charsets.add(Charset(110, 'utf16', 'utf16_turkish_ci', ''))
160 | _charsets.add(Charset(111, 'utf16', 'utf16_czech_ci', ''))
161 | _charsets.add(Charset(112, 'utf16', 'utf16_danish_ci', ''))
162 | _charsets.add(Charset(113, 'utf16', 'utf16_lithuanian_ci', ''))
163 | _charsets.add(Charset(114, 'utf16', 'utf16_slovak_ci', ''))
164 | _charsets.add(Charset(115, 'utf16', 'utf16_spanish2_ci', ''))
165 | _charsets.add(Charset(116, 'utf16', 'utf16_roman_ci', ''))
166 | _charsets.add(Charset(117, 'utf16', 'utf16_persian_ci', ''))
167 | _charsets.add(Charset(118, 'utf16', 'utf16_esperanto_ci', ''))
168 | _charsets.add(Charset(119, 'utf16', 'utf16_hungarian_ci', ''))
169 | _charsets.add(Charset(120, 'utf16', 'utf16_sinhala_ci', ''))
170 | _charsets.add(Charset(128, 'ucs2', 'ucs2_unicode_ci', ''))
171 | _charsets.add(Charset(129, 'ucs2', 'ucs2_icelandic_ci', ''))
172 | _charsets.add(Charset(130, 'ucs2', 'ucs2_latvian_ci', ''))
173 | _charsets.add(Charset(131, 'ucs2', 'ucs2_romanian_ci', ''))
174 | _charsets.add(Charset(132, 'ucs2', 'ucs2_slovenian_ci', ''))
175 | _charsets.add(Charset(133, 'ucs2', 'ucs2_polish_ci', ''))
176 | _charsets.add(Charset(134, 'ucs2', 'ucs2_estonian_ci', ''))
177 | _charsets.add(Charset(135, 'ucs2', 'ucs2_spanish_ci', ''))
178 | _charsets.add(Charset(136, 'ucs2', 'ucs2_swedish_ci', ''))
179 | _charsets.add(Charset(137, 'ucs2', 'ucs2_turkish_ci', ''))
180 | _charsets.add(Charset(138, 'ucs2', 'ucs2_czech_ci', ''))
181 | _charsets.add(Charset(139, 'ucs2', 'ucs2_danish_ci', ''))
182 | _charsets.add(Charset(140, 'ucs2', 'ucs2_lithuanian_ci', ''))
183 | _charsets.add(Charset(141, 'ucs2', 'ucs2_slovak_ci', ''))
184 | _charsets.add(Charset(142, 'ucs2', 'ucs2_spanish2_ci', ''))
185 | _charsets.add(Charset(143, 'ucs2', 'ucs2_roman_ci', ''))
186 | _charsets.add(Charset(144, 'ucs2', 'ucs2_persian_ci', ''))
187 | _charsets.add(Charset(145, 'ucs2', 'ucs2_esperanto_ci', ''))
188 | _charsets.add(Charset(146, 'ucs2', 'ucs2_hungarian_ci', ''))
189 | _charsets.add(Charset(147, 'ucs2', 'ucs2_sinhala_ci', ''))
190 | _charsets.add(Charset(159, 'ucs2', 'ucs2_general_mysql500_ci', ''))
191 | _charsets.add(Charset(160, 'utf32', 'utf32_unicode_ci', ''))
192 | _charsets.add(Charset(161, 'utf32', 'utf32_icelandic_ci', ''))
193 | _charsets.add(Charset(162, 'utf32', 'utf32_latvian_ci', ''))
194 | _charsets.add(Charset(163, 'utf32', 'utf32_romanian_ci', ''))
195 | _charsets.add(Charset(164, 'utf32', 'utf32_slovenian_ci', ''))
196 | _charsets.add(Charset(165, 'utf32', 'utf32_polish_ci', ''))
197 | _charsets.add(Charset(166, 'utf32', 'utf32_estonian_ci', ''))
198 | _charsets.add(Charset(167, 'utf32', 'utf32_spanish_ci', ''))
199 | _charsets.add(Charset(168, 'utf32', 'utf32_swedish_ci', ''))
200 | _charsets.add(Charset(169, 'utf32', 'utf32_turkish_ci', ''))
201 | _charsets.add(Charset(170, 'utf32', 'utf32_czech_ci', ''))
202 | _charsets.add(Charset(171, 'utf32', 'utf32_danish_ci', ''))
203 | _charsets.add(Charset(172, 'utf32', 'utf32_lithuanian_ci', ''))
204 | _charsets.add(Charset(173, 'utf32', 'utf32_slovak_ci', ''))
205 | _charsets.add(Charset(174, 'utf32', 'utf32_spanish2_ci', ''))
206 | _charsets.add(Charset(175, 'utf32', 'utf32_roman_ci', ''))
207 | _charsets.add(Charset(176, 'utf32', 'utf32_persian_ci', ''))
208 | _charsets.add(Charset(177, 'utf32', 'utf32_esperanto_ci', ''))
209 | _charsets.add(Charset(178, 'utf32', 'utf32_hungarian_ci', ''))
210 | _charsets.add(Charset(179, 'utf32', 'utf32_sinhala_ci', ''))
211 | _charsets.add(Charset(192, 'utf8', 'utf8_unicode_ci', ''))
212 | _charsets.add(Charset(193, 'utf8', 'utf8_icelandic_ci', ''))
213 | _charsets.add(Charset(194, 'utf8', 'utf8_latvian_ci', ''))
214 | _charsets.add(Charset(195, 'utf8', 'utf8_romanian_ci', ''))
215 | _charsets.add(Charset(196, 'utf8', 'utf8_slovenian_ci', ''))
216 | _charsets.add(Charset(197, 'utf8', 'utf8_polish_ci', ''))
217 | _charsets.add(Charset(198, 'utf8', 'utf8_estonian_ci', ''))
218 | _charsets.add(Charset(199, 'utf8', 'utf8_spanish_ci', ''))
219 | _charsets.add(Charset(200, 'utf8', 'utf8_swedish_ci', ''))
220 | _charsets.add(Charset(201, 'utf8', 'utf8_turkish_ci', ''))
221 | _charsets.add(Charset(202, 'utf8', 'utf8_czech_ci', ''))
222 | _charsets.add(Charset(203, 'utf8', 'utf8_danish_ci', ''))
223 | _charsets.add(Charset(204, 'utf8', 'utf8_lithuanian_ci', ''))
224 | _charsets.add(Charset(205, 'utf8', 'utf8_slovak_ci', ''))
225 | _charsets.add(Charset(206, 'utf8', 'utf8_spanish2_ci', ''))
226 | _charsets.add(Charset(207, 'utf8', 'utf8_roman_ci', ''))
227 | _charsets.add(Charset(208, 'utf8', 'utf8_persian_ci', ''))
228 | _charsets.add(Charset(209, 'utf8', 'utf8_esperanto_ci', ''))
229 | _charsets.add(Charset(210, 'utf8', 'utf8_hungarian_ci', ''))
230 | _charsets.add(Charset(211, 'utf8', 'utf8_sinhala_ci', ''))
231 | _charsets.add(Charset(223, 'utf8', 'utf8_general_mysql500_ci', ''))
232 | _charsets.add(Charset(224, 'utf8mb4', 'utf8mb4_unicode_ci', ''))
233 | _charsets.add(Charset(225, 'utf8mb4', 'utf8mb4_icelandic_ci', ''))
234 | _charsets.add(Charset(226, 'utf8mb4', 'utf8mb4_latvian_ci', ''))
235 | _charsets.add(Charset(227, 'utf8mb4', 'utf8mb4_romanian_ci', ''))
236 | _charsets.add(Charset(228, 'utf8mb4', 'utf8mb4_slovenian_ci', ''))
237 | _charsets.add(Charset(229, 'utf8mb4', 'utf8mb4_polish_ci', ''))
238 | _charsets.add(Charset(230, 'utf8mb4', 'utf8mb4_estonian_ci', ''))
239 | _charsets.add(Charset(231, 'utf8mb4', 'utf8mb4_spanish_ci', ''))
240 | _charsets.add(Charset(232, 'utf8mb4', 'utf8mb4_swedish_ci', ''))
241 | _charsets.add(Charset(233, 'utf8mb4', 'utf8mb4_turkish_ci', ''))
242 | _charsets.add(Charset(234, 'utf8mb4', 'utf8mb4_czech_ci', ''))
243 | _charsets.add(Charset(235, 'utf8mb4', 'utf8mb4_danish_ci', ''))
244 | _charsets.add(Charset(236, 'utf8mb4', 'utf8mb4_lithuanian_ci', ''))
245 | _charsets.add(Charset(237, 'utf8mb4', 'utf8mb4_slovak_ci', ''))
246 | _charsets.add(Charset(238, 'utf8mb4', 'utf8mb4_spanish2_ci', ''))
247 | _charsets.add(Charset(239, 'utf8mb4', 'utf8mb4_roman_ci', ''))
248 | _charsets.add(Charset(240, 'utf8mb4', 'utf8mb4_persian_ci', ''))
249 | _charsets.add(Charset(241, 'utf8mb4', 'utf8mb4_esperanto_ci', ''))
250 | _charsets.add(Charset(242, 'utf8mb4', 'utf8mb4_hungarian_ci', ''))
251 | _charsets.add(Charset(243, 'utf8mb4', 'utf8mb4_sinhala_ci', ''))
252 | 
253 | 
254 | charset_by_name = _charsets.by_name
255 | charset_by_id = _charsets.by_id
256 | 
257 | 
258 | def charset_to_encoding(name):
259 |     """Convert MySQL's charset name to Python's codec name"""
260 |     if name == 'utf8mb4':
261 |         return 'utf8'
262 |     return name
263 | 


--------------------------------------------------------------------------------
/asynctorndb/connection.py:
--------------------------------------------------------------------------------
   1 | #!/usr/bin/env python
   2 | #
   3 | # Copyright 2014 Mayflower
   4 | #
   5 | 
   6 | """ async mysql client for tornado
   7 | 
   8 | Base no PyMySQL (https://github.com/PyMySQL/PyMySQL) that's a pure
   9 | python mysql client.
  10 | """
  11 | 
  12 | from __future__ import print_function
  13 | from ._compat import PY2, range_type, text_type, str_type, JYTHON, IRONPYTHON
  14 | 
  15 | from tornado.gen import coroutine, Return
  16 | from tornado.tcpclient import TCPClient
  17 | import tornado.ioloop
  18 | import errno
  19 | from functools import partial
  20 | import os
  21 | import hashlib
  22 | import socket
  23 | import itertools
  24 | import time
  25 | 
  26 | try:
  27 |     import ssl
  28 |     SSL_ENABLED = True
  29 | except ImportError:
  30 |     SSL_ENABLED = False
  31 | 
  32 | import struct
  33 | import sys
  34 | if PY2:
  35 |     import ConfigParser as configparser
  36 | else:
  37 |     import configparser
  38 | 
  39 | import io
  40 | 
  41 | try:
  42 |     import getpass
  43 |     DEFAULT_USER = getpass.getuser()
  44 | except ImportError:
  45 |     DEFAULT_USER = None
  46 | 
  47 | 
  48 | from .charset import MBLENGTH, charset_by_name, charset_by_id
  49 | from .cursors import Cursor
  50 | from .constants import FIELD_TYPE
  51 | from .constants import SERVER_STATUS
  52 | from .constants.CLIENT import *
  53 | from .constants.COMMAND import *
  54 | from .util import byte2int, int2byte
  55 | from .converters import escape_item, encoders, decoders, escape_string
  56 | from .err import (
  57 |     raise_mysql_exception, Warning, Error,
  58 |     InterfaceError, DataError, DatabaseError, OperationalError,
  59 |     IntegrityError, InternalError, NotSupportedError, ProgrammingError)
  60 | 
  61 | _py_version = sys.version_info[:2]
  62 | 
  63 | 
  64 | # socket.makefile() in Python 2 is not usable because very inefficient and
  65 | # bad behavior about timeout.
  66 | # XXX: ._socketio doesn't work under IronPython.
  67 | if _py_version == (2, 7) and not IRONPYTHON:
  68 |     # read method of file-like returned by sock.makefile() is very slow.
  69 |     # So we copy io-based one from Python 3.
  70 |     from _socketio import SocketIO
  71 |     def _makefile(sock, mode):
  72 |         return io.BufferedReader(SocketIO(sock, mode))
  73 | elif _py_version == (2, 6):
  74 |     # Python 2.6 doesn't have fast io module.
  75 |     # So we make original one.
  76 |     class SockFile(object):
  77 |         def __init__(self, sock):
  78 |             self._sock = sock
  79 |         def read(self, n):
  80 |             read = self._sock.recv(n)
  81 |             if len(read) == n:
  82 |                 return read
  83 |             while True:
  84 |                 data = self._sock.recv(n-len(read))
  85 |                 if not data:
  86 |                     return read
  87 |                 read += data
  88 |                 if len(read) == n:
  89 |                     return read
  90 | 
  91 |     def _makefile(sock, mode):
  92 |         assert mode == 'rb'
  93 |         return SockFile(sock)
  94 | else:
  95 |     # socket.makefile in Python 3 is nice.
  96 |     def _makefile(sock, mode):
  97 |         return sock.makefile(mode)
  98 | 
  99 | 
 100 | TEXT_TYPES = set([
 101 |     FIELD_TYPE.BIT,
 102 |     FIELD_TYPE.BLOB,
 103 |     FIELD_TYPE.LONG_BLOB,
 104 |     FIELD_TYPE.MEDIUM_BLOB,
 105 |     FIELD_TYPE.STRING,
 106 |     FIELD_TYPE.TINY_BLOB,
 107 |     FIELD_TYPE.VAR_STRING,
 108 |     FIELD_TYPE.VARCHAR])
 109 | 
 110 | sha_new = partial(hashlib.new, 'sha1')
 111 | 
 112 | DEBUG = False
 113 | 
 114 | NULL_COLUMN = 251
 115 | UNSIGNED_CHAR_COLUMN = 251
 116 | UNSIGNED_SHORT_COLUMN = 252
 117 | UNSIGNED_INT24_COLUMN = 253
 118 | UNSIGNED_INT64_COLUMN = 254
 119 | UNSIGNED_CHAR_LENGTH = 1
 120 | UNSIGNED_SHORT_LENGTH = 2
 121 | UNSIGNED_INT24_LENGTH = 3
 122 | UNSIGNED_INT64_LENGTH = 8
 123 | 
 124 | DEFAULT_CHARSET = 'latin1'
 125 | 
 126 | MAX_PACKET_LEN = 2**24-1
 127 | 
 128 | 
 129 | def dump_packet(data):
 130 | 
 131 |     def is_ascii(data):
 132 |         if 65 <= byte2int(data) <= 122:  #data.isalnum():
 133 |             if isinstance(data, int):
 134 |                 return chr(data)
 135 |             return data
 136 |         return '.'
 137 | 
 138 |     try:
 139 |         print("packet length:", len(data))
 140 |         print("method call[1]:", sys._getframe(1).f_code.co_name)
 141 |         print("method call[2]:", sys._getframe(2).f_code.co_name)
 142 |         print("method call[3]:", sys._getframe(3).f_code.co_name)
 143 |         print("method call[4]:", sys._getframe(4).f_code.co_name)
 144 |         print("method call[5]:", sys._getframe(5).f_code.co_name)
 145 |         print("-" * 88)
 146 |     except ValueError:
 147 |         pass
 148 |     dump_data = [data[i:i+16] for i in range_type(0, min(len(data), 256), 16)]
 149 |     for d in dump_data:
 150 |         print(' '.join(["{:02X}".format(byte2int(x)) for x in d]) +
 151 |               '   ' * (16 - len(d)) + ' ' * 2 +
 152 |               ' '.join(["{}".format(is_ascii(x)) for x in d]))
 153 |     print("-" * 88)
 154 |     print()
 155 | 
 156 | 
 157 | def _scramble(password, message):
 158 |     if not password:
 159 |         return b'\0'
 160 |     if DEBUG: print('password=' + password)
 161 |     stage1 = sha_new(password).digest()
 162 |     stage2 = sha_new(stage1).digest()
 163 |     s = sha_new()
 164 |     s.update(message)
 165 |     s.update(stage2)
 166 |     result = s.digest()
 167 |     return _my_crypt(result, stage1)
 168 | 
 169 | 
 170 | def _my_crypt(message1, message2):
 171 |     length = len(message1)
 172 |     result = struct.pack('B', length)
 173 |     for i in range_type(length):
 174 |         x = (struct.unpack('B', message1[i:i+1])[0] ^
 175 |              struct.unpack('B', message2[i:i+1])[0])
 176 |         result += struct.pack('B', x)
 177 |     return result
 178 | 
 179 | # old_passwords support ported from libmysql/password.c
 180 | SCRAMBLE_LENGTH_323 = 8
 181 | 
 182 | 
 183 | class RandStruct_323(object):
 184 |     def __init__(self, seed1, seed2):
 185 |         self.max_value = 0x3FFFFFFF
 186 |         self.seed1 = seed1 % self.max_value
 187 |         self.seed2 = seed2 % self.max_value
 188 | 
 189 |     def my_rnd(self):
 190 |         self.seed1 = (self.seed1 * 3 + self.seed2) % self.max_value
 191 |         self.seed2 = (self.seed1 + self.seed2 + 33) % self.max_value
 192 |         return float(self.seed1) / float(self.max_value)
 193 | 
 194 | 
 195 | def _scramble_323(password, message):
 196 |     hash_pass = _hash_password_323(password)
 197 |     hash_message = _hash_password_323(message[:SCRAMBLE_LENGTH_323])
 198 |     hash_pass_n = struct.unpack(">LL", hash_pass)
 199 |     hash_message_n = struct.unpack(">LL", hash_message)
 200 | 
 201 |     rand_st = RandStruct_323(hash_pass_n[0] ^ hash_message_n[0],
 202 |                              hash_pass_n[1] ^ hash_message_n[1])
 203 |     outbuf = io.BytesIO()
 204 |     for _ in range_type(min(SCRAMBLE_LENGTH_323, len(message))):
 205 |         outbuf.write(int2byte(int(rand_st.my_rnd() * 31) + 64))
 206 |     extra = int2byte(int(rand_st.my_rnd() * 31))
 207 |     out = outbuf.getvalue()
 208 |     outbuf = io.BytesIO()
 209 |     for c in out:
 210 |         outbuf.write(int2byte(byte2int(c) ^ byte2int(extra)))
 211 |     return outbuf.getvalue()
 212 | 
 213 | 
 214 | def _hash_password_323(password):
 215 |     nr = 1345345333
 216 |     add = 7
 217 |     nr2 = 0x12345671
 218 | 
 219 |     for c in [byte2int(x) for x in password if x not in (' ', '\t')]:
 220 |         nr^= (((nr & 63)+add)*c)+ (nr << 8) & 0xFFFFFFFF
 221 |         nr2= (nr2 + ((nr2 << 8) ^ nr)) & 0xFFFFFFFF
 222 |         add= (add + c) & 0xFFFFFFFF
 223 | 
 224 |     r1 = nr & ((1 << 31) - 1) # kill sign bits
 225 |     r2 = nr2 & ((1 << 31) - 1)
 226 | 
 227 |     # pack
 228 |     return struct.pack(">LL", r1, r2)
 229 | 
 230 | 
 231 | def pack_int24(n):
 232 |     return struct.pack('<I', n)[:3]
 233 | 
 234 | def unpack_uint16(n):
 235 |     return struct.unpack('<H', n[0:2])[0]
 236 | 
 237 | def unpack_int24(n):
 238 |     return struct.unpack('<I', n + b'\0')[0]
 239 | 
 240 | def unpack_int32(n):
 241 |     return struct.unpack('<I', n)[0]
 242 | 
 243 | def unpack_int64(n):
 244 |     return struct.unpack('<Q', n)[0]
 245 | 
 246 | 
 247 | class MysqlPacket(object):
 248 |     """Representation of a MySQL response packet.  Reads in the packet
 249 |     from the network socket, removes packet header and provides an interface
 250 |     for reading/parsing the packet results."""
 251 |     __slots__ = ('_position', '_data', '_packet_number', 'connection')
 252 | 
 253 |     def __init__(self, connection):
 254 |         self._position = 0
 255 |         self.connection = connection
 256 | 
 257 |     def set_data(self, data):
 258 |         self._data = data
 259 | 
 260 |     @coroutine
 261 |     def recv_packet(self):
 262 |         """Parse the packet header and read entire packet payload into buffer."""
 263 |         buff = b''
 264 |         while True:
 265 |             packet_header = yield self.connection.stream.read_bytes(4)
 266 |             if DEBUG: dump_packet(packet_header)
 267 |             packet_length_bin = packet_header[:3]
 268 | 
 269 |             #TODO: check sequence id
 270 |             self._packet_number = byte2int(packet_header[3])
 271 | 
 272 |             bin_length = packet_length_bin + b'\0'  # pad little-endian number
 273 |             bytes_to_read = struct.unpack('<I', bin_length)[0]
 274 |             recv_data = yield self.connection.stream.read_bytes(bytes_to_read)
 275 |             if DEBUG: dump_packet(recv_data)
 276 |             buff += recv_data
 277 |             if bytes_to_read < MAX_PACKET_LEN:
 278 |                 break
 279 |         self._data = buff
 280 | 
 281 |     def packet_number(self):
 282 |         return self._packet_number
 283 | 
 284 |     def get_all_data(self):
 285 |         return self._data
 286 | 
 287 |     def read(self, size):
 288 |         """Read the first 'size' bytes in packet and advance cursor past them."""
 289 |         result = self._data[self._position:(self._position+size)]
 290 |         if len(result) != size:
 291 |             error = ('Result length not requested length:\n'
 292 |                      'Expected=%s.  Actual=%s.  Position: %s.  Data Length: %s'
 293 |                      % (size, len(result), self._position, len(self._data)))
 294 |             if DEBUG:
 295 |                 print(error)
 296 |                 self.dump()
 297 |             raise AssertionError(error)
 298 |         self._position += size
 299 |         return result
 300 | 
 301 |     def read_all(self):
 302 |         """Read all remaining data in the packet.
 303 | 
 304 |         (Subsequent read() will return errors.)
 305 |         """
 306 |         result = self._data[self._position:]
 307 |         self._position = None  # ensure no subsequent read()
 308 |         return result
 309 | 
 310 |     def advance(self, length):
 311 |         """Advance the cursor in data buffer 'length' bytes."""
 312 |         new_position = self._position + length
 313 |         if new_position < 0 or new_position > len(self._data):
 314 |             raise Exception('Invalid advance amount (%s) for cursor.  '
 315 |                             'Position=%s' % (length, new_position))
 316 |         self._position = new_position
 317 | 
 318 |     def rewind(self, position=0):
 319 |         """Set the position of the data buffer cursor to 'position'."""
 320 |         if position < 0 or position > len(self._data):
 321 |             raise Exception("Invalid position to rewind cursor to: %s." % position)
 322 |         self._position = position
 323 | 
 324 |     def get_bytes(self, position, length=1):
 325 |         """Get 'length' bytes starting at 'position'.
 326 | 
 327 |         Position is start of payload (first four packet header bytes are not
 328 |         included) starting at index '0'.
 329 | 
 330 |         No error checking is done.  If requesting outside end of buffer
 331 |         an empty string (or string shorter than 'length') may be returned!
 332 |         """
 333 |         return self._data[position:(position+length)]
 334 | 
 335 |     def read_length_encoded_integer(self):
 336 |         """Read a 'Length Coded Binary' number from the data buffer.
 337 | 
 338 |         Length coded numbers can be anywhere from 1 to 9 bytes depending
 339 |         on the value of the first byte.
 340 |         """
 341 |         c = ord(self.read(1))
 342 |         if c == NULL_COLUMN:
 343 |             return None
 344 |         if c < UNSIGNED_CHAR_COLUMN:
 345 |             return c
 346 |         elif c == UNSIGNED_SHORT_COLUMN:
 347 |             return unpack_uint16(self.read(UNSIGNED_SHORT_LENGTH))
 348 |         elif c == UNSIGNED_INT24_COLUMN:
 349 |             return unpack_int24(self.read(UNSIGNED_INT24_LENGTH))
 350 |         elif c == UNSIGNED_INT64_COLUMN:
 351 |             return unpack_int64(self.read(UNSIGNED_INT64_LENGTH))
 352 | 
 353 |     def read_length_coded_string(self):
 354 |         """Read a 'Length Coded String' from the data buffer.
 355 | 
 356 |         A 'Length Coded String' consists first of a length coded
 357 |         (unsigned, positive) integer represented in 1-9 bytes followed by
 358 |         that many bytes of binary data.  (For example "cat" would be "3cat".)
 359 |         """
 360 |         length = self.read_length_encoded_integer()
 361 |         if length is None:
 362 |             return None
 363 |         return self.read(length)
 364 | 
 365 |     def is_ok_packet(self):
 366 |         return self._data[0:1] == b'\0'
 367 | 
 368 |     def is_eof_packet(self):
 369 |         # http://dev.mysql.com/doc/internals/en/generic-response-packets.html#packet-EOF_Packet
 370 |         # Caution: \xFE may be LengthEncodedInteger.
 371 |         # If \xFE is LengthEncodedInteger header, 8bytes followed.
 372 |         return len(self._data) < 9 and self._data[0:1] == b'\xfe'
 373 | 
 374 |     def is_resultset_packet(self):
 375 |         field_count = ord(self._data[0:1])
 376 |         return 1 <= field_count <= 250
 377 | 
 378 |     def is_error_packet(self):
 379 |         return self._data[0:1] == b'\xff'
 380 | 
 381 |     def check_error(self):
 382 |         if self.is_error_packet():
 383 |             self.rewind()
 384 |             self.advance(1)  # field_count == error (we already know that)
 385 |             errno = unpack_uint16(self.read(2))
 386 |             if DEBUG: print("errno =", errno)
 387 |             raise_mysql_exception(self._data)
 388 | 
 389 |     def dump(self):
 390 |         dump_packet(self._data)
 391 | 
 392 | 
 393 | class FieldDescriptorPacket(MysqlPacket):
 394 |     """A MysqlPacket that represents a specific column's metadata in the result.
 395 | 
 396 |     Parsing is automatically done and the results are exported via public
 397 |     attributes on the class such as: db, table_name, name, length, type_code.
 398 |     """
 399 | 
 400 |     def __init__(self, connection):
 401 |         MysqlPacket.__init__(self, connection)
 402 | 
 403 |     @coroutine
 404 |     def recv_packet(self):
 405 |         yield super(FieldDescriptorPacket, self).recv_packet()
 406 |         self.__parse_field_descriptor(self.connection.encoding)
 407 | 
 408 |     def __parse_field_descriptor(self, encoding):
 409 |         """Parse the 'Field Descriptor' (Metadata) packet.
 410 | 
 411 |         This is compatible with MySQL 4.1+ (not compatible with MySQL 4.0).
 412 |         """
 413 |         self.catalog = self.read_length_coded_string()
 414 |         self.db = self.read_length_coded_string()
 415 |         self.table_name = self.read_length_coded_string().decode(encoding)
 416 |         self.org_table = self.read_length_coded_string().decode(encoding)
 417 |         self.name = self.read_length_coded_string().decode(encoding)
 418 |         self.org_name = self.read_length_coded_string().decode(encoding)
 419 |         self.advance(1)  # non-null filler
 420 |         self.charsetnr = struct.unpack('<H', self.read(2))[0]
 421 |         self.length = struct.unpack('<I', self.read(4))[0]
 422 |         self.type_code = byte2int(self.read(1))
 423 |         self.flags = struct.unpack('<H', self.read(2))[0]
 424 |         self.scale = byte2int(self.read(1))  # "decimals"
 425 |         self.advance(2)  # filler (always 0x00)
 426 | 
 427 |         # 'default' is a length coded binary and is still in the buffer?
 428 |         # not used for normal result sets...
 429 | 
 430 |     def description(self):
 431 |         """Provides a 7-item tuple compatible with the Python PEP249 DB Spec."""
 432 |         desc = []
 433 |         desc.append(self.name)
 434 |         desc.append(self.type_code)
 435 |         desc.append(None) # TODO: display_length; should this be self.length?
 436 |         desc.append(self.get_column_length()) # 'internal_size'
 437 |         desc.append(self.get_column_length()) # 'precision'  # TODO: why!?!?
 438 |         desc.append(self.scale)
 439 | 
 440 |         # 'null_ok' -- can this be True/False rather than 1/0?
 441 |         #              if so just do:  desc.append(bool(self.flags % 2 == 0))
 442 |         if self.flags % 2 == 0:
 443 |             desc.append(1)
 444 |         else:
 445 |             desc.append(0)
 446 |         return tuple(desc)
 447 | 
 448 |     def get_column_length(self):
 449 |         if self.type_code == FIELD_TYPE.VAR_STRING:
 450 |             mblen = MBLENGTH.get(self.charsetnr, 1)
 451 |             return self.length // mblen
 452 |         return self.length
 453 | 
 454 |     def __str__(self):
 455 |         return ('%s %r.%r.%r, type=%s, flags=%x'
 456 |                 % (self.__class__, self.db, self.table_name, self.name,
 457 |                    self.type_code, self.flags))
 458 | 
 459 | 
 460 | class OKPacketWrapper(object):
 461 |     """
 462 |     OK Packet Wrapper. It uses an existing packet object, and wraps
 463 |     around it, exposing useful variables while still providing access
 464 |     to the original packet objects variables and methods.
 465 |     """
 466 | 
 467 |     def __init__(self, from_packet):
 468 |         if not from_packet.is_ok_packet():
 469 |             raise ValueError('Cannot create ' + str(self.__class__.__name__) +
 470 |                              ' object from invalid packet type')
 471 | 
 472 |         self.packet = from_packet
 473 |         self.packet.advance(1)
 474 | 
 475 |         self.affected_rows = self.packet.read_length_encoded_integer()
 476 |         self.insert_id = self.packet.read_length_encoded_integer()
 477 |         self.server_status = struct.unpack('<H', self.packet.read(2))[0]
 478 |         self.warning_count = struct.unpack('<H', self.packet.read(2))[0]
 479 |         self.message = self.packet.read_all()
 480 |         self.has_next = self.server_status & SERVER_STATUS.SERVER_MORE_RESULTS_EXISTS
 481 | 
 482 |     def __getattr__(self, key):
 483 |         return getattr(self.packet, key)
 484 | 
 485 | 
 486 | class EOFPacketWrapper(object):
 487 |     """
 488 |     EOF Packet Wrapper. It uses an existing packet object, and wraps
 489 |     around it, exposing useful variables while still providing access
 490 |     to the original packet objects variables and methods.
 491 |     """
 492 | 
 493 |     def __init__(self, from_packet):
 494 |         if not from_packet.is_eof_packet():
 495 |             raise ValueError(
 496 |                 "Cannot create '{0}' object from invalid packet type".format(
 497 |                     self.__class__))
 498 | 
 499 |         self.packet = from_packet
 500 |         from_packet.advance(1)
 501 |         self.warning_count = struct.unpack('<h', from_packet.read(2))[0]
 502 |         self.server_status = struct.unpack('<h', self.packet.read(2))[0]
 503 |         if DEBUG: print("server_status=", self.server_status)
 504 |         self.has_next = self.server_status & SERVER_STATUS.SERVER_MORE_RESULTS_EXISTS
 505 | 
 506 |     def __getattr__(self, key):
 507 |         return getattr(self.packet, key)
 508 | 
 509 |     
 510 | class Connection(object):
 511 |     """
 512 |     Representation of a socket with a mysql server.
 513 | 
 514 |     The proper way to get an instance of this class is to call
 515 |     connect().
 516 | 
 517 |     """
 518 | 
 519 |     socket = None
 520 | 
 521 |     def __init__(self, host="localhost", user=None, passwd="",
 522 |                  database=None, port=3306, unix_socket=None,
 523 |                  charset='', sql_mode=None,
 524 |                  read_default_file=None, conv=decoders, use_unicode=None,
 525 |                  client_flag=0, cursorclass=Cursor, init_command=None,
 526 |                  connect_timeout=None, ssl=None, read_default_group=None,
 527 |                  compress=None, named_pipe=None, no_delay=False,
 528 |                  autocommit=False, db=None, io_loop=None):
 529 |         """
 530 |         Establish a connection to the MySQL database. Accepts several
 531 |         arguments:
 532 | 
 533 |         host: Host where the database server is located
 534 |         user: Username to log in as
 535 |         passwd: Password to use.
 536 |         database: Database to use, None to not use a particular one.
 537 |         port: MySQL port to use, default is usually OK.
 538 |         unix_socket: Optionally, you can use a unix socket rather than TCP/IP.
 539 |         charset: Charset you want to use.
 540 |         sql_mode: Default SQL_MODE to use.
 541 |         read_default_file: Specifies  my.cnf file to read these parameters from under the [client] section.
 542 |         conv: Decoders dictionary to use instead of the default one. This is used to provide custom marshalling of types. See converters.
 543 |         use_unicode: Whether or not to default to unicode strings. This option defaults to true for Py3k.
 544 |         client_flag: Custom flags to send to MySQL. Find potential values in constants.CLIENT.
 545 |         cursorclass: Custom cursor class to use.
 546 |         init_command: Initial SQL statement to run when connection is established.
 547 |         connect_timeout: Timeout before throwing an exception when connecting.
 548 |         ssl: A dict of arguments similar to mysql_ssl_set()'s parameters. For now the capath and cipher arguments are not supported.
 549 |         read_default_group: Group to read from in the configuration file.
 550 |         compress; Not supported
 551 |         named_pipe: Not supported
 552 |         no_delay: Disable Nagle's algorithm on the socket
 553 |         autocommit: Autocommit mode. None means use server default. (default: False)
 554 |         db: Alias for database. (for compatibility to MySQLdb)
 555 |         """
 556 | 
 557 |         if use_unicode is None and sys.version_info[0] > 2:
 558 |             use_unicode = True
 559 | 
 560 |         if db is not None and database is None:
 561 |             database = db
 562 | 
 563 |         if compress or named_pipe:
 564 |             raise NotImplementedError("compress and named_pipe arguments are not supported")
 565 | 
 566 |         if ssl and ('capath' in ssl or 'cipher' in ssl):
 567 |             raise NotImplementedError('ssl options capath and cipher are not supported')
 568 | 
 569 |         self.ssl = False
 570 |         if ssl:
 571 |             if not SSL_ENABLED:
 572 |                 raise NotImplementedError("ssl module not found")
 573 |             self.ssl = True
 574 |             client_flag |= SSL
 575 |             for k in ('key', 'cert', 'ca'):
 576 |                 v = None
 577 |                 if k in ssl:
 578 |                     v = ssl[k]
 579 |                 setattr(self, k, v)
 580 | 
 581 |         if read_default_group and not read_default_file:
 582 |             if sys.platform.startswith("win"):
 583 |                 read_default_file = "c:\\my.ini"
 584 |             else:
 585 |                 read_default_file = "/etc/my.cnf"
 586 | 
 587 |         if read_default_file:
 588 |             if not read_default_group:
 589 |                 read_default_group = "client"
 590 | 
 591 |             cfg = configparser.RawConfigParser()
 592 |             cfg.read(os.path.expanduser(read_default_file))
 593 | 
 594 |             def _config(key, default):
 595 |                 try:
 596 |                     return cfg.get(read_default_group, key)
 597 |                 except Exception:
 598 |                     return default
 599 | 
 600 |             user = _config("user", user)
 601 |             passwd = _config("password", passwd)
 602 |             host = _config("host", host)
 603 |             database = _config("database", database)
 604 |             unix_socket = _config("socket", unix_socket)
 605 |             port = int(_config("port", port))
 606 |             charset = _config("default-character-set", charset)
 607 | 
 608 |         self.host = host
 609 |         self.port = port
 610 |         self.user = user or DEFAULT_USER
 611 |         self.password = passwd or ""
 612 |         self.db = database
 613 |         self.no_delay = no_delay
 614 |         self.unix_socket = unix_socket
 615 |         if charset:
 616 |             self.charset = charset
 617 |             self.use_unicode = True
 618 |         else:
 619 |             self.charset = DEFAULT_CHARSET
 620 |             self.use_unicode = False
 621 | 
 622 |         if use_unicode is not None:
 623 |             self.use_unicode = use_unicode
 624 | 
 625 |         self.encoding = charset_by_name(self.charset).encoding
 626 | 
 627 |         client_flag |= CAPABILITIES
 628 |         client_flag |= MULTI_STATEMENTS
 629 |         if self.db:
 630 |             client_flag |= CONNECT_WITH_DB
 631 |         self.client_flag = client_flag
 632 | 
 633 |         self.cursorclass = cursorclass
 634 |         self.connect_timeout = connect_timeout
 635 | 
 636 |         self._result = None
 637 |         self._affected_rows = 0
 638 |         self.host_info = "Not connected"
 639 | 
 640 |         #: specified autocommit mode. None means use server default.
 641 |         self.autocommit_mode = autocommit
 642 | 
 643 |         self.encoders = encoders  # Need for MySQLdb compatibility.
 644 |         self.decoders = conv
 645 |         self.sql_mode = sql_mode
 646 |         self.init_command = init_command
 647 |         self.io_loop = io_loop or tornado.ioloop.IOLoop.current()
 648 |         self.stream = None
 649 | 
 650 |     @coroutine
 651 |     def close(self):
 652 |         ''' Send the quit message and close the socket '''
 653 |         if self.stream.closed():
 654 |             raise Error("Already closed")
 655 |         send_data = struct.pack('<i', 1) + int2byte(COM_QUIT)
 656 |         try:
 657 |             yield self.stream.write(send_data)
 658 |         except Exception:
 659 |             pass
 660 |         finally:
 661 |             self.stream.close()
 662 |             self.stream = None
 663 | 
 664 |     def __del__(self):
 665 |         if self.stream:
 666 |             self.stream.close()
 667 | 
 668 |     def autocommit(self, value):
 669 |         self.autocommit_mode = bool(value)
 670 |         current = self.get_autocommit()
 671 |         if value != current:
 672 |             self._send_autocommit_mode()
 673 | 
 674 |     def get_autocommit(self):
 675 |         return bool(self.server_status &
 676 |                     SERVER_STATUS.SERVER_STATUS_AUTOCOMMIT)
 677 | 
 678 |     @coroutine
 679 |     def _read_ok_packet(self):
 680 |         pkt = yield self._read_packet()
 681 |         if not pkt.is_ok_packet():
 682 |             raise OperationalError(2014, "Command Out of Sync")
 683 |         ok = OKPacketWrapper(pkt)
 684 |         self.server_status = ok.server_status
 685 |         raise Return(True)
 686 | 
 687 |     @coroutine
 688 |     def _send_autocommit_mode(self):
 689 |         ''' Set whether or not to commit after every execute() '''
 690 |         self._execute_command(COM_QUERY, "SET AUTOCOMMIT = %s" %
 691 |                               self.escape(self.autocommit_mode))
 692 |         yield self._read_ok_packet()
 693 | 
 694 |     @coroutine
 695 |     def commit(self):
 696 |         ''' Commit changes to stable storage '''
 697 |         self._execute_command(COM_QUERY, "COMMIT")
 698 |         yield self._read_ok_packet()
 699 | 
 700 |     @coroutine
 701 |     def rollback(self):
 702 |         ''' Roll back the current transaction '''
 703 |         yield self._execute_command(COM_QUERY, "ROLLBACK")
 704 |         yield self._read_ok_packet()
 705 | 
 706 |     @coroutine
 707 |     def select_db(self, db):
 708 |         '''Set current db'''
 709 |         yield self._execute_command(COM_INIT_DB, db)
 710 |         yield self._read_ok_packet()
 711 | 
 712 |     def escape(self, obj):
 713 |         ''' Escape whatever value you pass to it  '''
 714 |         if isinstance(obj, str_type):
 715 |             return "'" + self.escape_string(obj) + "'"
 716 |         return escape_item(obj, self.charset)
 717 | 
 718 |     def literal(self, obj):
 719 |         '''Alias for escape()'''
 720 |         return self.escape(obj)
 721 | 
 722 |     def escape_string(self, s):
 723 |         if (self.server_status &
 724 |                 SERVER_STATUS.SERVER_STATUS_NO_BACKSLASH_ESCAPES):
 725 |             return s.replace("'", "''")
 726 |         return escape_string(s)
 727 | 
 728 |     def cursor(self, cursor=None):
 729 |         ''' Create a new cursor to execute queries with '''
 730 |         if cursor:
 731 |             return cursor(self)
 732 |         return self.cursorclass(self)
 733 | 
 734 |     def __enter__(self):
 735 |         ''' Context manager that returns a Cursor '''
 736 |         return self.cursor()
 737 | 
 738 |     @coroutine
 739 |     def __exit__(self, exc, value, traceback):
 740 |         ''' On successful exit, commit. On exception, rollback. '''
 741 |         if exc:
 742 |             yield self.rollback()
 743 |         else:
 744 |             yield self.commit()
 745 | 
 746 |     @coroutine
 747 |     def query(self, sql, *args):
 748 |         """Returns a row list for the given query and parameters."""
 749 |         cur = self.cursor()
 750 |         try:
 751 |             yield cur.execute(sql, *args)
 752 |             column_names = [d[0] for d in cur.description]
 753 |             raise Return([Row(zip(column_names, row)) for row in cur])
 754 |         finally:
 755 |             cur.close()
 756 | 
 757 |     @coroutine
 758 |     def get(self, sql, *args):
 759 |         """Returns the (singular) row returned by the given query.
 760 |     
 761 |         If the query has no results, returns None.  If it has
 762 |         more than one result, raises an exception.
 763 |         """
 764 |         rows = yield self.query(sql, *args)
 765 |         if not rows:
 766 |             raise Return(None)
 767 |         elif len(rows) > 1:
 768 |             raise Exception("Multiple rows returned for Database.get() query")
 769 |         else:
 770 |             raise Return(rows[0])
 771 | 
 772 |     @coroutine
 773 |     def execute(self, sql, *args):
 774 |         """Executes the given query, returning the lastrowid from the query."""
 775 |         raise Return((yield self.execute_lastrowid(sql, *args)))
 776 | 
 777 |     @coroutine
 778 |     def execute_lastrowid(self, sql, *args):
 779 |         """Executes the given query, returning the lastrowid from the query."""
 780 |         cur = self.cursor()
 781 |         try:
 782 |             yield self._execute(cur, sql, *args)
 783 |             raise Return(cur.lastrowid)
 784 |         finally:
 785 |             cur.close()
 786 | 
 787 |     @coroutine
 788 |     def execute_rowcount(self, sql, *args):
 789 |         """Executes the given query, returning the rowcount from the query."""
 790 |         cur = self.cursor()
 791 |         try:
 792 |             yield self._execute(cur, sql, *args)
 793 |             raise Return(cur.rowcount)
 794 |         finally:
 795 |             cur.close()
 796 | 
 797 |     @coroutine
 798 |     def executemany(self, sql, args):
 799 |         """Executes the given query against all the given param sequences.
 800 | 
 801 |         We return the lastrowid from the query.
 802 |         """
 803 |         raise Return((yield self.executemany_lastrowid(sql, args)))
 804 |             
 805 |     @coroutine
 806 |     def executemany_lastrowid(self, sql, args):
 807 |         """Executes the given query against all the given param sequences.
 808 | 
 809 |         We return the lastrowid from the query.
 810 |         """
 811 |         cur = self.cursor()
 812 |         try:
 813 |             yield cur.executemany(sql, args)
 814 |             raise Return(cur.lastrowid)
 815 |         finally:
 816 |             cur.close()
 817 | 
 818 |     @coroutine
 819 |     def executemany_rowcount(self, sql, args):
 820 |         """Executes the given query against all the given param sequences.
 821 | 
 822 |         We return the rowcount from the query.
 823 |         """
 824 |         cur = self.cursor()
 825 |         try:
 826 |             yield cur.executemany(sql, args)
 827 |             raise Return(cur.rowcount)
 828 |         finally:
 829 |             cur.close()
 830 |     
 831 |     update = execute_rowcount
 832 |     updatemany = executemany_rowcount
 833 |     
 834 |     insert = execute_lastrowid
 835 |     insertmany = executemany_lastrowid
 836 |     
 837 |     @coroutine
 838 |     def _execute(self, cur, sql, *args):
 839 |         try:
 840 |             yield cur.execute(sql, *args)
 841 |         finally:
 842 |             cur.close()
 843 |         
 844 |     # The following methods are INTERNAL USE ONLY (called from Cursor)
 845 |     @coroutine
 846 |     def execute_query(self, sql, unbuffered=False):
 847 |         #if DEBUG:
 848 |         #    print("DEBUG: sending query:", sql)
 849 |         if isinstance(sql, text_type) and not (JYTHON or IRONPYTHON):
 850 |             sql = sql.encode(self.encoding)
 851 |         yield self._execute_command(COM_QUERY, sql)
 852 |         self._affected_rows = yield self._read_query_result(unbuffered=unbuffered)
 853 |         # return self._affected_rows
 854 | 
 855 |     def next_result(self):
 856 |         self._affected_rows = self._read_query_result()
 857 |         return self._affected_rows
 858 | 
 859 |     def affected_rows(self):
 860 |         return self._affected_rows
 861 | 
 862 |     def kill(self, thread_id):
 863 |         arg = struct.pack('<I', thread_id)
 864 |         self._execute_command(COM_PROCESS_KILL, arg)
 865 |         return self._read_ok_packet()
 866 | 
 867 |     def ping(self, reconnect=True):
 868 |         ''' Check if the server is alive '''
 869 |         if self.socket is None:
 870 |             if reconnect:
 871 |                 self._connect()
 872 |                 reconnect = False
 873 |             else:
 874 |                 raise Error("Already closed")
 875 |         try:
 876 |             self._execute_command(COM_PING, "")
 877 |             return self._read_ok_packet()
 878 |         except Exception:
 879 |             if reconnect:
 880 |                 self._connect()
 881 |                 return self.ping(False)
 882 |             else:
 883 |                 raise
 884 | 
 885 |     @coroutine
 886 |     def set_charset(self, charset):
 887 |         # Make sure charset is supported.
 888 |         encoding = charset_by_name(charset).encoding
 889 | 
 890 |         self._execute_command(COM_QUERY, "SET NAMES %s" % self.escape(charset))
 891 |         yield self._read_packet()
 892 |         self.charset = charset
 893 |         self.encoding = encoding
 894 |         
 895 |     @coroutine
 896 |     def connect(self):
 897 |         client = TCPClient(io_loop=self.io_loop)
 898 |         self.stream = yield client.connect(self.host, self.port)
 899 |         # sock = None
 900 |         # try:
 901 |         #     if self.unix_socket and self.host in ('localhost', '127.0.0.1'):
 902 |         #         sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
 903 |         #         t = sock.gettimeout()
 904 |         #         sock.settimeout(self.connect_timeout)
 905 |         #         sock.connect(self.unix_socket)
 906 |         #         sock.settimeout(t)
 907 |         #         self.host_info = "Localhost via UNIX socket"
 908 |         #         if DEBUG: print('connected using unix_socket')
 909 |         #     else:
 910 |         #         while True:
 911 |         #             try:
 912 |         #                 sock = socket.create_connection(
 913 |         #                         (self.host, self.port), self.connect_timeout)
 914 |         #                 break
 915 |         #             except (OSError, IOError) as e:
 916 |         #                 if e.errno == errno.EINTR:
 917 |         #                     continue
 918 |         #                 raise
 919 |         #         self.host_info = "socket %s:%d" % (self.host, self.port)
 920 |         #         if DEBUG: print('connected using socket')
 921 |         #     sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
 922 |         #     if self.no_delay:
 923 |         #         sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
 924 |         #     self.socket = sock
 925 |         #     self._rfile = _makefile(sock, 'rb')
 926 |         yield self._get_server_information()
 927 |         yield self._request_authentication()
 928 | 
 929 |             # if self.sql_mode is not None:
 930 |             #     c = self.cursor()
 931 |             #     c.execute("SET sql_mode=%s", (self.sql_mode,))
 932 | 
 933 |             # if self.init_command is not None:
 934 |             #     c = self.cursor()
 935 |             #     c.execute(self.init_command)
 936 |             #     self.commit()
 937 | 
 938 |             # if self.autocommit_mode is not None:
 939 |             #     self.autocommit(self.autocommit_mode)
 940 |         # except Exception as e:
 941 |         #     self._rfile = None
 942 |         #     if sock is not None:
 943 |         #         try:
 944 |         #             sock.close()
 945 |         #         except socket.error:
 946 |         #             pass
 947 |         #     raise OperationalError(
 948 |         #         2003, "Can't connect to MySQL server on %r (%s)" % (self.host, e))
 949 | 
 950 |     reconnect = connect
 951 |         
 952 |     @coroutine
 953 |     def _read_packet(self, packet_type=MysqlPacket):
 954 |         """Read an entire "mysql packet" in its entirety from the network
 955 |         and return a MysqlPacket type that represents the results.
 956 |         """
 957 |         packet = packet_type(self)
 958 |         yield packet.recv_packet()
 959 |         packet.check_error()
 960 |         raise Return(packet)
 961 | 
 962 |     def _read_bytes(self, num_bytes):
 963 |         while True:
 964 |             try:
 965 |                 data = self._rfile.read(num_bytes)
 966 |                 break
 967 |             except (IOError, OSError) as e:
 968 |                 if e.errno == errno.EINTR:
 969 |                     continue
 970 |                 raise OperationalError(
 971 |                         2013, "Lost connection to MySQL server during query (%r)" % (e,))
 972 |         if len(data) < num_bytes:
 973 |             raise OperationalError(2013,
 974 |                     "Lost connection to MySQL server during query")
 975 |         return data
 976 | 
 977 |     def _write_bytes(self, data):
 978 |         try:
 979 |             self.stream.write(data)
 980 |         except IOError as e:
 981 |             raise OperationalError(2006, "MySQL server has gone away (%r)" % (e,))
 982 | 
 983 |     @coroutine
 984 |     def _read_query_result(self, unbuffered=False):
 985 |         if unbuffered:
 986 |             try:
 987 |                 result = MySQLResult(self)
 988 |                 yield result.init_unbuffered_query()
 989 |             except:
 990 |                 result.unbuffered_active = False
 991 |                 result.connection = None
 992 |                 raise
 993 |         else:
 994 |             result = MySQLResult(self)
 995 |             yield result.read()
 996 |         self._result = result
 997 |         if result.server_status is not None:
 998 |             self.server_status = result.server_status
 999 |         raise Return(result.affected_rows)
1000 | 
1001 |     def insert_id(self):
1002 |         if self._result:
1003 |             return self._result.insert_id
1004 |         else:
1005 |             return 0
1006 | 
1007 |     @coroutine
1008 |     def _execute_command(self, command, sql):
1009 |         # if not self.socket:
1010 |         #     raise InterfaceError("(0, '')")
1011 | 
1012 |         # If the last query was unbuffered, make sure it finishes before
1013 |         # sending new commands
1014 |         if self._result is not None and self._result.unbuffered_active:
1015 |             self._result._finish_unbuffered_query()
1016 | 
1017 |         if isinstance(sql, text_type):
1018 |             sql = sql.encode(self.encoding)
1019 | 
1020 |         chunk_size = min(MAX_PACKET_LEN, len(sql) + 1)  # +1 is for command
1021 | 
1022 |         prelude = struct.pack('<i', chunk_size) + int2byte(command)
1023 |         yield self.stream.write(prelude + sql[:chunk_size-1])
1024 |         if DEBUG: dump_packet(prelude + sql)
1025 | 
1026 |         if chunk_size < MAX_PACKET_LEN:
1027 |             raise Return()
1028 | 
1029 |         seq_id = 1
1030 |         sql = sql[chunk_size-1:]
1031 |         while True:
1032 |             chunk_size = min(MAX_PACKET_LEN, len(sql))
1033 |             prelude = struct.pack('<i', chunk_size)[:3]
1034 |             data = prelude + int2byte(seq_id%256) + sql[:chunk_size]
1035 |             yield self.stream.write(data)
1036 |             if DEBUG: dump_packet(data)
1037 |             sql = sql[chunk_size:]
1038 |             if not sql and chunk_size < MAX_PACKET_LEN:
1039 |                 break
1040 |             seq_id += 1
1041 | 
1042 |     @coroutine
1043 |     def _request_authentication(self):
1044 |         self.client_flag |= CAPABILITIES
1045 |         if self.server_version.startswith('5'):
1046 |             self.client_flag |= MULTI_RESULTS
1047 | 
1048 |         if self.user is None:
1049 |             raise ValueError("Did not specify a username")
1050 | 
1051 |         charset_id = charset_by_name(self.charset).id
1052 |         if isinstance(self.user, text_type):
1053 |             self.user = self.user.encode(self.encoding)
1054 | 
1055 |         data_init = struct.pack('<i', self.client_flag) + struct.pack("<I", 1) + \
1056 |                      int2byte(charset_id) + int2byte(0)*23
1057 | 
1058 |         next_packet = 1
1059 | 
1060 |         if self.ssl:
1061 |             data = pack_int24(len(data_init)) + int2byte(next_packet) + data_init
1062 |             next_packet += 1
1063 | 
1064 |             if DEBUG: dump_packet(data)
1065 | 
1066 |             yield self.stream.write(data)
1067 |             self.socket = ssl.wrap_socket(self.socket, keyfile=self.key,
1068 |                                           certfile=self.cert,
1069 |                                           ssl_version=ssl.PROTOCOL_TLSv1,
1070 |                                           cert_reqs=ssl.CERT_REQUIRED,
1071 |                                           ca_certs=self.ca)
1072 |             self._rfile = _makefile(self.socket, 'rb')
1073 | 
1074 |         data = data_init + self.user + b'\0' + \
1075 |             _scramble(self.password.encode('latin1'), self.salt)
1076 | 
1077 |         if self.db:
1078 |             if isinstance(self.db, text_type):
1079 |                 self.db = self.db.encode(self.encoding)
1080 |             data += self.db + int2byte(0)
1081 | 
1082 |         data = pack_int24(len(data)) + int2byte(next_packet) + data
1083 |         next_packet += 2
1084 | 
1085 |         if DEBUG: dump_packet(data)
1086 | 
1087 |         yield self.stream.write(data)
1088 | 
1089 |         auth_packet = MysqlPacket(self)
1090 |         yield auth_packet.recv_packet()
1091 |         auth_packet.check_error()
1092 |         if DEBUG: auth_packet.dump()
1093 | 
1094 |         # if old_passwords is enabled the packet will be 1 byte long and
1095 |         # have the octet 254
1096 | 
1097 |         if auth_packet.is_eof_packet():
1098 |             # send legacy handshake
1099 |             data = _scramble_323(self.password.encode('latin1'), self.salt) + b'\0'
1100 |             data = pack_int24(len(data)) + int2byte(next_packet) + data
1101 | 
1102 |             self.stream.write(data)
1103 |             auth_packet = MysqlPacket(self)
1104 |             yield auth_packet.recv_packet()
1105 |             auth_packet.check_error()
1106 |             if DEBUG: auth_packet.dump()
1107 | 
1108 |     # _mysql support
1109 |     def thread_id(self):
1110 |         return self.server_thread_id[0]
1111 | 
1112 |     def character_set_name(self):
1113 |         return self.charset
1114 | 
1115 |     def get_host_info(self):
1116 |         return self.host_info
1117 | 
1118 |     def get_proto_info(self):
1119 |         return self.protocol_version
1120 | 
1121 |     @coroutine
1122 |     def _get_server_information(self):
1123 |         i = 0
1124 |         packet = MysqlPacket(self)
1125 |         yield packet.recv_packet()
1126 |         packet.check_error()
1127 |         data = packet.get_all_data()
1128 | 
1129 |         if DEBUG: dump_packet(data)
1130 |         self.protocol_version = byte2int(data[i:i+1])
1131 |         i += 1
1132 | 
1133 |         server_end = data.find(int2byte(0), i)
1134 |         self.server_version = data[i:server_end].decode('latin1')
1135 |         i = server_end + 1
1136 | 
1137 |         self.server_thread_id = struct.unpack('<I', data[i:i+4])
1138 |         i += 4
1139 | 
1140 |         self.salt = data[i:i+8]
1141 |         i += 9  # 8 + 1(filler)
1142 | 
1143 |         self.server_capabilities = struct.unpack('<H', data[i:i+2])[0]
1144 |         i += 2
1145 | 
1146 |         if len(data) >= i + 6:
1147 |             lang, stat, cap_h, salt_len = struct.unpack('<BHHB', data[i:i+6])
1148 |             i += 6
1149 |             self.server_language = lang
1150 |             self.server_charset = charset_by_id(lang).name
1151 | 
1152 |             self.server_status = stat
1153 |             if DEBUG: print("server_status: %x" % stat)
1154 | 
1155 |             self.server_capabilities |= cap_h << 16
1156 |             if DEBUG: print("salt_len:", salt_len)
1157 |             salt_len = max(12, salt_len - 9)
1158 | 
1159 |         # reserved
1160 |         i += 10
1161 | 
1162 |         if len(data) >= i + salt_len:
1163 |             self.salt += data[i:i+salt_len] # salt_len includes auth_plugin_data_part_1 and filler
1164 |         #TODO: AUTH PLUGIN NAME may appeare here.
1165 | 
1166 |     def get_server_info(self):
1167 |         return self.server_version
1168 | 
1169 |     Warning = Warning
1170 |     Error = Error
1171 |     InterfaceError = InterfaceError
1172 |     DatabaseError = DatabaseError
1173 |     DataError = DataError
1174 |     OperationalError = OperationalError
1175 |     IntegrityError = IntegrityError
1176 |     InternalError = InternalError
1177 |     ProgrammingError = ProgrammingError
1178 |     NotSupportedError = NotSupportedError
1179 | 
1180 | 
1181 | # TODO: move OK and EOF packet parsing/logic into a proper subclass
1182 | #       of MysqlPacket like has been done with FieldDescriptorPacket.
1183 | class MySQLResult(object):
1184 | 
1185 |     def __init__(self, connection):
1186 |         self.connection = connection
1187 |         self.affected_rows = None
1188 |         self.insert_id = None
1189 |         self.server_status = None
1190 |         self.warning_count = 0
1191 |         self.message = None
1192 |         self.field_count = 0
1193 |         self.description = None
1194 |         self.rows = None
1195 |         self.has_next = None
1196 |         self.unbuffered_active = False
1197 | 
1198 |     def __del__(self):
1199 |         if self.unbuffered_active:
1200 |             self._finish_unbuffered_query()
1201 | 
1202 |     @coroutine
1203 |     def read(self):
1204 |         try:
1205 |             first_packet = yield self.connection._read_packet()
1206 | 
1207 |             # TODO: use classes for different packet types?
1208 |             if first_packet.is_ok_packet():
1209 |                 self._read_ok_packet(first_packet)
1210 |             else:
1211 |                 yield self._read_result_packet(first_packet)
1212 |         finally:
1213 |             self.connection = False
1214 | 
1215 |     @coroutine
1216 |     def init_unbuffered_query(self):
1217 |         self.unbuffered_active = True
1218 |         first_packet = yield self.connection._read_packet()
1219 | 
1220 |         if first_packet.is_ok_packet():
1221 |             self._read_ok_packet(first_packet)
1222 |             self.unbuffered_active = False
1223 |             self.connection = None
1224 |         else:
1225 |             self.field_count = first_packet.read_length_encoded_integer()
1226 |             yield self._get_descriptions()
1227 | 
1228 |             # Apparently, MySQLdb picks this number because it's the maximum
1229 |             # value of a 64bit unsigned integer. Since we're emulating MySQLdb,
1230 |             # we set it to this instead of None, which would be preferred.
1231 |             self.affected_rows = 18446744073709551615
1232 | 
1233 |     def _read_ok_packet(self, first_packet):
1234 |         ok_packet = OKPacketWrapper(first_packet)
1235 |         self.affected_rows = ok_packet.affected_rows
1236 |         self.insert_id = ok_packet.insert_id
1237 |         self.server_status = ok_packet.server_status
1238 |         self.warning_count = ok_packet.warning_count
1239 |         self.message = ok_packet.message
1240 |         self.has_next = ok_packet.has_next
1241 | 
1242 |     def _check_packet_is_eof(self, packet):
1243 |         if packet.is_eof_packet():
1244 |             eof_packet = EOFPacketWrapper(packet)
1245 |             self.warning_count = eof_packet.warning_count
1246 |             self.has_next = eof_packet.has_next
1247 |             return True
1248 |         return False
1249 | 
1250 |     @coroutine
1251 |     def _read_result_packet(self, first_packet):
1252 |         self.field_count = first_packet.read_length_encoded_integer()
1253 |         yield self._get_descriptions()
1254 |         yield self._read_rowdata_packet()
1255 | 
1256 |     @coroutine
1257 |     def _read_rowdata_packet_unbuffered(self):
1258 |         # Check if in an active query
1259 |         if not self.unbuffered_active:
1260 |             return
1261 | 
1262 |         # EOF
1263 |         packet = yield self.connection._read_packet()
1264 |         if self._check_packet_is_eof(packet):
1265 |             self.unbuffered_active = False
1266 |             self.connection = None
1267 |             self.rows = None
1268 |             raise Return()
1269 | 
1270 |         row = yield self._read_row_from_packet(packet)
1271 |         self.affected_rows = 1
1272 |         self.rows = (row,)  # rows should tuple of row for MySQL-python compatibility.
1273 |         raise Return(row)
1274 | 
1275 |     @coroutine
1276 |     def _finish_unbuffered_query(self):
1277 |         # After much reading on the MySQL protocol, it appears that there is,
1278 |         # in fact, no way to stop MySQL from sending all the data after
1279 |         # executing a query, so we just spin, and wait for an EOF packet.
1280 |         while self.unbuffered_active:
1281 |             packet = yield self.connection._read_packet()
1282 |             if self._check_packet_is_eof(packet):
1283 |                 self.unbuffered_active = False
1284 |                 self.connection = None  # release reference to kill cyclic reference.
1285 | 
1286 |     @coroutine
1287 |     def _read_rowdata_packet(self):
1288 |         """Read a rowdata packet for each data row in the result set."""
1289 |         rows = []
1290 |         while True:
1291 |             packet = MysqlPacket(self.connection)
1292 |             buff = b''
1293 |             while True:
1294 |                 packet_header = yield self.connection.stream.read_bytes(4)
1295 |                 if DEBUG: dump_packet(packet_header)
1296 |                 packet_length_bin = packet_header[:3]
1297 | 
1298 |                 #TODO: check sequence id
1299 |                 self._packet_number = byte2int(packet_header[3])
1300 | 
1301 |                 bin_length = packet_length_bin + b'\0'  # pad little-endian number
1302 |                 bytes_to_read = struct.unpack('<I', bin_length)[0]
1303 |                 recv_data = yield self.connection.stream.read_bytes(bytes_to_read)
1304 |                 if DEBUG: dump_packet(recv_data)
1305 |                 buff += recv_data
1306 |                 if bytes_to_read < MAX_PACKET_LEN:
1307 |                     break
1308 |             packet.set_data(buff)
1309 | 
1310 |             if self._check_packet_is_eof(packet):
1311 |                 self.connection = None  # release reference to kill cyclic reference.
1312 |                 break
1313 |             rows.append(self._read_row_from_packet(packet))
1314 | 
1315 |         self.affected_rows = len(rows)
1316 |         self.rows = tuple(rows)
1317 | 
1318 |     def _read_row_from_packet(self, packet):
1319 |         use_unicode = self.connection.use_unicode
1320 |         row = []
1321 |         for field in self.fields:
1322 |             data = packet.read_length_coded_string()
1323 |             if data is not None:
1324 |                 field_type = field.type_code
1325 |                 if use_unicode:
1326 |                     if field_type in TEXT_TYPES:
1327 |                         charset = charset_by_id(field.charsetnr)
1328 |                         if use_unicode and not charset.is_binary:
1329 |                             # TEXTs with charset=binary means BINARY types.
1330 |                             data = data.decode(charset.encoding)
1331 |                     else:
1332 |                         data = data.decode()
1333 | 
1334 |                 converter = self.connection.decoders.get(field_type)
1335 |                 if DEBUG: print("DEBUG: field={}, converter={}".format(field, converter))
1336 |                 if DEBUG: print("DEBUG: DATA = ", data)
1337 |                 if converter is not None:
1338 |                     data = converter(data)
1339 |             row.append(data)
1340 |         return tuple(row)
1341 | 
1342 |     @coroutine
1343 |     def _get_descriptions(self):
1344 |         """Read a column descriptor packet for each column in the result."""
1345 |         self.fields = []
1346 |         description = []
1347 |         for i in range_type(self.field_count):
1348 |             field = yield self.connection._read_packet(FieldDescriptorPacket)
1349 |             self.fields.append(field)
1350 |             description.append(field.description())
1351 | 
1352 |         eof_packet = yield self.connection._read_packet()
1353 |         assert eof_packet.is_eof_packet(), 'Protocol error, expecting EOF'
1354 |         self.description = tuple(description)
1355 | 
1356 | 
1357 | class Row(dict):
1358 |     """A dict that allows for object-like property access syntax."""
1359 |     def __getattr__(self, name):
1360 |         try:
1361 |             return self[name]
1362 |         except KeyError:
1363 |             raise AttributeError(name)
1364 | 
1365 |     def __setattr__(self, name, value):
1366 |         self[name] = value
1367 | 
1368 | 


--------------------------------------------------------------------------------
/asynctorndb/constants/CLIENT.py:
--------------------------------------------------------------------------------
 1 | 
 2 | LONG_PASSWORD = 1
 3 | FOUND_ROWS = 1 << 1
 4 | LONG_FLAG = 1 << 2
 5 | CONNECT_WITH_DB = 1 << 3
 6 | NO_SCHEMA = 1 << 4
 7 | COMPRESS = 1 << 5
 8 | ODBC = 1 << 6
 9 | LOCAL_FILES = 1 << 7
10 | IGNORE_SPACE = 1 << 8
11 | PROTOCOL_41 = 1 << 9
12 | INTERACTIVE = 1 << 10
13 | SSL = 1 << 11
14 | IGNORE_SIGPIPE = 1 << 12
15 | TRANSACTIONS  = 1 << 13
16 | SECURE_CONNECTION = 1 << 15
17 | MULTI_STATEMENTS = 1 << 16
18 | MULTI_RESULTS = 1 << 17
19 | CAPABILITIES = LONG_PASSWORD|LONG_FLAG|TRANSACTIONS| \
20 |     PROTOCOL_41|SECURE_CONNECTION
21 | 


--------------------------------------------------------------------------------
/asynctorndb/constants/COMMAND.py:
--------------------------------------------------------------------------------
 1 | 
 2 | COM_SLEEP = 0x00
 3 | COM_QUIT = 0x01
 4 | COM_INIT_DB = 0x02
 5 | COM_QUERY = 0x03
 6 | COM_FIELD_LIST = 0x04
 7 | COM_CREATE_DB = 0x05
 8 | COM_DROP_DB = 0x06
 9 | COM_REFRESH = 0x07
10 | COM_SHUTDOWN = 0x08
11 | COM_STATISTICS = 0x09
12 | COM_PROCESS_INFO = 0x0a
13 | COM_CONNECT = 0x0b
14 | COM_PROCESS_KILL = 0x0c
15 | COM_DEBUG = 0x0d
16 | COM_PING = 0x0e
17 | COM_TIME = 0x0f
18 | COM_DELAYED_INSERT = 0x10
19 | COM_CHANGE_USER = 0x11
20 | COM_BINLOG_DUMP = 0x12
21 | COM_TABLE_DUMP = 0x13
22 | COM_CONNECT_OUT = 0x14
23 | COM_REGISTER_SLAVE = 0x15
24 | 


--------------------------------------------------------------------------------
/asynctorndb/constants/ER.py:
--------------------------------------------------------------------------------
  1 | 
  2 | ERROR_FIRST = 1000
  3 | HASHCHK = 1000
  4 | NISAMCHK = 1001
  5 | NO = 1002
  6 | YES = 1003
  7 | CANT_CREATE_FILE = 1004
  8 | CANT_CREATE_TABLE = 1005
  9 | CANT_CREATE_DB = 1006
 10 | DB_CREATE_EXISTS = 1007
 11 | DB_DROP_EXISTS = 1008
 12 | DB_DROP_DELETE = 1009
 13 | DB_DROP_RMDIR = 1010
 14 | CANT_DELETE_FILE = 1011
 15 | CANT_FIND_SYSTEM_REC = 1012
 16 | CANT_GET_STAT = 1013
 17 | CANT_GET_WD = 1014
 18 | CANT_LOCK = 1015
 19 | CANT_OPEN_FILE = 1016
 20 | FILE_NOT_FOUND = 1017
 21 | CANT_READ_DIR = 1018
 22 | CANT_SET_WD = 1019
 23 | CHECKREAD = 1020
 24 | DISK_FULL = 1021
 25 | DUP_KEY = 1022
 26 | ERROR_ON_CLOSE = 1023
 27 | ERROR_ON_READ = 1024
 28 | ERROR_ON_RENAME = 1025
 29 | ERROR_ON_WRITE = 1026
 30 | FILE_USED = 1027
 31 | FILSORT_ABORT = 1028
 32 | FORM_NOT_FOUND = 1029
 33 | GET_ERRNO = 1030
 34 | ILLEGAL_HA = 1031
 35 | KEY_NOT_FOUND = 1032
 36 | NOT_FORM_FILE = 1033
 37 | NOT_KEYFILE = 1034
 38 | OLD_KEYFILE = 1035
 39 | OPEN_AS_READONLY = 1036
 40 | OUTOFMEMORY = 1037
 41 | OUT_OF_SORTMEMORY = 1038
 42 | UNEXPECTED_EOF = 1039
 43 | CON_COUNT_ERROR = 1040
 44 | OUT_OF_RESOURCES = 1041
 45 | BAD_HOST_ERROR = 1042
 46 | HANDSHAKE_ERROR = 1043
 47 | DBACCESS_DENIED_ERROR = 1044
 48 | ACCESS_DENIED_ERROR = 1045
 49 | NO_DB_ERROR = 1046
 50 | UNKNOWN_COM_ERROR = 1047
 51 | BAD_NULL_ERROR = 1048
 52 | BAD_DB_ERROR = 1049
 53 | TABLE_EXISTS_ERROR = 1050
 54 | BAD_TABLE_ERROR = 1051
 55 | NON_UNIQ_ERROR = 1052
 56 | SERVER_SHUTDOWN = 1053
 57 | BAD_FIELD_ERROR = 1054
 58 | WRONG_FIELD_WITH_GROUP = 1055
 59 | WRONG_GROUP_FIELD = 1056
 60 | WRONG_SUM_SELECT = 1057
 61 | WRONG_VALUE_COUNT = 1058
 62 | TOO_LONG_IDENT = 1059
 63 | DUP_FIELDNAME = 1060
 64 | DUP_KEYNAME = 1061
 65 | DUP_ENTRY = 1062
 66 | WRONG_FIELD_SPEC = 1063
 67 | PARSE_ERROR = 1064
 68 | EMPTY_QUERY = 1065
 69 | NONUNIQ_TABLE = 1066
 70 | INVALID_DEFAULT = 1067
 71 | MULTIPLE_PRI_KEY = 1068
 72 | TOO_MANY_KEYS = 1069
 73 | TOO_MANY_KEY_PARTS = 1070
 74 | TOO_LONG_KEY = 1071
 75 | KEY_COLUMN_DOES_NOT_EXITS = 1072
 76 | BLOB_USED_AS_KEY = 1073
 77 | TOO_BIG_FIELDLENGTH = 1074
 78 | WRONG_AUTO_KEY = 1075
 79 | READY = 1076
 80 | NORMAL_SHUTDOWN = 1077
 81 | GOT_SIGNAL = 1078
 82 | SHUTDOWN_COMPLETE = 1079
 83 | FORCING_CLOSE = 1080
 84 | IPSOCK_ERROR = 1081
 85 | NO_SUCH_INDEX = 1082
 86 | WRONG_FIELD_TERMINATORS = 1083
 87 | BLOBS_AND_NO_TERMINATED = 1084
 88 | TEXTFILE_NOT_READABLE = 1085
 89 | FILE_EXISTS_ERROR = 1086
 90 | LOAD_INFO = 1087
 91 | ALTER_INFO = 1088
 92 | WRONG_SUB_KEY = 1089
 93 | CANT_REMOVE_ALL_FIELDS = 1090
 94 | CANT_DROP_FIELD_OR_KEY = 1091
 95 | INSERT_INFO = 1092
 96 | UPDATE_TABLE_USED = 1093
 97 | NO_SUCH_THREAD = 1094
 98 | KILL_DENIED_ERROR = 1095
 99 | NO_TABLES_USED = 1096
100 | TOO_BIG_SET = 1097
101 | NO_UNIQUE_LOGFILE = 1098
102 | TABLE_NOT_LOCKED_FOR_WRITE = 1099
103 | TABLE_NOT_LOCKED = 1100
104 | BLOB_CANT_HAVE_DEFAULT = 1101
105 | WRONG_DB_NAME = 1102
106 | WRONG_TABLE_NAME = 1103
107 | TOO_BIG_SELECT = 1104
108 | UNKNOWN_ERROR = 1105
109 | UNKNOWN_PROCEDURE = 1106
110 | WRONG_PARAMCOUNT_TO_PROCEDURE = 1107
111 | WRONG_PARAMETERS_TO_PROCEDURE = 1108
112 | UNKNOWN_TABLE = 1109
113 | FIELD_SPECIFIED_TWICE = 1110
114 | INVALID_GROUP_FUNC_USE = 1111
115 | UNSUPPORTED_EXTENSION = 1112
116 | TABLE_MUST_HAVE_COLUMNS = 1113
117 | RECORD_FILE_FULL = 1114
118 | UNKNOWN_CHARACTER_SET = 1115
119 | TOO_MANY_TABLES = 1116
120 | TOO_MANY_FIELDS = 1117
121 | TOO_BIG_ROWSIZE = 1118
122 | STACK_OVERRUN = 1119
123 | WRONG_OUTER_JOIN = 1120
124 | NULL_COLUMN_IN_INDEX = 1121
125 | CANT_FIND_UDF = 1122
126 | CANT_INITIALIZE_UDF = 1123
127 | UDF_NO_PATHS = 1124
128 | UDF_EXISTS = 1125
129 | CANT_OPEN_LIBRARY = 1126
130 | CANT_FIND_DL_ENTRY = 1127
131 | FUNCTION_NOT_DEFINED = 1128
132 | HOST_IS_BLOCKED = 1129
133 | HOST_NOT_PRIVILEGED = 1130
134 | PASSWORD_ANONYMOUS_USER = 1131
135 | PASSWORD_NOT_ALLOWED = 1132
136 | PASSWORD_NO_MATCH = 1133
137 | UPDATE_INFO = 1134
138 | CANT_CREATE_THREAD = 1135
139 | WRONG_VALUE_COUNT_ON_ROW = 1136
140 | CANT_REOPEN_TABLE = 1137
141 | INVALID_USE_OF_NULL = 1138
142 | REGEXP_ERROR = 1139
143 | MIX_OF_GROUP_FUNC_AND_FIELDS = 1140
144 | NONEXISTING_GRANT = 1141
145 | TABLEACCESS_DENIED_ERROR = 1142
146 | COLUMNACCESS_DENIED_ERROR = 1143
147 | ILLEGAL_GRANT_FOR_TABLE = 1144
148 | GRANT_WRONG_HOST_OR_USER = 1145
149 | NO_SUCH_TABLE = 1146
150 | NONEXISTING_TABLE_GRANT = 1147
151 | NOT_ALLOWED_COMMAND = 1148
152 | SYNTAX_ERROR = 1149
153 | DELAYED_CANT_CHANGE_LOCK = 1150
154 | TOO_MANY_DELAYED_THREADS = 1151
155 | ABORTING_CONNECTION = 1152
156 | NET_PACKET_TOO_LARGE = 1153
157 | NET_READ_ERROR_FROM_PIPE = 1154
158 | NET_FCNTL_ERROR = 1155
159 | NET_PACKETS_OUT_OF_ORDER = 1156
160 | NET_UNCOMPRESS_ERROR = 1157
161 | NET_READ_ERROR = 1158
162 | NET_READ_INTERRUPTED = 1159
163 | NET_ERROR_ON_WRITE = 1160
164 | NET_WRITE_INTERRUPTED = 1161
165 | TOO_LONG_STRING = 1162
166 | TABLE_CANT_HANDLE_BLOB = 1163
167 | TABLE_CANT_HANDLE_AUTO_INCREMENT = 1164
168 | DELAYED_INSERT_TABLE_LOCKED = 1165
169 | WRONG_COLUMN_NAME = 1166
170 | WRONG_KEY_COLUMN = 1167
171 | WRONG_MRG_TABLE = 1168
172 | DUP_UNIQUE = 1169
173 | BLOB_KEY_WITHOUT_LENGTH = 1170
174 | PRIMARY_CANT_HAVE_NULL = 1171
175 | TOO_MANY_ROWS = 1172
176 | REQUIRES_PRIMARY_KEY = 1173
177 | NO_RAID_COMPILED = 1174
178 | UPDATE_WITHOUT_KEY_IN_SAFE_MODE = 1175
179 | KEY_DOES_NOT_EXITS = 1176
180 | CHECK_NO_SUCH_TABLE = 1177
181 | CHECK_NOT_IMPLEMENTED = 1178
182 | CANT_DO_THIS_DURING_AN_TRANSACTION = 1179
183 | ERROR_DURING_COMMIT = 1180
184 | ERROR_DURING_ROLLBACK = 1181
185 | ERROR_DURING_FLUSH_LOGS = 1182
186 | ERROR_DURING_CHECKPOINT = 1183
187 | NEW_ABORTING_CONNECTION = 1184
188 | DUMP_NOT_IMPLEMENTED = 1185
189 | FLUSH_MASTER_BINLOG_CLOSED = 1186
190 | INDEX_REBUILD = 1187
191 | MASTER = 1188
192 | MASTER_NET_READ = 1189
193 | MASTER_NET_WRITE = 1190
194 | FT_MATCHING_KEY_NOT_FOUND = 1191
195 | LOCK_OR_ACTIVE_TRANSACTION = 1192
196 | UNKNOWN_SYSTEM_VARIABLE = 1193
197 | CRASHED_ON_USAGE = 1194
198 | CRASHED_ON_REPAIR = 1195
199 | WARNING_NOT_COMPLETE_ROLLBACK = 1196
200 | TRANS_CACHE_FULL = 1197
201 | SLAVE_MUST_STOP = 1198
202 | SLAVE_NOT_RUNNING = 1199
203 | BAD_SLAVE = 1200
204 | MASTER_INFO = 1201
205 | SLAVE_THREAD = 1202
206 | TOO_MANY_USER_CONNECTIONS = 1203
207 | SET_CONSTANTS_ONLY = 1204
208 | LOCK_WAIT_TIMEOUT = 1205
209 | LOCK_TABLE_FULL = 1206
210 | READ_ONLY_TRANSACTION = 1207
211 | DROP_DB_WITH_READ_LOCK = 1208
212 | CREATE_DB_WITH_READ_LOCK = 1209
213 | WRONG_ARGUMENTS = 1210
214 | NO_PERMISSION_TO_CREATE_USER = 1211
215 | UNION_TABLES_IN_DIFFERENT_DIR = 1212
216 | LOCK_DEADLOCK = 1213
217 | TABLE_CANT_HANDLE_FT = 1214
218 | CANNOT_ADD_FOREIGN = 1215
219 | NO_REFERENCED_ROW = 1216
220 | ROW_IS_REFERENCED = 1217
221 | CONNECT_TO_MASTER = 1218
222 | QUERY_ON_MASTER = 1219
223 | ERROR_WHEN_EXECUTING_COMMAND = 1220
224 | WRONG_USAGE = 1221
225 | WRONG_NUMBER_OF_COLUMNS_IN_SELECT = 1222
226 | CANT_UPDATE_WITH_READLOCK = 1223
227 | MIXING_NOT_ALLOWED = 1224
228 | DUP_ARGUMENT = 1225
229 | USER_LIMIT_REACHED = 1226
230 | SPECIFIC_ACCESS_DENIED_ERROR = 1227
231 | LOCAL_VARIABLE = 1228
232 | GLOBAL_VARIABLE = 1229
233 | NO_DEFAULT = 1230
234 | WRONG_VALUE_FOR_VAR = 1231
235 | WRONG_TYPE_FOR_VAR = 1232
236 | VAR_CANT_BE_READ = 1233
237 | CANT_USE_OPTION_HERE = 1234
238 | NOT_SUPPORTED_YET = 1235
239 | MASTER_FATAL_ERROR_READING_BINLOG = 1236
240 | SLAVE_IGNORED_TABLE = 1237
241 | INCORRECT_GLOBAL_LOCAL_VAR = 1238
242 | WRONG_FK_DEF = 1239
243 | KEY_REF_DO_NOT_MATCH_TABLE_REF = 1240
244 | OPERAND_COLUMNS = 1241
245 | SUBQUERY_NO_1_ROW = 1242
246 | UNKNOWN_STMT_HANDLER = 1243
247 | CORRUPT_HELP_DB = 1244
248 | CYCLIC_REFERENCE = 1245
249 | AUTO_CONVERT = 1246
250 | ILLEGAL_REFERENCE = 1247
251 | DERIVED_MUST_HAVE_ALIAS = 1248
252 | SELECT_REDUCED = 1249
253 | TABLENAME_NOT_ALLOWED_HERE = 1250
254 | NOT_SUPPORTED_AUTH_MODE = 1251
255 | SPATIAL_CANT_HAVE_NULL = 1252
256 | COLLATION_CHARSET_MISMATCH = 1253
257 | SLAVE_WAS_RUNNING = 1254
258 | SLAVE_WAS_NOT_RUNNING = 1255
259 | TOO_BIG_FOR_UNCOMPRESS = 1256
260 | ZLIB_Z_MEM_ERROR = 1257
261 | ZLIB_Z_BUF_ERROR = 1258
262 | ZLIB_Z_DATA_ERROR = 1259
263 | CUT_VALUE_GROUP_CONCAT = 1260
264 | WARN_TOO_FEW_RECORDS = 1261
265 | WARN_TOO_MANY_RECORDS = 1262
266 | WARN_NULL_TO_NOTNULL = 1263
267 | WARN_DATA_OUT_OF_RANGE = 1264
268 | WARN_DATA_TRUNCATED = 1265
269 | WARN_USING_OTHER_HANDLER = 1266
270 | CANT_AGGREGATE_2COLLATIONS = 1267
271 | DROP_USER = 1268
272 | REVOKE_GRANTS = 1269
273 | CANT_AGGREGATE_3COLLATIONS = 1270
274 | CANT_AGGREGATE_NCOLLATIONS = 1271
275 | VARIABLE_IS_NOT_STRUCT = 1272
276 | UNKNOWN_COLLATION = 1273
277 | SLAVE_IGNORED_SSL_PARAMS = 1274
278 | SERVER_IS_IN_SECURE_AUTH_MODE = 1275
279 | WARN_FIELD_RESOLVED = 1276
280 | BAD_SLAVE_UNTIL_COND = 1277
281 | MISSING_SKIP_SLAVE = 1278
282 | UNTIL_COND_IGNORED = 1279
283 | WRONG_NAME_FOR_INDEX = 1280
284 | WRONG_NAME_FOR_CATALOG = 1281
285 | WARN_QC_RESIZE = 1282
286 | BAD_FT_COLUMN = 1283
287 | UNKNOWN_KEY_CACHE = 1284
288 | WARN_HOSTNAME_WONT_WORK = 1285
289 | UNKNOWN_STORAGE_ENGINE = 1286
290 | WARN_DEPRECATED_SYNTAX = 1287
291 | NON_UPDATABLE_TABLE = 1288
292 | FEATURE_DISABLED = 1289
293 | OPTION_PREVENTS_STATEMENT = 1290
294 | DUPLICATED_VALUE_IN_TYPE = 1291
295 | TRUNCATED_WRONG_VALUE = 1292
296 | TOO_MUCH_AUTO_TIMESTAMP_COLS = 1293
297 | INVALID_ON_UPDATE = 1294
298 | UNSUPPORTED_PS = 1295
299 | GET_ERRMSG = 1296
300 | GET_TEMPORARY_ERRMSG = 1297
301 | UNKNOWN_TIME_ZONE = 1298
302 | WARN_INVALID_TIMESTAMP = 1299
303 | INVALID_CHARACTER_STRING = 1300
304 | WARN_ALLOWED_PACKET_OVERFLOWED = 1301
305 | CONFLICTING_DECLARATIONS = 1302
306 | SP_NO_RECURSIVE_CREATE = 1303
307 | SP_ALREADY_EXISTS = 1304
308 | SP_DOES_NOT_EXIST = 1305
309 | SP_DROP_FAILED = 1306
310 | SP_STORE_FAILED = 1307
311 | SP_LILABEL_MISMATCH = 1308
312 | SP_LABEL_REDEFINE = 1309
313 | SP_LABEL_MISMATCH = 1310
314 | SP_UNINIT_VAR = 1311
315 | SP_BADSELECT = 1312
316 | SP_BADRETURN = 1313
317 | SP_BADSTATEMENT = 1314
318 | UPDATE_LOG_DEPRECATED_IGNORED = 1315
319 | UPDATE_LOG_DEPRECATED_TRANSLATED = 1316
320 | QUERY_INTERRUPTED = 1317
321 | SP_WRONG_NO_OF_ARGS = 1318
322 | SP_COND_MISMATCH = 1319
323 | SP_NORETURN = 1320
324 | SP_NORETURNEND = 1321
325 | SP_BAD_CURSOR_QUERY = 1322
326 | SP_BAD_CURSOR_SELECT = 1323
327 | SP_CURSOR_MISMATCH = 1324
328 | SP_CURSOR_ALREADY_OPEN = 1325
329 | SP_CURSOR_NOT_OPEN = 1326
330 | SP_UNDECLARED_VAR = 1327
331 | SP_WRONG_NO_OF_FETCH_ARGS = 1328
332 | SP_FETCH_NO_DATA = 1329
333 | SP_DUP_PARAM = 1330
334 | SP_DUP_VAR = 1331
335 | SP_DUP_COND = 1332
336 | SP_DUP_CURS = 1333
337 | SP_CANT_ALTER = 1334
338 | SP_SUBSELECT_NYI = 1335
339 | STMT_NOT_ALLOWED_IN_SF_OR_TRG = 1336
340 | SP_VARCOND_AFTER_CURSHNDLR = 1337
341 | SP_CURSOR_AFTER_HANDLER = 1338
342 | SP_CASE_NOT_FOUND = 1339
343 | FPARSER_TOO_BIG_FILE = 1340
344 | FPARSER_BAD_HEADER = 1341
345 | FPARSER_EOF_IN_COMMENT = 1342
346 | FPARSER_ERROR_IN_PARAMETER = 1343
347 | FPARSER_EOF_IN_UNKNOWN_PARAMETER = 1344
348 | VIEW_NO_EXPLAIN = 1345
349 | FRM_UNKNOWN_TYPE = 1346
350 | WRONG_OBJECT = 1347
351 | NONUPDATEABLE_COLUMN = 1348
352 | VIEW_SELECT_DERIVED = 1349
353 | VIEW_SELECT_CLAUSE = 1350
354 | VIEW_SELECT_VARIABLE = 1351
355 | VIEW_SELECT_TMPTABLE = 1352
356 | VIEW_WRONG_LIST = 1353
357 | WARN_VIEW_MERGE = 1354
358 | WARN_VIEW_WITHOUT_KEY = 1355
359 | VIEW_INVALID = 1356
360 | SP_NO_DROP_SP = 1357
361 | SP_GOTO_IN_HNDLR = 1358
362 | TRG_ALREADY_EXISTS = 1359
363 | TRG_DOES_NOT_EXIST = 1360
364 | TRG_ON_VIEW_OR_TEMP_TABLE = 1361
365 | TRG_CANT_CHANGE_ROW = 1362
366 | TRG_NO_SUCH_ROW_IN_TRG = 1363
367 | NO_DEFAULT_FOR_FIELD = 1364
368 | DIVISION_BY_ZERO = 1365
369 | TRUNCATED_WRONG_VALUE_FOR_FIELD = 1366
370 | ILLEGAL_VALUE_FOR_TYPE = 1367
371 | VIEW_NONUPD_CHECK = 1368
372 | VIEW_CHECK_FAILED = 1369
373 | PROCACCESS_DENIED_ERROR = 1370
374 | RELAY_LOG_FAIL = 1371
375 | PASSWD_LENGTH = 1372
376 | UNKNOWN_TARGET_BINLOG = 1373
377 | IO_ERR_LOG_INDEX_READ = 1374
378 | BINLOG_PURGE_PROHIBITED = 1375
379 | FSEEK_FAIL = 1376
380 | BINLOG_PURGE_FATAL_ERR = 1377
381 | LOG_IN_USE = 1378
382 | LOG_PURGE_UNKNOWN_ERR = 1379
383 | RELAY_LOG_INIT = 1380
384 | NO_BINARY_LOGGING = 1381
385 | RESERVED_SYNTAX = 1382
386 | WSAS_FAILED = 1383
387 | DIFF_GROUPS_PROC = 1384
388 | NO_GROUP_FOR_PROC = 1385
389 | ORDER_WITH_PROC = 1386
390 | LOGGING_PROHIBIT_CHANGING_OF = 1387
391 | NO_FILE_MAPPING = 1388
392 | WRONG_MAGIC = 1389
393 | PS_MANY_PARAM = 1390
394 | KEY_PART_0 = 1391
395 | VIEW_CHECKSUM = 1392
396 | VIEW_MULTIUPDATE = 1393
397 | VIEW_NO_INSERT_FIELD_LIST = 1394
398 | VIEW_DELETE_MERGE_VIEW = 1395
399 | CANNOT_USER = 1396
400 | XAER_NOTA = 1397
401 | XAER_INVAL = 1398
402 | XAER_RMFAIL = 1399
403 | XAER_OUTSIDE = 1400
404 | XAER_RMERR = 1401
405 | XA_RBROLLBACK = 1402
406 | NONEXISTING_PROC_GRANT = 1403
407 | PROC_AUTO_GRANT_FAIL = 1404
408 | PROC_AUTO_REVOKE_FAIL = 1405
409 | DATA_TOO_LONG = 1406
410 | SP_BAD_SQLSTATE = 1407
411 | STARTUP = 1408
412 | LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR = 1409
413 | CANT_CREATE_USER_WITH_GRANT = 1410
414 | WRONG_VALUE_FOR_TYPE = 1411
415 | TABLE_DEF_CHANGED = 1412
416 | SP_DUP_HANDLER = 1413
417 | SP_NOT_VAR_ARG = 1414
418 | SP_NO_RETSET = 1415
419 | CANT_CREATE_GEOMETRY_OBJECT = 1416
420 | FAILED_ROUTINE_BREAK_BINLOG = 1417
421 | BINLOG_UNSAFE_ROUTINE = 1418
422 | BINLOG_CREATE_ROUTINE_NEED_SUPER = 1419
423 | EXEC_STMT_WITH_OPEN_CURSOR = 1420
424 | STMT_HAS_NO_OPEN_CURSOR = 1421
425 | COMMIT_NOT_ALLOWED_IN_SF_OR_TRG = 1422
426 | NO_DEFAULT_FOR_VIEW_FIELD = 1423
427 | SP_NO_RECURSION = 1424
428 | TOO_BIG_SCALE = 1425
429 | TOO_BIG_PRECISION = 1426
430 | M_BIGGER_THAN_D = 1427
431 | WRONG_LOCK_OF_SYSTEM_TABLE = 1428
432 | CONNECT_TO_FOREIGN_DATA_SOURCE = 1429
433 | QUERY_ON_FOREIGN_DATA_SOURCE = 1430
434 | FOREIGN_DATA_SOURCE_DOESNT_EXIST = 1431
435 | FOREIGN_DATA_STRING_INVALID_CANT_CREATE = 1432
436 | FOREIGN_DATA_STRING_INVALID = 1433
437 | CANT_CREATE_FEDERATED_TABLE = 1434
438 | TRG_IN_WRONG_SCHEMA = 1435
439 | STACK_OVERRUN_NEED_MORE = 1436
440 | TOO_LONG_BODY = 1437
441 | WARN_CANT_DROP_DEFAULT_KEYCACHE = 1438
442 | TOO_BIG_DISPLAYWIDTH = 1439
443 | XAER_DUPID = 1440
444 | DATETIME_FUNCTION_OVERFLOW = 1441
445 | CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG = 1442
446 | VIEW_PREVENT_UPDATE = 1443
447 | PS_NO_RECURSION = 1444
448 | SP_CANT_SET_AUTOCOMMIT = 1445
449 | MALFORMED_DEFINER = 1446
450 | VIEW_FRM_NO_USER = 1447
451 | VIEW_OTHER_USER = 1448
452 | NO_SUCH_USER = 1449
453 | FORBID_SCHEMA_CHANGE = 1450
454 | ROW_IS_REFERENCED_2 = 1451
455 | NO_REFERENCED_ROW_2 = 1452
456 | SP_BAD_VAR_SHADOW = 1453
457 | TRG_NO_DEFINER = 1454
458 | OLD_FILE_FORMAT = 1455
459 | SP_RECURSION_LIMIT = 1456
460 | SP_PROC_TABLE_CORRUPT = 1457
461 | SP_WRONG_NAME = 1458
462 | TABLE_NEEDS_UPGRADE = 1459
463 | SP_NO_AGGREGATE = 1460
464 | MAX_PREPARED_STMT_COUNT_REACHED = 1461
465 | VIEW_RECURSIVE = 1462
466 | NON_GROUPING_FIELD_USED = 1463
467 | TABLE_CANT_HANDLE_SPKEYS = 1464
468 | NO_TRIGGERS_ON_SYSTEM_SCHEMA = 1465
469 | USERNAME = 1466
470 | HOSTNAME = 1467
471 | WRONG_STRING_LENGTH = 1468
472 | ERROR_LAST = 1468
473 | 


--------------------------------------------------------------------------------
/asynctorndb/constants/FIELD_TYPE.py:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | DECIMAL = 0
 4 | TINY = 1
 5 | SHORT = 2
 6 | LONG = 3
 7 | FLOAT = 4
 8 | DOUBLE = 5
 9 | NULL = 6
10 | TIMESTAMP = 7
11 | LONGLONG = 8
12 | INT24 = 9
13 | DATE = 10
14 | TIME = 11
15 | DATETIME = 12
16 | YEAR = 13
17 | NEWDATE = 14
18 | VARCHAR = 15
19 | BIT = 16
20 | NEWDECIMAL = 246
21 | ENUM = 247
22 | SET = 248
23 | TINY_BLOB = 249
24 | MEDIUM_BLOB = 250
25 | LONG_BLOB = 251
26 | BLOB = 252
27 | VAR_STRING = 253
28 | STRING = 254
29 | GEOMETRY = 255
30 | 
31 | CHAR = TINY
32 | INTERVAL = ENUM
33 | 


--------------------------------------------------------------------------------
/asynctorndb/constants/FLAG.py:
--------------------------------------------------------------------------------
 1 | NOT_NULL = 1
 2 | PRI_KEY = 2
 3 | UNIQUE_KEY = 4
 4 | MULTIPLE_KEY = 8
 5 | BLOB = 16
 6 | UNSIGNED = 32
 7 | ZEROFILL = 64
 8 | BINARY = 128
 9 | ENUM = 256
10 | AUTO_INCREMENT = 512
11 | TIMESTAMP = 1024
12 | SET = 2048
13 | PART_KEY = 16384
14 | GROUP = 32767
15 | UNIQUE = 65536
16 | 


--------------------------------------------------------------------------------
/asynctorndb/constants/SERVER_STATUS.py:
--------------------------------------------------------------------------------
 1 | 
 2 | SERVER_STATUS_IN_TRANS = 1
 3 | SERVER_STATUS_AUTOCOMMIT = 2
 4 | SERVER_MORE_RESULTS_EXISTS = 8
 5 | SERVER_QUERY_NO_GOOD_INDEX_USED = 16
 6 | SERVER_QUERY_NO_INDEX_USED = 32
 7 | SERVER_STATUS_CURSOR_EXISTS = 64
 8 | SERVER_STATUS_LAST_ROW_SENT = 128
 9 | SERVER_STATUS_DB_DROPPED = 256
10 | SERVER_STATUS_NO_BACKSLASH_ESCAPES = 512
11 | SERVER_STATUS_METADATA_CHANGED = 1024
12 | 


--------------------------------------------------------------------------------
/asynctorndb/constants/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mayflaver/AsyncTorndb/9281d544d0f87d62a3410a93e589ee2eda4af2be/asynctorndb/constants/__init__.py


--------------------------------------------------------------------------------
/asynctorndb/converters.py:
--------------------------------------------------------------------------------
  1 | from ._compat import PY2, text_type, long_type, JYTHON, IRONPYTHON
  2 | 
  3 | import sys
  4 | import binascii
  5 | import datetime
  6 | from decimal import Decimal
  7 | import re
  8 | import time
  9 | 
 10 | from .constants import FIELD_TYPE, FLAG
 11 | from .charset import charset_by_id, charset_to_encoding
 12 | 
 13 | 
 14 | ESCAPE_REGEX = re.compile(r"[\0\n\r\032\'\"\\]")
 15 | ESCAPE_MAP = {'\0': '\\0', '\n': '\\n', '\r': '\\r', '\032': '\\Z',
 16 |               '\'': '\\\'', '"': '\\"', '\\': '\\\\'}
 17 | 
 18 | 
 19 | def escape_item(val, charset):
 20 |     if type(val) in [tuple, list, set]:
 21 |         return escape_sequence(val, charset)
 22 |     if type(val) is dict:
 23 |         return escape_dict(val, charset)
 24 |     encoder = encoders[type(val)]
 25 |     val = encoder(val)
 26 |     if type(val) in [str, int, text_type]:
 27 |         return val
 28 |     return val
 29 | 
 30 | def escape_dict(val, charset):
 31 |     n = {}
 32 |     for k, v in list(val.items()):
 33 |         quoted = escape_item(v, charset)
 34 |         n[k] = quoted
 35 |     return n
 36 | 
 37 | def escape_sequence(val, charset):
 38 |     n = []
 39 |     for item in val:
 40 |         quoted = escape_item(item, charset)
 41 |         n.append(quoted)
 42 |     return "(" + ",".join(n) + ")"
 43 | 
 44 | def escape_set(val, charset):
 45 |     val = [escape_item(x, charset) for x in val]
 46 |     return ','.join(val)
 47 | 
 48 | def escape_bool(value):
 49 |     return str(int(value))
 50 | 
 51 | def escape_object(value):
 52 |     return str(value)
 53 | 
 54 | def escape_int(value):
 55 |     return str(value)
 56 | 
 57 | 
 58 | def escape_float(value):
 59 |     return ('%.15g' % value)
 60 | 
 61 | def escape_string(value):
 62 |     return ("%s" % (ESCAPE_REGEX.sub(
 63 |             lambda match: ESCAPE_MAP.get(match.group(0)), value),))
 64 | 
 65 | def escape_str(value):
 66 |     return "'%s'" % escape_string(value)
 67 | 
 68 | def escape_unicode(value):
 69 |     return escape_str(value)
 70 | 
 71 | def escape_bytes(value):
 72 |     return "x'%s'" % binascii.hexlify(value).decode(sys.getdefaultencoding())
 73 | 
 74 | def escape_None(value):
 75 |     return 'NULL'
 76 | 
 77 | def escape_timedelta(obj):
 78 |     seconds = int(obj.seconds) % 60
 79 |     minutes = int(obj.seconds // 60) % 60
 80 |     hours = int(obj.seconds // 3600) % 24 + int(obj.days) * 24
 81 |     return escape_str('%02d:%02d:%02d' % (hours, minutes, seconds))
 82 | 
 83 | def escape_time(obj):
 84 |     s = "%02d:%02d:%02d" % (int(obj.hour), int(obj.minute),
 85 |                             int(obj.second))
 86 |     if obj.microsecond:
 87 |         s += ".{0:06}".format(obj.microsecond)
 88 | 
 89 |     return escape_str(s)
 90 | 
 91 | def escape_datetime(obj):
 92 |     return escape_str(obj.isoformat(' '))
 93 | 
 94 | def escape_date(obj):
 95 |     return escape_str(obj.isoformat())
 96 | 
 97 | def escape_struct_time(obj):
 98 |     return escape_datetime(datetime.datetime(*obj[:6]))
 99 | 
100 | def convert_datetime(obj):
101 |     """Returns a DATETIME or TIMESTAMP column value as a datetime object:
102 | 
103 |       >>> datetime_or_None('2007-02-25 23:06:20')
104 |       datetime.datetime(2007, 2, 25, 23, 6, 20)
105 |       >>> datetime_or_None('2007-02-25T23:06:20')
106 |       datetime.datetime(2007, 2, 25, 23, 6, 20)
107 | 
108 |     Illegal values are returned as None:
109 | 
110 |       >>> datetime_or_None('2007-02-31T23:06:20') is None
111 |       True
112 |       >>> datetime_or_None('0000-00-00 00:00:00') is None
113 |       True
114 | 
115 |     """
116 |     if ' ' in obj:
117 |         sep = ' '
118 |     elif 'T' in obj:
119 |         sep = 'T'
120 |     else:
121 |         return convert_date(obj)
122 | 
123 |     try:
124 |         ymd, hms = obj.split(sep, 1)
125 |         usecs = '0'
126 |         if '.' in hms:
127 |             hms, usecs = hms.split('.')
128 |         usecs = float('0.' + usecs) * 1e6
129 |         return datetime.datetime(*[ int(x) for x in ymd.split('-')+hms.split(':')+[usecs] ])
130 |     except ValueError:
131 |         return convert_date(obj)
132 | 
133 | 
134 | def convert_timedelta(obj):
135 |     """Returns a TIME column as a timedelta object:
136 | 
137 |       >>> timedelta_or_None('25:06:17')
138 |       datetime.timedelta(1, 3977)
139 |       >>> timedelta_or_None('-25:06:17')
140 |       datetime.timedelta(-2, 83177)
141 | 
142 |     Illegal values are returned as None:
143 | 
144 |       >>> timedelta_or_None('random crap') is None
145 |       True
146 | 
147 |     Note that MySQL always returns TIME columns as (+|-)HH:MM:SS, but
148 |     can accept values as (+|-)DD HH:MM:SS. The latter format will not
149 |     be parsed correctly by this function.
150 |     """
151 |     try:
152 |         microseconds = 0
153 |         if "." in obj:
154 |             (obj, tail) = obj.split('.')
155 |             microseconds = float('0.' + tail) * 1e6
156 |         hours, minutes, seconds = obj.split(':')
157 |         tdelta = datetime.timedelta(
158 |             hours = int(hours),
159 |             minutes = int(minutes),
160 |             seconds = int(seconds),
161 |             microseconds = int(microseconds)
162 |             )
163 |         return tdelta
164 |     except ValueError:
165 |         return None
166 | 
167 | def convert_time(obj):
168 |     """Returns a TIME column as a time object:
169 | 
170 |       >>> time_or_None('15:06:17')
171 |       datetime.time(15, 6, 17)
172 | 
173 |     Illegal values are returned as None:
174 | 
175 |       >>> time_or_None('-25:06:17') is None
176 |       True
177 |       >>> time_or_None('random crap') is None
178 |       True
179 | 
180 |     Note that MySQL always returns TIME columns as (+|-)HH:MM:SS, but
181 |     can accept values as (+|-)DD HH:MM:SS. The latter format will not
182 |     be parsed correctly by this function.
183 | 
184 |     Also note that MySQL's TIME column corresponds more closely to
185 |     Python's timedelta and not time. However if you want TIME columns
186 |     to be treated as time-of-day and not a time offset, then you can
187 |     use set this function as the converter for FIELD_TYPE.TIME.
188 |     """
189 |     try:
190 |         microseconds = 0
191 |         if "." in obj:
192 |             (obj, tail) = obj.split('.')
193 |             microseconds = float('0.' + tail) * 1e6
194 |         hours, minutes, seconds = obj.split(':')
195 |         return datetime.time(hour=int(hours), minute=int(minutes),
196 |                              second=int(seconds), microsecond=int(microseconds))
197 |     except ValueError:
198 |         return None
199 | 
200 | def convert_date(obj):
201 |     """Returns a DATE column as a date object:
202 | 
203 |       >>> date_or_None('2007-02-26')
204 |       datetime.date(2007, 2, 26)
205 | 
206 |     Illegal values are returned as None:
207 | 
208 |       >>> date_or_None('2007-02-31') is None
209 |       True
210 |       >>> date_or_None('0000-00-00') is None
211 |       True
212 | 
213 |     """
214 |     try:
215 |         return datetime.date(*[ int(x) for x in obj.split('-', 2) ])
216 |     except ValueError:
217 |         return None
218 | 
219 | 
220 | def convert_mysql_timestamp(timestamp):
221 |     """Convert a MySQL TIMESTAMP to a Timestamp object.
222 | 
223 |     MySQL >= 4.1 returns TIMESTAMP in the same format as DATETIME:
224 | 
225 |       >>> mysql_timestamp_converter('2007-02-25 22:32:17')
226 |       datetime.datetime(2007, 2, 25, 22, 32, 17)
227 | 
228 |     MySQL < 4.1 uses a big string of numbers:
229 | 
230 |       >>> mysql_timestamp_converter('20070225223217')
231 |       datetime.datetime(2007, 2, 25, 22, 32, 17)
232 | 
233 |     Illegal values are returned as None:
234 | 
235 |       >>> mysql_timestamp_converter('2007-02-31 22:32:17') is None
236 |       True
237 |       >>> mysql_timestamp_converter('00000000000000') is None
238 |       True
239 | 
240 |     """
241 |     if timestamp[4] == '-':
242 |         return convert_datetime(timestamp)
243 |     timestamp += "0"*(14-len(timestamp)) # padding
244 |     year, month, day, hour, minute, second = \
245 |         int(timestamp[:4]), int(timestamp[4:6]), int(timestamp[6:8]), \
246 |         int(timestamp[8:10]), int(timestamp[10:12]), int(timestamp[12:14])
247 |     try:
248 |         return datetime.datetime(year, month, day, hour, minute, second)
249 |     except ValueError:
250 |         return None
251 | 
252 | def convert_set(s):
253 |     return set(s.split(","))
254 | 
255 | def convert_bit(b):
256 |     #b = "\x00" * (8 - len(b)) + b # pad w/ zeroes
257 |     #return struct.unpack(">Q", b)[0]
258 |     #
259 |     # the snippet above is right, but MySQLdb doesn't process bits,
260 |     # so we shouldn't either
261 |     return b
262 | 
263 | def convert_characters(connection, field, data):
264 |     field_charset = charset_by_id(field.charsetnr).name
265 |     encoding = charset_to_encoding(field_charset)
266 |     if field.flags & FLAG.SET:
267 |         return convert_set(data.decode(encoding))
268 |     if field.flags & FLAG.BINARY:
269 |         return data
270 | 
271 |     if connection.use_unicode:
272 |         data = data.decode(encoding)
273 |     elif connection.charset != field_charset:
274 |         data = data.decode(encoding)
275 |         data = data.encode(connection.encoding)
276 |     return data
277 | 
278 | encoders = {
279 |         bool: escape_bool,
280 |         int: escape_int,
281 |         long_type: escape_int,
282 |         float: escape_float,
283 |         str: escape_str,
284 |         text_type: escape_unicode,
285 |         tuple: escape_sequence,
286 |         list: escape_sequence,
287 |         set: escape_sequence,
288 |         dict: escape_dict,
289 |         type(None): escape_None,
290 |         datetime.date: escape_date,
291 |         datetime.datetime: escape_datetime,
292 |         datetime.timedelta: escape_timedelta,
293 |         datetime.time: escape_time,
294 |         time.struct_time: escape_struct_time,
295 |         Decimal: str,
296 |         }
297 | 
298 | 
299 | def through(x):
300 |     return x
301 | 
302 | if not PY2 or JYTHON or IRONPYTHON:
303 |     encoders[bytes] = escape_bytes
304 | 
305 | decoders = {
306 |         FIELD_TYPE.BIT: convert_bit,
307 |         FIELD_TYPE.TINY: int,
308 |         FIELD_TYPE.SHORT: int,
309 |         FIELD_TYPE.LONG: int,
310 |         FIELD_TYPE.FLOAT: float,
311 |         FIELD_TYPE.DOUBLE: float,
312 |         FIELD_TYPE.DECIMAL: float,
313 |         FIELD_TYPE.NEWDECIMAL: float,
314 |         FIELD_TYPE.LONGLONG: int,
315 |         FIELD_TYPE.INT24: int,
316 |         FIELD_TYPE.YEAR: int,
317 |         FIELD_TYPE.TIMESTAMP: convert_mysql_timestamp,
318 |         FIELD_TYPE.DATETIME: convert_datetime,
319 |         FIELD_TYPE.TIME: convert_timedelta,
320 |         FIELD_TYPE.DATE: convert_date,
321 |         FIELD_TYPE.SET: convert_set,
322 |         FIELD_TYPE.BLOB: through,
323 |         FIELD_TYPE.TINY_BLOB: through,
324 |         FIELD_TYPE.MEDIUM_BLOB: through,
325 |         FIELD_TYPE.LONG_BLOB: through,
326 |         FIELD_TYPE.STRING: through,
327 |         FIELD_TYPE.VAR_STRING: through,
328 |         FIELD_TYPE.VARCHAR: through,
329 |         FIELD_TYPE.DECIMAL: Decimal,
330 |         FIELD_TYPE.NEWDECIMAL: Decimal,
331 |         }
332 | 
333 | 
334 | # for MySQLdb compatibility
335 | conversions = decoders
336 | 
337 | def Thing2Literal(obj):
338 |     return escape_str(str(obj))
339 | 


--------------------------------------------------------------------------------
/asynctorndb/cursors.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | from __future__ import print_function, absolute_import
  3 | import re
  4 | 
  5 | from ._compat import range_type, text_type, PY2
  6 | from tornado.gen import coroutine, Return
  7 | 
  8 | from .err import (
  9 |     Warning, Error, InterfaceError, DataError,
 10 |     DatabaseError, OperationalError, IntegrityError, InternalError,
 11 |     NotSupportedError, ProgrammingError)
 12 | 
 13 | 
 14 | #: Regular expression for :meth:`Cursor.executemany`.
 15 | #: executemany only suports simple bulk insert.
 16 | #: You can use it to load large dataset.
 17 | RE_INSERT_VALUES = re.compile(r"""INSERT\s.+\sVALUES\s+(\(\s*%s\s*(,\s*%s\s*)*\))\s*\Z""",
 18 |                               re.IGNORECASE | re.DOTALL)
 19 | 
 20 | 
 21 | class Cursor(object):
 22 |     '''
 23 |     This is the object you use to interact with the database.
 24 |     '''
 25 | 
 26 |     #: Max stetement size which :meth:`executemany` generates.
 27 |     #:
 28 |     #: Max size of allowed statement is max_allowed_packet - packet_header_size.
 29 |     #: Default value of max_allowed_packet is 1048576.
 30 |     max_stmt_length = 1024000
 31 | 
 32 |     def __init__(self, connection):
 33 |         '''
 34 |         Do not create an instance of a Cursor yourself. Call
 35 |         connections.Connection.cursor().
 36 |         '''
 37 |         self.connection = connection
 38 |         self.description = None
 39 |         self.rownumber = 0
 40 |         self.rowcount = -1
 41 |         self.arraysize = 1
 42 |         self._executed = None
 43 |         self._result = None
 44 |         self._rows = None
 45 | 
 46 |     def __del__(self):
 47 |         '''
 48 |         When this gets GC'd close it.
 49 |         '''
 50 |         self.close()
 51 | 
 52 |     def close(self):
 53 |         '''
 54 |         Closing a cursor just exhausts all remaining data.
 55 |         '''
 56 |         conn = self.connection
 57 |         if conn is None:
 58 |             return
 59 |         try:
 60 |             while self.nextset():
 61 |                 pass
 62 |         finally:
 63 |             self.connection = None
 64 | 
 65 |     def _get_db(self):
 66 |         if not self.connection:
 67 |             raise ProgrammingError("Cursor closed")
 68 |         return self.connection
 69 | 
 70 |     def _check_executed(self):
 71 |         if not self._executed:
 72 |             raise ProgrammingError("execute() first")
 73 | 
 74 |     def _conv_row(self, row):
 75 |         return row
 76 | 
 77 |     def setinputsizes(self, *args):
 78 |         """Does nothing, required by DB API."""
 79 | 
 80 |     def setoutputsizes(self, *args):
 81 |         """Does nothing, required by DB API."""
 82 | 
 83 |     def nextset(self):
 84 |         """Get the next query set"""
 85 |         conn = self._get_db()
 86 |         current_result = self._result
 87 |         if current_result is None or current_result is not conn._result:
 88 |             return None
 89 |         if not current_result.has_next:
 90 |             return None
 91 |         conn.next_result()
 92 |         self._do_get_result()
 93 |         return True
 94 | 
 95 |     def _escape_args(self, args, conn):
 96 |         if isinstance(args, (tuple, list)):
 97 |             return tuple(conn.escape(arg) for arg in args)
 98 |         elif isinstance(args, dict):
 99 |             return dict((key, conn.escape(val)) for (key, val) in list(args.items()))
100 |         else:
101 |             #If it's not a dictionary let's try escaping it anyways.
102 |             #Worst case it will throw a Value error
103 |             return conn.escape(args)
104 | 
105 |     @coroutine
106 |     def execute(self, query, *args):
107 |         '''Execute a query'''
108 |         conn = self._get_db()
109 | 
110 |         while self.nextset():
111 |             pass
112 | 
113 |         if PY2:  # Use bytes on Python 2 always
114 |             encoding = conn.encoding
115 | 
116 |             def ensure_bytes(x):
117 |                 if isinstance(x, unicode):
118 |                     x = x.encode(encoding)
119 |                 return x
120 | 
121 |             query = ensure_bytes(query)
122 | 
123 |             if args is not None:
124 |                 if isinstance(args, (tuple, list)):
125 |                     args = tuple(map(ensure_bytes, args))
126 |                 elif isinstance(args, dict):
127 |                     args = dict((ensure_bytes(key), ensure_bytes(val)) for (key, val) in args.items())
128 |                 else:
129 |                     args = ensure_bytes(args)
130 | 
131 |         if args is not None:
132 |             query = query % self._escape_args(args, conn)
133 | 
134 |         result = yield self._query(query)
135 |         self._executed = query
136 |         raise Return(result)
137 | 
138 |     @coroutine
139 |     def executemany(self, query, args):
140 |         """Run several data against one query
141 | 
142 |         PyMySQL can execute bulkinsert for query like 'INSERT ... VALUES (%s)'.
143 |         In other form of queries, just run :meth:`execute` many times.
144 |         """
145 |         if not args:
146 |             raise Return()
147 | 
148 |         m = RE_INSERT_VALUES.match(query)
149 |         if m:
150 |             q_values = m.group(1).rstrip()
151 |             assert q_values[0] == '(' and q_values[-1] == ')'
152 |             q_prefix = query[:m.start(1)]
153 |             raise Return((yield self._do_execute_many(q_prefix, q_values, args,
154 |                                                     self.max_stmt_length,
155 |                                                     self._get_db().encoding)))
156 | 
157 |         for arg in args:
158 |             row = yield self.execute(query, *arg)
159 |             self.rowcount += row
160 |         raise Return(self.rowcount)
161 | 
162 |     @coroutine
163 |     def _do_execute_many(self, prefix, values, args, max_stmt_length, encoding):
164 |         conn = self._get_db()
165 |         escape = self._escape_args
166 |         if isinstance(prefix, text_type):
167 |             prefix = prefix.encode(encoding)
168 |         sql = bytearray(prefix)
169 |         args = iter(args)
170 |         v = values % escape(next(args), conn)
171 |         if isinstance(v, text_type):
172 |             v = v.encode(encoding)
173 |         sql += v
174 |         rows = 0
175 |         for arg in args:
176 |             v = values % escape(arg, conn)
177 |             if isinstance(v, text_type):
178 |                 v = v.encode(encoding)
179 |             if len(sql) + len(v) + 1 > max_stmt_length:
180 |                 row = yield self.execute(str(sql))
181 |                 rows += row
182 |                 sql = bytearray(prefix)
183 |             else:
184 |                 sql += b','
185 |             sql += v
186 |         row = yield self.execute(str(sql))
187 |         rows += row
188 |         self.rowcount = rows
189 |         raise Return(rows)
190 | 
191 |     def callproc(self, procname, args=()):
192 |         """Execute stored procedure procname with args
193 | 
194 |         procname -- string, name of procedure to execute on server
195 | 
196 |         args -- Sequence of parameters to use with procedure
197 | 
198 |         Returns the original args.x
199 | 
200 |         Compatibility warning: PEP-249 specifies that any modified
201 |         parameters must be returned. This is currently impossible
202 |         as they are only available by storing them in a server
203 |         variable and then retrieved by a query. Since stored
204 |         procedures return zero or more result sets, there is no
205 |         reliable way to get at OUT or INOUT parameters via callproc.
206 |         The server variables are named @_procname_n, where procname
207 |         is the parameter above and n is the position of the parameter
208 |         (from zero). Once all result sets generated by the procedure
209 |         have been fetched, you can issue a SELECT @_procname_0, ...
210 |         query using .execute() to get any OUT or INOUT values.
211 | 
212 |         Compatibility warning: The act of calling a stored procedure
213 |         itself creates an empty result set. This appears after any
214 |         result sets generated by the procedure. This is non-standard
215 |         behavior with respect to the DB-API. Be sure to use nextset()
216 |         to advance through all result sets; otherwise you may get
217 |         disconnected.
218 |         """
219 |         conn = self._get_db()
220 |         for index, arg in enumerate(args):
221 |             q = "SET @_%s_%d=%s" % (procname, index, conn.escape(arg))
222 |             self._query(q)
223 |             self.nextset()
224 | 
225 |         q = "CALL %s(%s)" % (procname,
226 |                              ','.join(['@_%s_%d' % (procname, i)
227 |                                        for i in range_type(len(args))]))
228 |         self._query(q)
229 |         self._executed = q
230 |         return args
231 | 
232 |     def fetchone(self):
233 |         ''' Fetch the next row '''
234 |         self._check_executed()
235 |         if self._rows is None or self.rownumber >= len(self._rows):
236 |             return None
237 |         result = self._rows[self.rownumber]
238 |         self.rownumber += 1
239 |         return result
240 | 
241 |     def fetchmany(self, size=None):
242 |         ''' Fetch several rows '''
243 |         self._check_executed()
244 |         if self._rows is None:
245 |             return None
246 |         end = self.rownumber + (size or self.arraysize)
247 |         result = self._rows[self.rownumber:end]
248 |         self.rownumber = min(end, len(self._rows))
249 |         return result
250 | 
251 |     def fetchall(self):
252 |         ''' Fetch all the rows '''
253 |         self._check_executed()
254 |         if self._rows is None:
255 |             return None
256 |         if self.rownumber:
257 |             result = self._rows[self.rownumber:]
258 |         else:
259 |             result = self._rows
260 |         self.rownumber = len(self._rows)
261 |         return result
262 | 
263 |     def scroll(self, value, mode='relative'):
264 |         self._check_executed()
265 |         if mode == 'relative':
266 |             r = self.rownumber + value
267 |         elif mode == 'absolute':
268 |             r = value
269 |         else:
270 |             raise ProgrammingError("unknown scroll mode %s" % mode)
271 | 
272 |         if not (0 <= r < len(self._rows)):
273 |             raise IndexError("out of range")
274 |         self.rownumber = r
275 | 
276 |     @coroutine
277 |     def _query(self, q):
278 |         conn = self._get_db()
279 |         self._last_executed = q
280 |         yield conn.execute_query(q)
281 |         self._do_get_result()
282 |         raise Return(self.rowcount)
283 | 
284 |     def _do_get_result(self):
285 |         conn = self._get_db()
286 | 
287 |         self.rownumber = 0
288 |         self._result = result = conn._result
289 | 
290 |         self.rowcount = result.affected_rows
291 |         self.description = result.description
292 |         self.lastrowid = result.insert_id
293 |         self._rows = result.rows
294 | 
295 |     def __iter__(self):
296 |         return iter(self.fetchone, None)
297 | 
298 |     Warning = Warning
299 |     Error = Error
300 |     InterfaceError = InterfaceError
301 |     DatabaseError = DatabaseError
302 |     DataError = DataError
303 |     OperationalError = OperationalError
304 |     IntegrityError = IntegrityError
305 |     InternalError = InternalError
306 |     ProgrammingError = ProgrammingError
307 |     NotSupportedError = NotSupportedError
308 | 
309 | 
310 | class DictCursorMixin(object):
311 |     # You can override this to use OrderedDict or other dict-like types.
312 |     dict_type = dict
313 | 
314 |     def _do_get_result(self):
315 |         super(DictCursorMixin, self)._do_get_result()
316 |         fields = []
317 |         if self.description:
318 |             for f in self._result.fields:
319 |                 name = f.name
320 |                 if name in fields:
321 |                     name = f.table_name + '.' + name
322 |                 fields.append(name)
323 |             self._fields = fields
324 | 
325 |         if fields and self._rows:
326 |             self._rows = [self._conv_row(r) for r in self._rows]
327 | 
328 |     def _conv_row(self, row):
329 |         if row is None:
330 |             return None
331 |         return self.dict_type(list(zip(self._fields, row)))
332 | 
333 | 
334 | class DictCursor(DictCursorMixin, Cursor):
335 |     """A cursor which returns results as a dictionary"""
336 | 
337 | 
338 | class SSCursor(Cursor):
339 |     """
340 |     Unbuffered Cursor, mainly useful for queries that return a lot of data,
341 |     or for connections to remote servers over a slow network.
342 | 
343 |     Instead of copying every row of data into a buffer, this will fetch
344 |     rows as needed. The upside of this, is the client uses much less memory,
345 |     and rows are returned much faster when traveling over a slow network,
346 |     or if the result set is very big.
347 | 
348 |     There are limitations, though. The MySQL protocol doesn't support
349 |     returning the total number of rows, so the only way to tell how many rows
350 |     there are is to iterate over every row returned. Also, it currently isn't
351 |     possible to scroll backwards, as only the current row is held in memory.
352 |     """
353 | 
354 |     def _conv_row(self, row):
355 |         return row
356 | 
357 |     def close(self):
358 |         conn = self.connection
359 |         if conn is None:
360 |             return
361 | 
362 |         if self._result is not None and self._result is conn._result:
363 |             self._result._finish_unbuffered_query()
364 | 
365 |         try:
366 |             while self.nextset():
367 |                 pass
368 |         finally:
369 |             self.connection = None
370 | 
371 |     def _query(self, q):
372 |         conn = self._get_db()
373 |         self._last_executed = q
374 |         conn.execute_query(q, unbuffered=True)
375 |         self._do_get_result()
376 |         return self.rowcount
377 | 
378 |     def read_next(self):
379 |         """ Read next row """
380 |         return self._conv_row(self._result._read_rowdata_packet_unbuffered())
381 | 
382 |     def fetchone(self):
383 |         """ Fetch next row """
384 |         self._check_executed()
385 |         row = self.read_next()
386 |         if row is None:
387 |             return None
388 |         self.rownumber += 1
389 |         return row
390 | 
391 |     def fetchall(self):
392 |         """
393 |         Fetch all, as per MySQLdb. Pretty useless for large queries, as
394 |         it is buffered. See fetchall_unbuffered(), if you want an unbuffered
395 |         generator version of this method.
396 | 
397 |         """
398 |         return list(self.fetchall_unbuffered())
399 | 
400 |     def fetchall_unbuffered(self):
401 |         """
402 |         Fetch all, implemented as a generator, which isn't to standard,
403 |         however, it doesn't make sense to return everything in a list, as that
404 |         would use ridiculous memory for large result sets.
405 |         """
406 |         return iter(self.fetchone, None)
407 | 
408 |     def __iter__(self):
409 |         return self.fetchall_unbuffered()
410 | 
411 |     def fetchmany(self, size=None):
412 |         """ Fetch many """
413 | 
414 |         self._check_executed()
415 |         if size is None:
416 |             size = self.arraysize
417 | 
418 |         rows = []
419 |         for i in range_type(size):
420 |             row = self.read_next()
421 |             if row is None:
422 |                 break
423 |             rows.append(row)
424 |             self.rownumber += 1
425 |         return rows
426 | 
427 |     def scroll(self, value, mode='relative'):
428 |         self._check_executed()
429 | 
430 |         if mode == 'relative':
431 |             if value < 0:
432 |                 raise NotSupportedError(
433 |                         "Backwards scrolling not supported by this cursor")
434 | 
435 |             for _ in range_type(value):
436 |                 self.read_next()
437 |             self.rownumber += value
438 |         elif mode == 'absolute':
439 |             if value < self.rownumber:
440 |                 raise NotSupportedError(
441 |                     "Backwards scrolling not supported by this cursor")
442 | 
443 |             end = value - self.rownumber
444 |             for _ in range_type(end):
445 |                 self.read_next()
446 |             self.rownumber = value
447 |         else:
448 |             raise ProgrammingError("unknown scroll mode %s" % mode)
449 | 
450 |             
451 | class SSDictCursor(DictCursorMixin, SSCursor):
452 |     """ An unbuffered cursor, which returns results as a dictionary """
453 | 


--------------------------------------------------------------------------------
/asynctorndb/err.py:
--------------------------------------------------------------------------------
  1 | import struct
  2 | 
  3 | from .constants import ER
  4 | 
  5 | class MySQLError(Exception):
  6 |     """Exception related to operation with MySQL."""
  7 | 
  8 | 
  9 | class Warning(Warning, MySQLError):
 10 |     """Exception raised for important warnings like data truncations
 11 |     while inserting, etc."""
 12 | 
 13 | class Error(MySQLError):
 14 |     """Exception that is the base class of all other error exceptions
 15 |     (not Warning)."""
 16 | 
 17 | 
 18 | class InterfaceError(Error):
 19 |     """Exception raised for errors that are related to the database
 20 |     interface rather than the database itself."""
 21 | 
 22 | 
 23 | class DatabaseError(Error):
 24 |     """Exception raised for errors that are related to the
 25 |     database."""
 26 | 
 27 | 
 28 | class DataError(DatabaseError):
 29 |     """Exception raised for errors that are due to problems with the
 30 |     processed data like division by zero, numeric value out of range,
 31 |     etc."""
 32 | 
 33 | 
 34 | class OperationalError(DatabaseError):
 35 |     """Exception raised for errors that are related to the database's
 36 |     operation and not necessarily under the control of the programmer,
 37 |     e.g. an unexpected disconnect occurs, the data source name is not
 38 |     found, a transaction could not be processed, a memory allocation
 39 |     error occurred during processing, etc."""
 40 | 
 41 | 
 42 | class IntegrityError(DatabaseError):
 43 |     """Exception raised when the relational integrity of the database
 44 |     is affected, e.g. a foreign key check fails, duplicate key,
 45 |     etc."""
 46 | 
 47 | 
 48 | class InternalError(DatabaseError):
 49 |     """Exception raised when the database encounters an internal
 50 |     error, e.g. the cursor is not valid anymore, the transaction is
 51 |     out of sync, etc."""
 52 | 
 53 | 
 54 | class ProgrammingError(DatabaseError):
 55 |     """Exception raised for programming errors, e.g. table not found
 56 |     or already exists, syntax error in the SQL statement, wrong number
 57 |     of parameters specified, etc."""
 58 | 
 59 | 
 60 | class NotSupportedError(DatabaseError):
 61 |     """Exception raised in case a method or database API was used
 62 |     which is not supported by the database, e.g. requesting a
 63 |     .rollback() on a connection that does not support transaction or
 64 |     has transactions turned off."""
 65 | 
 66 | 
 67 | error_map = {}
 68 | 
 69 | def _map_error(exc, *errors):
 70 |     for error in errors:
 71 |         error_map[error] = exc
 72 | 
 73 | _map_error(ProgrammingError, ER.DB_CREATE_EXISTS, ER.SYNTAX_ERROR,
 74 |            ER.PARSE_ERROR, ER.NO_SUCH_TABLE, ER.WRONG_DB_NAME,
 75 |            ER.WRONG_TABLE_NAME, ER.FIELD_SPECIFIED_TWICE,
 76 |            ER.INVALID_GROUP_FUNC_USE, ER.UNSUPPORTED_EXTENSION,
 77 |            ER.TABLE_MUST_HAVE_COLUMNS, ER.CANT_DO_THIS_DURING_AN_TRANSACTION)
 78 | _map_error(DataError, ER.WARN_DATA_TRUNCATED, ER.WARN_NULL_TO_NOTNULL,
 79 |            ER.WARN_DATA_OUT_OF_RANGE, ER.NO_DEFAULT, ER.PRIMARY_CANT_HAVE_NULL,
 80 |            ER.DATA_TOO_LONG, ER.DATETIME_FUNCTION_OVERFLOW)
 81 | _map_error(IntegrityError, ER.DUP_ENTRY, ER.NO_REFERENCED_ROW,
 82 |            ER.NO_REFERENCED_ROW_2, ER.ROW_IS_REFERENCED, ER.ROW_IS_REFERENCED_2,
 83 |            ER.CANNOT_ADD_FOREIGN, ER.BAD_NULL_ERROR)
 84 | _map_error(NotSupportedError, ER.WARNING_NOT_COMPLETE_ROLLBACK,
 85 |            ER.NOT_SUPPORTED_YET, ER.FEATURE_DISABLED, ER.UNKNOWN_STORAGE_ENGINE)
 86 | _map_error(OperationalError, ER.DBACCESS_DENIED_ERROR, ER.ACCESS_DENIED_ERROR,
 87 |            ER.CON_COUNT_ERROR, ER.TABLEACCESS_DENIED_ERROR,
 88 |            ER.COLUMNACCESS_DENIED_ERROR)
 89 | 
 90 | del _map_error, ER
 91 | 
 92 | 
 93 | def _get_error_info(data):
 94 |     errno = struct.unpack('<h', data[1:3])[0]
 95 |     is_41 = data[3:4] == b"#"
 96 |     if is_41:
 97 |         # version 4.1
 98 |         sqlstate = data[4:9].decode("utf8", 'replace')
 99 |         errorvalue = data[9:].decode("utf8", 'replace')
100 |         return (errno, sqlstate, errorvalue)
101 |     else:
102 |         # version 4.0
103 |         return (errno, None, data[3:].decode("utf8", 'replace'))
104 | 
105 | def _check_mysql_exception(errinfo):
106 |     errno, sqlstate, errorvalue = errinfo
107 |     errorclass = error_map.get(errno, None)
108 |     if errorclass:
109 |         raise errorclass(errno,errorvalue)
110 | 
111 |     # couldn't find the right error number
112 |     raise InternalError(errno, errorvalue)
113 | 
114 | def raise_mysql_exception(data):
115 |     errinfo = _get_error_info(data)
116 |     _check_mysql_exception(errinfo)
117 | 


--------------------------------------------------------------------------------
/asynctorndb/tcpclient.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #
  3 | # Copyright 2014 Facebook
  4 | #
  5 | # Licensed under the Apache License, Version 2.0 (the "License"); you may
  6 | # not use this file except in compliance with the License. You may obtain
  7 | # a copy of the License at
  8 | #
  9 | #     http://www.apache.org/licenses/LICENSE-2.0
 10 | #
 11 | # Unless required by applicable law or agreed to in writing, software
 12 | # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 13 | # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 14 | # License for the specific language governing permissions and limitations
 15 | # under the License.
 16 | 
 17 | """A non-blocking TCP connection factory.
 18 | """
 19 | from __future__ import absolute_import, division, print_function, with_statement
 20 | 
 21 | import functools
 22 | import socket
 23 | 
 24 | from tornado.concurrent import Future
 25 | from tornado.ioloop import IOLoop
 26 | from tornado.iostream import IOStream
 27 | from tornado import gen
 28 | from tornado.netutil import Resolver
 29 | 
 30 | _INITIAL_CONNECT_TIMEOUT = 0.3
 31 | 
 32 | 
 33 | class _Connector(object):
 34 |     """A stateless implementation of the "Happy Eyeballs" algorithm.
 35 | 
 36 |     "Happy Eyeballs" is documented in RFC6555 as the recommended practice
 37 |     for when both IPv4 and IPv6 addresses are available.
 38 | 
 39 |     In this implementation, we partition the addresses by family, and
 40 |     make the first connection attempt to whichever address was
 41 |     returned first by ``getaddrinfo``.  If that connection fails or
 42 |     times out, we begin a connection in parallel to the first address
 43 |     of the other family.  If there are additional failures we retry
 44 |     with other addresses, keeping one connection attempt per family
 45 |     in flight at a time.
 46 | 
 47 |     http://tools.ietf.org/html/rfc6555
 48 | 
 49 |     """
 50 |     def __init__(self, addrinfo, io_loop, connect):
 51 |         self.io_loop = io_loop
 52 |         self.connect = connect
 53 | 
 54 |         self.future = Future()
 55 |         self.timeout = None
 56 |         self.last_error = None
 57 |         self.remaining = len(addrinfo)
 58 |         self.primary_addrs, self.secondary_addrs = self.split(addrinfo)
 59 | 
 60 |     @staticmethod
 61 |     def split(addrinfo):
 62 |         """Partition the ``addrinfo`` list by address family.
 63 | 
 64 |         Returns two lists.  The first list contains the first entry from
 65 |         ``addrinfo`` and all others with the same family, and the
 66 |         second list contains all other addresses (normally one list will
 67 |         be AF_INET and the other AF_INET6, although non-standard resolvers
 68 |         may return additional families).
 69 |         """
 70 |         primary = []
 71 |         secondary = []
 72 |         primary_af = addrinfo[0][0]
 73 |         for af, addr in addrinfo:
 74 |             if af == primary_af:
 75 |                 primary.append((af, addr))
 76 |             else:
 77 |                 secondary.append((af, addr))
 78 |         return primary, secondary
 79 | 
 80 |     def start(self, timeout=_INITIAL_CONNECT_TIMEOUT):
 81 |         self.try_connect(iter(self.primary_addrs))
 82 |         self.set_timout(timeout)
 83 |         return self.future
 84 | 
 85 |     def try_connect(self, addrs):
 86 |         try:
 87 |             af, addr = next(addrs)
 88 |         except StopIteration:
 89 |             # We've reached the end of our queue, but the other queue
 90 |             # might still be working.  Send a final error on the future
 91 |             # only when both queues are finished.
 92 |             if self.remaining == 0 and not self.future.done():
 93 |                 self.future.set_exception(self.last_error or
 94 |                                           IOError("connection failed"))
 95 |             return
 96 |         future = self.connect(af, addr)
 97 |         future.add_done_callback(functools.partial(self.on_connect_done,
 98 |                                                    addrs, af, addr))
 99 | 
100 |     def on_connect_done(self, addrs, af, addr, future):
101 |         self.remaining -= 1
102 |         try:
103 |             stream = future.result()
104 |         except Exception as e:
105 |             if self.future.done():
106 |                 return
107 |             # Error: try again (but remember what happened so we have an
108 |             # error to raise in the end)
109 |             self.last_error = e
110 |             self.try_connect(addrs)
111 |             if self.timeout is not None:
112 |                 # If the first attempt failed, don't wait for the
113 |                 # timeout to try an address from the secondary queue.
114 |                 self.on_timeout()
115 |             return
116 |         self.clear_timeout()
117 |         if self.future.done():
118 |             # This is a late arrival; just drop it.
119 |             stream.close()
120 |         else:
121 |             self.future.set_result((af, addr, stream))
122 | 
123 |     def set_timout(self, timeout):
124 |         self.timeout = self.io_loop.add_timeout(self.io_loop.time() + timeout,
125 |                                                 self.on_timeout)
126 | 
127 |     def on_timeout(self):
128 |         self.timeout = None
129 |         self.try_connect(iter(self.secondary_addrs))
130 | 
131 |     def clear_timeout(self):
132 |         if self.timeout is not None:
133 |             self.io_loop.remove_timeout(self.timeout)
134 | 
135 | 
136 | class TCPClient(object):
137 |     """A non-blocking TCP connection factory.
138 |     """
139 |     def __init__(self, resolver=None, io_loop=None):
140 |         self.io_loop = io_loop or IOLoop.current()
141 |         if resolver is not None:
142 |             self.resolver = resolver
143 |             self._own_resolver = False
144 |         else:
145 |             self.resolver = Resolver(io_loop=io_loop)
146 |             self._own_resolver = True
147 | 
148 |     def close(self):
149 |         if self._own_resolver:
150 |             self.resolver.close()
151 | 
152 |     @gen.coroutine
153 |     def connect(self, host, port, af=socket.AF_UNSPEC, ssl_options=None,
154 |                 max_buffer_size=None):
155 |         """Connect to the given host and port.
156 | 
157 |         Asynchronously returns an `.IOStream` (or `.SSLIOStream` if
158 |         ``ssl_options`` is not None).
159 |         """
160 |         addrinfo = yield self.resolver.resolve(host, port, af)
161 |         connector = _Connector(
162 |             addrinfo, self.io_loop,
163 |             functools.partial(self._create_stream, max_buffer_size))
164 |         af, addr, stream = yield connector.start()
165 |         # TODO: For better performance we could cache the (af, addr)
166 |         # information here and re-use it on sbusequent connections to
167 |         # the same host. (http://tools.ietf.org/html/rfc6555#section-4.2)
168 |         if ssl_options is not None:
169 |             stream = yield stream.start_tls(False, ssl_options=ssl_options,
170 |                                             server_hostname=host)
171 |         raise gen.Return(stream)
172 | 
173 |     def _create_stream(self, max_buffer_size, af, addr):
174 |         # Always connect in plaintext; we'll convert to ssl if necessary
175 |         # after one connection has completed.
176 |         stream = IOStream(socket.socket(af),
177 |                           io_loop=self.io_loop,
178 |                           max_buffer_size=max_buffer_size)
179 |         return stream.connect(addr)
180 | 


--------------------------------------------------------------------------------
/asynctorndb/times.py:
--------------------------------------------------------------------------------
 1 | from time import localtime
 2 | from datetime import date, datetime, time, timedelta
 3 | 
 4 | Date = date
 5 | Time = time
 6 | TimeDelta = timedelta
 7 | Timestamp = datetime
 8 | 
 9 | def DateFromTicks(ticks):
10 |     return date(*localtime(ticks)[:3])
11 | 
12 | def TimeFromTicks(ticks):
13 |     return time(*localtime(ticks)[3:6])
14 | 
15 | def TimestampFromTicks(ticks):
16 |     return datetime(*localtime(ticks)[:6])
17 | 


--------------------------------------------------------------------------------
/asynctorndb/util.py:
--------------------------------------------------------------------------------
 1 | import struct
 2 | 
 3 | def byte2int(b):
 4 |     if isinstance(b, int):
 5 |         return b
 6 |     else:
 7 |         return struct.unpack("!B", b)[0]
 8 | 
 9 | def int2byte(i):
10 |     return struct.pack("!B", i)
11 | 
12 | def join_bytes(bs):
13 |     if len(bs) == 0:
14 |         return ""
15 |     else:
16 |         rv = bs[0]
17 |         for b in bs[1:]:
18 |             rv += b
19 |         return rv
20 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #
 3 | # Copyright 2014 Mayflower
 4 | #
 5 | 
 6 | from setuptools import setup, find_packages
 7 | 
 8 | version = "0.1"
 9 | 
10 | setup(
11 |     name="asynctorndb",
12 |     version=version,
13 |     author="Mayflower",
14 |     author_email="fucongwang@gmail.com",
15 |     url="https://github.com/mayflaver/AsyncTorndb",
16 |     license="MIT",
17 |     packages=find_packages(),
18 |     description="async mysql client for tornado.",
19 |     )
20 | 


--------------------------------------------------------------------------------