diff options
| author | adustman <adustman@9fc6cd9a-920d-0410-adcf-ac96716ed7e8> | 2009-02-06 01:23:21 +0000 |
|---|---|---|
| committer | adustman <adustman@9fc6cd9a-920d-0410-adcf-ac96716ed7e8> | 2009-02-06 01:23:21 +0000 |
| commit | 97ee5f86cad57bd99f508569936e79d1e84fc20f (patch) | |
| tree | 972d4857afa4578f26f08ae171788231cc40b1c8 | |
| download | mysqldb1-97ee5f86cad57bd99f508569936e79d1e84fc20f.tar.gz | |
1.2.3b1MySQLdb-1.2.3b1
36 files changed, 8082 insertions, 0 deletions
diff --git a/MySQLdb/.cvsignore b/MySQLdb/.cvsignore new file mode 100644 index 0000000..d562f69 --- /dev/null +++ b/MySQLdb/.cvsignore @@ -0,0 +1,6 @@ +dist +build +regress.py +test.py +PKG-INFO +*.pyc diff --git a/MySQLdb/HISTORY b/MySQLdb/HISTORY new file mode 100644 index 0000000..e7de68b --- /dev/null +++ b/MySQLdb/HISTORY @@ -0,0 +1,100 @@ +===================== + What's new in 1.2.2 +===================== + +The build system has been completely redone and should now build +on Windows without any patching; uses setuptools. + +Added compatibility for Python 2.5, including support for with statement. + +connection.ping() now takes an optional boolean argument which can +enable (or disable) automatic reconnection. + +Support returning SET columns as Python sets was removed due to an +API bug in MySQL; corresponding test removed. + +Added a test for single-character CHAR columns. + +BLOB columns are now returned as Python strings instead of byte arrays. + +BINARY character columns are always returned as Python strings, and not +unicode. + +Fixed a bug introduced in 1.2.1 where the new SHOW WARNINGS support broke +SSCursor. + +Only encode the query (convert to a string) when it is a unicode instance; +re-encoding encoded strings would break things. + +Make a deep copy of conv when connecting, since it can be modified. + +Added support for new VARCHAR and BIT column types. + +DBAPISet objects were broken, but nobody noticed. + + +======================== + What's new in 1.2.1_p2 +======================== + +There are some minor build fixes which probably only affect MySQL +older than 4.0. + +If you had MySQL older than 4.1, the new charset and sql_mode +parameters didn't work right. In fact, it was impossible to create +a connection due to the charset problem. + +If you are using MySQL-4.1 or newer, there is no practical difference +between 1.2.1 and 1.2.1_p2, and you don't need to upgrade. + + +===================== + What's new in 1.2.1 +===================== + +Switched to Subversion. Was going to do this for 1.3, but a +SourceForge CVS outage has forced the issue. + +Mapped a lot of new 4.1 and 5.0 error codes to Python exceptions + +Added an API call for mysql_set_character_set(charset) (MySQL > 5.0.7) + +Added an API call for mysql_get_character_set_info() (MySQL > 5.0.10) + +Revamped the build system. Edit site.cfg if necessary (probably not +in most cases) + +Python-2.3 is now the minimum version. + +Dropped support for mx.Datetime and stringtimes; always uses Python +datetime module now. + +Improved unit tests + +New connect() options: +* charset: sets character set, implies use_unicode +* sql_mode: sets SQL mode (i.e. ANSI, etc.; see MySQL docs) + +When using MySQL-4.1 or newer, enables MULTI_STATEMENTS + +When using MySQL-5.0 or newer, enables MULTI_RESULTS + +When using MySQL-4.1 or newer, more detailed warning messages +are produced + +SET columns returned as Python Set types; you can pass a Set as +a parameter to cursor.execute(). + +Support for the new MySQL-5.0 DECIMAL implementation + +Support for Python Decimal type + +Some use of weak references internally. Cursors no longer leak +if you don't close them. Connections still do, unfortunately. + +ursor.fetchXXXDict() methods raise DeprecationWarning + +cursor.begin() is making a brief reappearence. + +cursor.callproc() now works, with some limitations. + diff --git a/MySQLdb/MANIFEST.in b/MySQLdb/MANIFEST.in new file mode 100644 index 0000000..0b78a83 --- /dev/null +++ b/MySQLdb/MANIFEST.in @@ -0,0 +1,16 @@ +recursive-include doc *.txt +include MANIFEST.in +include MANIFEST +include ChangeLog +include HISTORY +include GPL +include pymemcompat.h +include dbapi20.py +include test_MySQLdb_dbapi20.py +include test_capabilities.py +include test_MySQLdb_capabilities.py +include metadata.cfg +include site.cfg +include setup_common.py +include setup_posix.py +include setup_windows.py diff --git a/MySQLdb/MySQLdb/.cvsignore b/MySQLdb/MySQLdb/.cvsignore new file mode 100644 index 0000000..0d20b64 --- /dev/null +++ b/MySQLdb/MySQLdb/.cvsignore @@ -0,0 +1 @@ +*.pyc diff --git a/MySQLdb/MySQLdb/__init__.py b/MySQLdb/MySQLdb/__init__.py new file mode 100644 index 0000000..7bfac1d --- /dev/null +++ b/MySQLdb/MySQLdb/__init__.py @@ -0,0 +1,98 @@ +"""MySQLdb - A DB API v2.0 compatible interface to MySQL. + +This package is a wrapper around _mysql, which mostly implements the +MySQL C API. + +connect() -- connects to server + +See the C API specification and the MySQL documentation for more info +on other items. + +For information on how MySQLdb handles type conversion, see the +MySQLdb.converters module. + +""" + +__revision__ = """$Revision$"""[11:-2] +from release import __version__, version_info, __author__ + +import _mysql + +if version_info != _mysql.version_info: + raise ImportError, "this is MySQLdb version %s, but _mysql is version %r" %\ + (version_info, _mysql.version_info) + +threadsafety = 1 +apilevel = "2.0" +paramstyle = "format" + +from _mysql import * +from MySQLdb.constants import FIELD_TYPE +from MySQLdb.times import Date, Time, Timestamp, \ + DateFromTicks, TimeFromTicks, TimestampFromTicks + +try: + frozenset +except NameError: + from sets import ImmutableSet as frozenset + +class DBAPISet(frozenset): + + """A special type of set for which A == x is true if A is a + DBAPISet and x is a member of that set.""" + + def __eq__(self, other): + if isinstance(other, DBAPISet): + return not self.difference(other) + return other in self + + +STRING = DBAPISet([FIELD_TYPE.ENUM, FIELD_TYPE.STRING, + FIELD_TYPE.VAR_STRING]) +BINARY = DBAPISet([FIELD_TYPE.BLOB, FIELD_TYPE.LONG_BLOB, + FIELD_TYPE.MEDIUM_BLOB, FIELD_TYPE.TINY_BLOB]) +NUMBER = DBAPISet([FIELD_TYPE.DECIMAL, FIELD_TYPE.DOUBLE, FIELD_TYPE.FLOAT, + FIELD_TYPE.INT24, FIELD_TYPE.LONG, FIELD_TYPE.LONGLONG, + FIELD_TYPE.TINY, FIELD_TYPE.YEAR]) +DATE = DBAPISet([FIELD_TYPE.DATE, FIELD_TYPE.NEWDATE]) +TIME = DBAPISet([FIELD_TYPE.TIME]) +TIMESTAMP = DBAPISet([FIELD_TYPE.TIMESTAMP, FIELD_TYPE.DATETIME]) +DATETIME = TIMESTAMP +ROWID = DBAPISet() + +def test_DBAPISet_set_equality(): + assert STRING == STRING + +def test_DBAPISet_set_inequality(): + assert STRING != NUMBER + +def test_DBAPISet_set_equality_membership(): + assert FIELD_TYPE.VAR_STRING == STRING + +def test_DBAPISet_set_inequality_membership(): + assert FIELD_TYPE.DATE != STRING + +def Binary(x): + return str(x) + +def Connect(*args, **kwargs): + """Factory function for connections.Connection.""" + from connections import Connection + return Connection(*args, **kwargs) + +connect = Connection = Connect + +__all__ = [ 'BINARY', 'Binary', 'Connect', 'Connection', 'DATE', + 'Date', 'Time', 'Timestamp', 'DateFromTicks', 'TimeFromTicks', + 'TimestampFromTicks', 'DataError', 'DatabaseError', 'Error', + 'FIELD_TYPE', 'IntegrityError', 'InterfaceError', 'InternalError', + 'MySQLError', 'NULL', 'NUMBER', 'NotSupportedError', 'DBAPISet', + 'OperationalError', 'ProgrammingError', 'ROWID', 'STRING', 'TIME', + 'TIMESTAMP', 'Warning', 'apilevel', 'connect', 'connections', + 'constants', 'converters', 'cursors', 'debug', 'escape', 'escape_dict', + 'escape_sequence', 'escape_string', 'get_client_info', + 'paramstyle', 'string_literal', 'threadsafety', 'version_info'] + + + + diff --git a/MySQLdb/MySQLdb/connections.py b/MySQLdb/MySQLdb/connections.py new file mode 100644 index 0000000..92ca8ee --- /dev/null +++ b/MySQLdb/MySQLdb/connections.py @@ -0,0 +1,316 @@ +""" + +This module implements connections for MySQLdb. Presently there is +only one class: Connection. Others are unlikely. However, you might +want to make your own subclasses. In most cases, you will probably +override Connection.default_cursor with a non-standard Cursor class. + +""" +import cursors +from _mysql_exceptions import Warning, Error, InterfaceError, DataError, \ + DatabaseError, OperationalError, IntegrityError, InternalError, \ + NotSupportedError, ProgrammingError +import types, _mysql + + +def defaulterrorhandler(connection, cursor, errorclass, errorvalue): + """ + + If cursor is not None, (errorclass, errorvalue) is appended to + cursor.messages; otherwise it is appended to + connection.messages. Then errorclass is raised with errorvalue as + the value. + + You can override this with your own error handler by assigning it + to the instance. + + """ + error = errorclass, errorvalue + if cursor: + cursor.messages.append(error) + else: + connection.messages.append(error) + del cursor + del connection + raise errorclass(errorvalue) + + +class Connection(_mysql.connection): + + """MySQL Database Connection Object""" + + default_cursor = cursors.Cursor + + def __init__(self, *args, **kwargs): + """ + + Create a connection to the database. It is strongly recommended + that you only use keyword parameters. Consult the MySQL C API + documentation for more information. + + host + string, host to connect + + user + string, user to connect as + + passwd + string, password to use + + db + string, database to use + + port + integer, TCP/IP port to connect to + + unix_socket + string, location of unix_socket to use + + conv + conversion dictionary, see MySQLdb.converters + + connect_timeout + number of seconds to wait before the connection attempt + fails. + + compress + if set, compression is enabled + + named_pipe + if set, a named pipe is used to connect (Windows only) + + init_command + command which is run once the connection is created + + read_default_file + file from which default client values are read + + read_default_group + configuration group to use from the default file + + cursorclass + class object, used to create cursors (keyword only) + + use_unicode + If True, text-like columns are returned as unicode objects + using the connection's character set. Otherwise, text-like + columns are returned as strings. columns are returned as + normal strings. Unicode objects will always be encoded to + the connection's character set regardless of this setting. + + charset + If supplied, the connection character set will be changed + to this character set (MySQL-4.1 and newer). This implies + use_unicode=True. + + sql_mode + If supplied, the session SQL mode will be changed to this + setting (MySQL-4.1 and newer). For more details and legal + values, see the MySQL documentation. + + client_flag + integer, flags to use or 0 + (see MySQL docs or constants/CLIENTS.py) + + ssl + dictionary or mapping, contains SSL connection parameters; + see the MySQL documentation for more details + (mysql_ssl_set()). If this is set, and the client does not + support SSL, NotSupportedError will be raised. + + local_infile + integer, non-zero enables LOAD LOCAL INFILE; zero disables + + There are a number of undocumented, non-standard methods. See the + documentation for the MySQL C API for some hints on what they do. + + """ + from constants import CLIENT, FIELD_TYPE + from converters import conversions + from weakref import proxy, WeakValueDictionary + + import types + + kwargs2 = kwargs.copy() + + if kwargs.has_key('conv'): + conv = kwargs['conv'] + else: + conv = conversions + + conv2 = {} + for k, v in conv.items(): + if isinstance(k, int): + if isinstance(v, list): + conv2[k] = v[:] + else: + conv2[k] = v + kwargs2['conv'] = conv2 + + self.cursorclass = kwargs2.pop('cursorclass', self.default_cursor) + charset = kwargs2.pop('charset', '') + + if charset: + use_unicode = True + else: + use_unicode = False + + use_unicode = kwargs2.pop('use_unicode', use_unicode) + sql_mode = kwargs2.pop('sql_mode', '') + + client_flag = kwargs.get('client_flag', 0) + client_version = tuple([ int(n) for n in _mysql.get_client_info().split('.')[:2] ]) + if client_version >= (4, 1): + client_flag |= CLIENT.MULTI_STATEMENTS + if client_version >= (5, 0): + client_flag |= CLIENT.MULTI_RESULTS + + kwargs2['client_flag'] = client_flag + + super(Connection, self).__init__(*args, **kwargs2) + + self.encoders = dict([ (k, v) for k, v in conv.items() + if type(k) is not int ]) + + self._server_version = tuple([ int(n) for n in self.get_server_info().split('.')[:2] ]) + + db = proxy(self) + def _get_string_literal(): + def string_literal(obj, dummy=None): + return db.string_literal(obj) + return string_literal + + def _get_unicode_literal(): + def unicode_literal(u, dummy=None): + return db.literal(u.encode(unicode_literal.charset)) + return unicode_literal + + def _get_string_decoder(): + def string_decoder(s): + return s.decode(string_decoder.charset) + return string_decoder + + string_literal = _get_string_literal() + self.unicode_literal = unicode_literal = _get_unicode_literal() + self.string_decoder = string_decoder = _get_string_decoder() + if not charset: + charset = self.character_set_name() + self.set_character_set(charset) + + if sql_mode: + self.set_sql_mode(sql_mode) + + if use_unicode: + self.converter[FIELD_TYPE.STRING].append((None, string_decoder)) + self.converter[FIELD_TYPE.VAR_STRING].append((None, string_decoder)) + self.converter[FIELD_TYPE.VARCHAR].append((None, string_decoder)) + self.converter[FIELD_TYPE.BLOB].append((None, string_decoder)) + + self.encoders[types.StringType] = string_literal + self.encoders[types.UnicodeType] = unicode_literal + self._transactional = self.server_capabilities & CLIENT.TRANSACTIONS + if self._transactional: + # PEP-249 requires autocommit to be initially off + self.autocommit(False) + self.messages = [] + + def cursor(self, cursorclass=None): + """ + + Create a cursor on which queries may be performed. The + optional cursorclass parameter is used to create the + Cursor. By default, self.cursorclass=cursors.Cursor is + used. + + """ + return (cursorclass or self.cursorclass)(self) + + def __enter__(self): return self.cursor() + + def __exit__(self, exc, value, tb): + if exc: + self.rollback() + else: + self.commit() + + def literal(self, o): + """ + + If o is a single object, returns an SQL literal as a string. + If o is a non-string sequence, the items of the sequence are + converted and returned as a sequence. + + Non-standard. For internal use; do not use this in your + applications. + + """ + return self.escape(o, self.encoders) + + def begin(self): + """Explicitly begin a connection. Non-standard. + DEPRECATED: Will be removed in 1.3. + Use an SQL BEGIN statement instead.""" + from warnings import warn + warn("begin() is non-standard and will be removed in 1.3", + DeprecationWarning, 2) + self.query("BEGIN") + + if not hasattr(_mysql.connection, 'warning_count'): + + def warning_count(self): + """Return the number of warnings generated from the + last query. This is derived from the info() method.""" + from string import atoi + info = self.info() + if info: + return atoi(info.split()[-1]) + else: + return 0 + + def set_character_set(self, charset): + """Set the connection character set to charset. The character + set can only be changed in MySQL-4.1 and newer. If you try + to change the character set from the current value in an + older version, NotSupportedError will be raised.""" + if self.character_set_name() != charset: + try: + super(Connection, self).set_character_set(charset) + except AttributeError: + if self._server_version < (4, 1): + raise NotSupportedError("server is too old to set charset") + self.query('SET NAMES %s' % charset) + self.store_result() + self.string_decoder.charset = charset + self.unicode_literal.charset = charset + + def set_sql_mode(self, sql_mode): + """Set the connection sql_mode. See MySQL documentation for + legal values.""" + if self._server_version < (4, 1): + raise NotSupportedError("server is too old to set sql_mode") + self.query("SET SESSION sql_mode='%s'" % sql_mode) + self.store_result() + + def show_warnings(self): + """Return detailed information about warnings as a + sequence of tuples of (Level, Code, Message). This + is only supported in MySQL-4.1 and up. If your server + is an earlier version, an empty sequence is returned.""" + if self._server_version < (4,1): return () + self.query("SHOW WARNINGS") + r = self.store_result() + warnings = r.fetch_row(0) + return warnings + + Warning = Warning + Error = Error + InterfaceError = InterfaceError + DatabaseError = DatabaseError + DataError = DataError + OperationalError = OperationalError + IntegrityError = IntegrityError + InternalError = InternalError + ProgrammingError = ProgrammingError + NotSupportedError = NotSupportedError + + errorhandler = defaulterrorhandler diff --git a/MySQLdb/MySQLdb/constants/.cvsignore b/MySQLdb/MySQLdb/constants/.cvsignore new file mode 100644 index 0000000..0d20b64 --- /dev/null +++ b/MySQLdb/MySQLdb/constants/.cvsignore @@ -0,0 +1 @@ +*.pyc diff --git a/MySQLdb/MySQLdb/constants/CLIENT.py b/MySQLdb/MySQLdb/constants/CLIENT.py new file mode 100644 index 0000000..6559917 --- /dev/null +++ b/MySQLdb/MySQLdb/constants/CLIENT.py @@ -0,0 +1,29 @@ +"""MySQL CLIENT constants + +These constants are used when creating the connection. Use bitwise-OR +(|) to combine options together, and pass them as the client_flags +parameter to MySQLdb.Connection. For more information on these flags, +see the MySQL C API documentation for mysql_real_connect(). + +""" + +LONG_PASSWORD = 1 +FOUND_ROWS = 2 +LONG_FLAG = 4 +CONNECT_WITH_DB = 8 +NO_SCHEMA = 16 +COMPRESS = 32 +ODBC = 64 +LOCAL_FILES = 128 +IGNORE_SPACE = 256 +CHANGE_USER = 512 +INTERACTIVE = 1024 +SSL = 2048 +IGNORE_SIGPIPE = 4096 +TRANSACTIONS = 8192 # mysql_com.h was WRONG prior to 3.23.35 +RESERVED = 16384 +SECURE_CONNECTION = 32768 +MULTI_STATEMENTS = 65536 +MULTI_RESULTS = 131072 + + diff --git a/MySQLdb/MySQLdb/constants/CR.py b/MySQLdb/MySQLdb/constants/CR.py new file mode 100644 index 0000000..249dfec --- /dev/null +++ b/MySQLdb/MySQLdb/constants/CR.py @@ -0,0 +1,30 @@ +"""MySQL Connection Errors + +Nearly all of these raise OperationalError. COMMANDS_OUT_OF_SYNC +raises ProgrammingError. + +""" + +MIN_ERROR = 2000 +MAX_ERROR = 2999 +UNKNOWN_ERROR = 2000 +SOCKET_CREATE_ERROR = 2001 +CONNECTION_ERROR = 2002 +CONN_HOST_ERROR = 2003 +IPSOCK_ERROR = 2004 +UNKNOWN_HOST = 2005 +SERVER_GONE_ERROR = 2006 +VERSION_ERROR = 2007 +OUT_OF_MEMORY = 2008 +WRONG_HOST_INFO = 2009 +LOCALHOST_CONNECTION = 2010 +TCP_CONNECTION = 2011 +SERVER_HANDSHAKE_ERR = 2012 +SERVER_LOST = 2013 +COMMANDS_OUT_OF_SYNC = 2014 +NAMEDPIPE_CONNECTION = 2015 +NAMEDPIPEWAIT_ERROR = 2016 +NAMEDPIPEOPEN_ERROR = 2017 +NAMEDPIPESETSTATE_ERROR = 2018 +CANT_READ_CHARSET = 2019 +NET_PACKET_TOO_LARGE = 2020 diff --git a/MySQLdb/MySQLdb/constants/ER.py b/MySQLdb/MySQLdb/constants/ER.py new file mode 100644 index 0000000..ed45f3a --- /dev/null +++ b/MySQLdb/MySQLdb/constants/ER.py @@ -0,0 +1,467 @@ +"""MySQL ER Constants + +These constants are error codes for the bulk of the error conditions +that may occur. + +""" + +HASHCHK = 1000 +NISAMCHK = 1001 +NO = 1002 +YES = 1003 +CANT_CREATE_FILE = 1004 +CANT_CREATE_TABLE = 1005 +CANT_CREATE_DB = 1006 +DB_CREATE_EXISTS = 1007 +DB_DROP_EXISTS = 1008 +DB_DROP_DELETE = 1009 +DB_DROP_RMDIR = 1010 +CANT_DELETE_FILE = 1011 +CANT_FIND_SYSTEM_REC = 1012 +CANT_GET_STAT = 1013 +CANT_GET_WD = 1014 +CANT_LOCK = 1015 +CANT_OPEN_FILE = 1016 +FILE_NOT_FOUND = 1017 +CANT_READ_DIR = 1018 +CANT_SET_WD = 1019 +CHECKREAD = 1020 +DISK_FULL = 1021 +DUP_KEY = 1022 +ERROR_ON_CLOSE = 1023 +ERROR_ON_READ = 1024 +ERROR_ON_RENAME = 1025 +ERROR_ON_WRITE = 1026 +FILE_USED = 1027 +FILSORT_ABORT = 1028 +FORM_NOT_FOUND = 1029 +GET_ERRNO = 1030 +ILLEGAL_HA = 1031 +KEY_NOT_FOUND = 1032 +NOT_FORM_FILE = 1033 +NOT_KEYFILE = 1034 +OLD_KEYFILE = 1035 +OPEN_AS_READONLY = 1036 +OUTOFMEMORY = 1037 +OUT_OF_SORTMEMORY = 1038 +UNEXPECTED_EOF = 1039 +CON_COUNT_ERROR = 1040 +OUT_OF_RESOURCES = 1041 +BAD_HOST_ERROR = 1042 +HANDSHAKE_ERROR = 1043 +DBACCESS_DENIED_ERROR = 1044 +ACCESS_DENIED_ERROR = 1045 +NO_DB_ERROR = 1046 +UNKNOWN_COM_ERROR = 1047 +BAD_NULL_ERROR = 1048 +BAD_DB_ERROR = 1049 +TABLE_EXISTS_ERROR = 1050 +BAD_TABLE_ERROR = 1051 +NON_UNIQ_ERROR = 1052 +SERVER_SHUTDOWN = 1053 +BAD_FIELD_ERROR = 1054 +WRONG_FIELD_WITH_GROUP = 1055 +WRONG_GROUP_FIELD = 1056 +WRONG_SUM_SELECT = 1057 +WRONG_VALUE_COUNT = 1058 +TOO_LONG_IDENT = 1059 +DUP_FIELDNAME = 1060 +DUP_KEYNAME = 1061 +DUP_ENTRY = 1062 +WRONG_FIELD_SPEC = 1063 +PARSE_ERROR = 1064 +EMPTY_QUERY = 1065 +NONUNIQ_TABLE = 1066 +INVALID_DEFAULT = 1067 +MULTIPLE_PRI_KEY = 1068 +TOO_MANY_KEYS = 1069 +TOO_MANY_KEY_PARTS = 1070 +TOO_LONG_KEY = 1071 +KEY_COLUMN_DOES_NOT_EXITS = 1072 +BLOB_USED_AS_KEY = 1073 +TOO_BIG_FIELDLENGTH = 1074 +WRONG_AUTO_KEY = 1075 +READY = 1076 +NORMAL_SHUTDOWN = 1077 +GOT_SIGNAL = 1078 +SHUTDOWN_COMPLETE = 1079 +FORCING_CLOSE = 1080 +IPSOCK_ERROR = 1081 +NO_SUCH_INDEX = 1082 +WRONG_FIELD_TERMINATORS = 1083 +BLOBS_AND_NO_TERMINATED = 1084 +TEXTFILE_NOT_READABLE = 1085 +FILE_EXISTS_ERROR = 1086 +LOAD_INFO = 1087 +ALTER_INFO = 1088 +WRONG_SUB_KEY = 1089 +CANT_REMOVE_ALL_FIELDS = 1090 +CANT_DROP_FIELD_OR_KEY = 1091 +INSERT_INFO = 1092 +INSERT_TABLE_USED = 1093 +NO_SUCH_THREAD = 1094 +KILL_DENIED_ERROR = 1095 +NO_TABLES_USED = 1096 +TOO_BIG_SET = 1097 +NO_UNIQUE_LOGFILE = 1098 +TABLE_NOT_LOCKED_FOR_WRITE = 1099 +TABLE_NOT_LOCKED = 1100 +BLOB_CANT_HAVE_DEFAULT = 1101 +WRONG_DB_NAME = 1102 +WRONG_TABLE_NAME = 1103 +TOO_BIG_SELECT = 1104 +UNKNOWN_ERROR = 1105 +UNKNOWN_PROCEDURE = 1106 +WRONG_PARAMCOUNT_TO_PROCEDURE = 1107 +WRONG_PARAMETERS_TO_PROCEDURE = 1108 +UNKNOWN_TABLE = 1109 +FIELD_SPECIFIED_TWICE = 1110 +INVALID_GROUP_FUNC_USE = 1111 +UNSUPPORTED_EXTENSION = 1112 +TABLE_MUST_HAVE_COLUMNS = 1113 +RECORD_FILE_FULL = 1114 +UNKNOWN_CHARACTER_SET = 1115 +TOO_MANY_TABLES = 1116 +TOO_MANY_FIELDS = 1117 +TOO_BIG_ROWSIZE = 1118 +STACK_OVERRUN = 1119 +WRONG_OUTER_JOIN = 1120 +NULL_COLUMN_IN_INDEX = 1121 +CANT_FIND_UDF = 1122 +CANT_INITIALIZE_UDF = 1123 +UDF_NO_PATHS = 1124 +UDF_EXISTS = 1125 +CANT_OPEN_LIBRARY = 1126 +CANT_FIND_DL_ENTRY = 1127 +FUNCTION_NOT_DEFINED = 1128 +HOST_IS_BLOCKED = 1129 +HOST_NOT_PRIVILEGED = 1130 +PASSWORD_ANONYMOUS_USER = 1131 +PASSWORD_NOT_ALLOWED = 1132 +PASSWORD_NO_MATCH = 1133 +UPDATE_INFO = 1134 +CANT_CREATE_THREAD = 1135 +WRONG_VALUE_COUNT_ON_ROW = 1136 +CANT_REOPEN_TABLE = 1137 +INVALID_USE_OF_NULL = 1138 +REGEXP_ERROR = 1139 +MIX_OF_GROUP_FUNC_AND_FIELDS = 1140 +NONEXISTING_GRANT = 1141 +TABLEACCESS_DENIED_ERROR = 1142 +COLUMNACCESS_DENIED_ERROR = 1143 +ILLEGAL_GRANT_FOR_TABLE = 1144 +GRANT_WRONG_HOST_OR_USER = 1145 +NO_SUCH_TABLE = 1146 +NONEXISTING_TABLE_GRANT = 1147 +NOT_ALLOWED_COMMAND = 1148 +SYNTAX_ERROR = 1149 +DELAYED_CANT_CHANGE_LOCK = 1150 +TOO_MANY_DELAYED_THREADS = 1151 +ABORTING_CONNECTION = 1152 +NET_PACKET_TOO_LARGE = 1153 +NET_READ_ERROR_FROM_PIPE = 1154 +NET_FCNTL_ERROR = 1155 +NET_PACKETS_OUT_OF_ORDER = 1156 +NET_UNCOMPRESS_ERROR = 1157 +NET_READ_ERROR = 1158 +NET_READ_INTERRUPTED = 1159 +NET_ERROR_ON_WRITE = 1160 +NET_WRITE_INTERRUPTED = 1161 +TOO_LONG_STRING = 1162 +TABLE_CANT_HANDLE_BLOB = 1163 +TABLE_CANT_HANDLE_AUTO_INCREMENT = 1164 +DELAYED_INSERT_TABLE_LOCKED = 1165 +WRONG_COLUMN_NAME = 1166 +WRONG_KEY_COLUMN = 1167 +WRONG_MRG_TABLE = 1168 +DUP_UNIQUE = 1169 +BLOB_KEY_WITHOUT_LENGTH = 1170 +PRIMARY_CANT_HAVE_NULL = 1171 +TOO_MANY_ROWS = 1172 +REQUIRES_PRIMARY_KEY = 1173 +NO_RAID_COMPILED = 1174 +UPDATE_WITHOUT_KEY_IN_SAFE_MODE = 1175 +KEY_DOES_NOT_EXITS = 1176 +CHECK_NO_SUCH_TABLE = 1177 +CHECK_NOT_IMPLEMENTED = 1178 +CANT_DO_THIS_DURING_AN_TRANSACTION = 1179 +ERROR_DURING_COMMIT = 1180 +ERROR_DURING_ROLLBACK = 1181 +ERROR_DURING_FLUSH_LOGS = 1182 +ERROR_DURING_CHECKPOINT = 1183 +NEW_ABORTING_CONNECTION = 1184 +DUMP_NOT_IMPLEMENTED = 1185 +FLUSH_MASTER_BINLOG_CLOSED = 1186 +INDEX_REBUILD = 1187 +MASTER = 1188 +MASTER_NET_READ = 1189 +MASTER_NET_WRITE = 1190 +FT_MATCHING_KEY_NOT_FOUND = 1191 +LOCK_OR_ACTIVE_TRANSACTION = 1192 +UNKNOWN_SYSTEM_VARIABLE = 1193 +CRASHED_ON_USAGE = 1194 +CRASHED_ON_REPAIR = 1195 +WARNING_NOT_COMPLETE_ROLLBACK = 1196 +TRANS_CACHE_FULL = 1197 +SLAVE_MUST_STOP = 1198 +SLAVE_NOT_RUNNING = 1199 +BAD_SLAVE = 1200 +MASTER_INFO = 1201 +SLAVE_THREAD = 1202 +TOO_MANY_USER_CONNECTIONS = 1203 +SET_CONSTANTS_ONLY = 1204 +LOCK_WAIT_TIMEOUT = 1205 +LOCK_TABLE_FULL = 1206 +READ_ONLY_TRANSACTION = 1207 +DROP_DB_WITH_READ_LOCK = 1208 +CREATE_DB_WITH_READ_LOCK = 1209 +WRONG_ARGUMENTS = 1210 +NO_PERMISSION_TO_CREATE_USER = 1211 +UNION_TABLES_IN_DIFFERENT_DIR = 1212 +LOCK_DEADLOCK = 1213 +TABLE_CANT_HANDLE_FT = 1214 +CANNOT_ADD_FOREIGN = 1215 +NO_REFERENCED_ROW = 1216 +ROW_IS_REFERENCED = 1217 +CONNECT_TO_MASTER = 1218 +QUERY_ON_MASTER = 1219 +ERROR_WHEN_EXECUTING_COMMAND = 1220 +WRONG_USAGE = 1221 +WRONG_NUMBER_OF_COLUMNS_IN_SELECT = 1222 +CANT_UPDATE_WITH_READLOCK = 1223 +MIXING_NOT_ALLOWED = 1224 +DUP_ARGUMENT = 1225 +USER_LIMIT_REACHED = 1226 +SPECIFIC_ACCESS_DENIED_ERROR = 1227 +LOCAL_VARIABLE = 1228 +GLOBAL_VARIABLE = 1229 +NO_DEFAULT = 1230 +WRONG_VALUE_FOR_VAR = 1231 +WRONG_TYPE_FOR_VAR = 1232 +VAR_CANT_BE_READ = 1233 +CANT_USE_OPTION_HERE = 1234 +NOT_SUPPORTED_YET = 1235 +MASTER_FATAL_ERROR_READING_BINLOG = 1236 +SLAVE_IGNORED_TABLE = 1237 +INCORRECT_GLOBAL_LOCAL_VAR = 1238 +WRONG_FK_DEF = 1239 +KEY_REF_DO_NOT_MATCH_TABLE_REF = 1240 +OPERAND_COLUMNS = 1241 +SUBQUERY_NO_1_ROW = 1242 +UNKNOWN_STMT_HANDLER = 1243 +CORRUPT_HELP_DB = 1244 +CYCLIC_REFERENCE = 1245 +AUTO_CONVERT = 1246 +ILLEGAL_REFERENCE = 1247 +DERIVED_MUST_HAVE_ALIAS = 1248 +SELECT_REDUCED = 1249 +TABLENAME_NOT_ALLOWED_HERE = 1250 +NOT_SUPPORTED_AUTH_MODE = 1251 +SPATIAL_CANT_HAVE_NULL = 1252 +COLLATION_CHARSET_MISMATCH = 1253 +SLAVE_WAS_RUNNING = 1254 +SLAVE_WAS_NOT_RUNNING = 1255 +TOO_BIG_FOR_UNCOMPRESS = 1256 +ZLIB_Z_MEM_ERROR = 1257 +ZLIB_Z_BUF_ERROR = 1258 +ZLIB_Z_DATA_ERROR = 1259 +CUT_VALUE_GROUP_CONCAT = 1260 +WARN_TOO_FEW_RECORDS = 1261 +WARN_TOO_MANY_RECORDS = 1262 +WARN_NULL_TO_NOTNULL = 1263 +WARN_DATA_OUT_OF_RANGE = 1264 +WARN_DATA_TRUNCATED = 1265 +WARN_USING_OTHER_HANDLER = 1266 +CANT_AGGREGATE_2COLLATIONS = 1267 +DROP_USER = 1268 +REVOKE_GRANTS = 1269 +CANT_AGGREGATE_3COLLATIONS = 1270 +CANT_AGGREGATE_NCOLLATIONS = 1271 +VARIABLE_IS_NOT_STRUCT = 1272 +UNKNOWN_COLLATION = 1273 +SLAVE_IGNORED_SSL_PARAMS = 1274 +SERVER_IS_IN_SECURE_AUTH_MODE = 1275 +WARN_FIELD_RESOLVED = 1276 +BAD_SLAVE_UNTIL_COND = 1277 +MISSING_SKIP_SLAVE = 1278 +UNTIL_COND_IGNORED = 1279 +WRONG_NAME_FOR_INDEX = 1280 +WRONG_NAME_FOR_CATALOG = 1281 +WARN_QC_RESIZE = 1282 +BAD_FT_COLUMN = 1283 +UNKNOWN_KEY_CACHE = 1284 +WARN_HOSTNAME_WONT_WORK = 1285 +UNKNOWN_STORAGE_ENGINE = 1286 +WARN_DEPRECATED_SYNTAX = 1287 +NON_UPDATABLE_TABLE = 1288 +FEATURE_DISABLED = 1289 +OPTION_PREVENTS_STATEMENT = 1290 +DUPLICATED_VALUE_IN_TYPE = 1291 +TRUNCATED_WRONG_VALUE = 1292 +TOO_MUCH_AUTO_TIMESTAMP_COLS = 1293 +INVALID_ON_UPDATE = 1294 +UNSUPPORTED_PS = 1295 +GET_ERRMSG = 1296 +GET_TEMPORARY_ERRMSG = 1297 +UNKNOWN_TIME_ZONE = 1298 +WARN_INVALID_TIMESTAMP = 1299 +INVALID_CHARACTER_STRING = 1300 +WARN_ALLOWED_PACKET_OVERFLOWED = 1301 +CONFLICTING_DECLARATIONS = 1302 +SP_NO_RECURSIVE_CREATE = 1303 +SP_ALREADY_EXISTS = 1304 +SP_DOES_NOT_EXIST = 1305 +SP_DROP_FAILED = 1306 +SP_STORE_FAILED = 1307 +SP_LILABEL_MISMATCH = 1308 +SP_LABEL_REDEFINE = 1309 +SP_LABEL_MISMATCH = 1310 +SP_UNINIT_VAR = 1311 +SP_BADSELECT = 1312 +SP_BADRETURN = 1313 +SP_BADSTATEMENT = 1314 +UPDATE_LOG_DEPRECATED_IGNORED = 1315 +UPDATE_LOG_DEPRECATED_TRANSLATED = 1316 +QUERY_INTERRUPTED = 1317 +SP_WRONG_NO_OF_ARGS = 1318 +SP_COND_MISMATCH = 1319 +SP_NORETURN = 1320 +SP_NORETURNEND = 1321 +SP_BAD_CURSOR_QUERY = 1322 +SP_BAD_CURSOR_SELECT = 1323 +SP_CURSOR_MISMATCH = 1324 +SP_CURSOR_ALREADY_OPEN = 1325 +SP_CURSOR_NOT_OPEN = 1326 +SP_UNDECLARED_VAR = 1327 +SP_WRONG_NO_OF_FETCH_ARGS = 1328 +SP_FETCH_NO_DATA = 1329 +SP_DUP_PARAM = 1330 +SP_DUP_VAR = 1331 +SP_DUP_COND = 1332 +SP_DUP_CURS = 1333 +SP_CANT_ALTER = 1334 +SP_SUBSELECT_NYI = 1335 +STMT_NOT_ALLOWED_IN_SF_OR_TRG = 1336 +SP_VARCOND_AFTER_CURSHNDLR = 1337 +SP_CURSOR_AFTER_HANDLER = 1338 +SP_CASE_NOT_FOUND = 1339 +FPARSER_TOO_BIG_FILE = 1340 +FPARSER_BAD_HEADER = 1341 +FPARSER_EOF_IN_COMMENT = 1342 +FPARSER_ERROR_IN_PARAMETER = 1343 +FPARSER_EOF_IN_UNKNOWN_PARAMETER = 1344 +VIEW_NO_EXPLAIN = 1345 +FRM_UNKNOWN_TYPE = 1346 +WRONG_OBJECT = 1347 +NONUPDATEABLE_COLUMN = 1348 +VIEW_SELECT_DERIVED = 1349 +VIEW_SELECT_CLAUSE = 1350 +VIEW_SELECT_VARIABLE = 1351 +VIEW_SELECT_TMPTABLE = 1352 +VIEW_WRONG_LIST = 1353 +WARN_VIEW_MERGE = 1354 +WARN_VIEW_WITHOUT_KEY = 1355 +VIEW_INVALID = 1356 +SP_NO_DROP_SP = 1357 +SP_GOTO_IN_HNDLR = 1358 +TRG_ALREADY_EXISTS = 1359 +TRG_DOES_NOT_EXIST = 1360 +TRG_ON_VIEW_OR_TEMP_TABLE = 1361 +TRG_CANT_CHANGE_ROW = 1362 +TRG_NO_SUCH_ROW_IN_TRG = 1363 +NO_DEFAULT_FOR_FIELD = 1364 +DIVISION_BY_ZERO = 1365 +TRUNCATED_WRONG_VALUE_FOR_FIELD = 1366 +ILLEGAL_VALUE_FOR_TYPE = 1367 +VIEW_NONUPD_CHECK = 1368 +VIEW_CHECK_FAILED = 1369 +PROCACCESS_DENIED_ERROR = 1370 +RELAY_LOG_FAIL = 1371 +PASSWD_LENGTH = 1372 +UNKNOWN_TARGET_BINLOG = 1373 +IO_ERR_LOG_INDEX_READ = 1374 +BINLOG_PURGE_PROHIBITED = 1375 +FSEEK_FAIL = 1376 +BINLOG_PURGE_FATAL_ERR = 1377 +LOG_IN_USE = 1378 +LOG_PURGE_UNKNOWN_ERR = 1379 +RELAY_LOG_INIT = 1380 +NO_BINARY_LOGGING = 1381 +RESERVED_SYNTAX = 1382 +WSAS_FAILED = 1383 +DIFF_GROUPS_PROC = 1384 +NO_GROUP_FOR_PROC = 1385 +ORDER_WITH_PROC = 1386 +LOGGING_PROHIBIT_CHANGING_OF = 1387 +NO_FILE_MAPPING = 1388 +WRONG_MAGIC = 1389 +PS_MANY_PARAM = 1390 +KEY_PART_0 = 1391 +VIEW_CHECKSUM = 1392 +VIEW_MULTIUPDATE = 1393 +VIEW_NO_INSERT_FIELD_LIST = 1394 +VIEW_DELETE_MERGE_VIEW = 1395 +CANNOT_USER = 1396 +XAER_NOTA = 1397 +XAER_INVAL = 1398 +XAER_RMFAIL = 1399 +XAER_OUTSIDE = 1400 +XAER_RMERR = 1401 +XA_RBROLLBACK = 1402 +NONEXISTING_PROC_GRANT = 1403 +PROC_AUTO_GRANT_FAIL = 1404 +PROC_AUTO_REVOKE_FAIL = 1405 +DATA_TOO_LONG = 1406 +SP_BAD_SQLSTATE = 1407 +STARTUP = 1408 +LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR = 1409 +CANT_CREATE_USER_WITH_GRANT = 1410 +WRONG_VALUE_FOR_TYPE = 1411 +TABLE_DEF_CHANGED = 1412 +SP_DUP_HANDLER = 1413 +SP_NOT_VAR_ARG = 1414 +SP_NO_RETSET = 1415 +CANT_CREATE_GEOMETRY_OBJECT = 1416 +FAILED_ROUTINE_BREAK_BINLOG = 1417 +BINLOG_UNSAFE_ROUTINE = 1418 +BINLOG_CREATE_ROUTINE_NEED_SUPER = 1419 +EXEC_STMT_WITH_OPEN_CURSOR = 1420 +STMT_HAS_NO_OPEN_CURSOR = 1421 +COMMIT_NOT_ALLOWED_IN_SF_OR_TRG = 1422 +NO_DEFAULT_FOR_VIEW_FIELD = 1423 +SP_NO_RECURSION = 1424 +TOO_BIG_SCALE = 1425 +TOO_BIG_PRECISION = 1426 +M_BIGGER_THAN_D = 1427 +WRONG_LOCK_OF_SYSTEM_TABLE = 1428 +CONNECT_TO_FOREIGN_DATA_SOURCE = 1429 +QUERY_ON_FOREIGN_DATA_SOURCE = 1430 +FOREIGN_DATA_SOURCE_DOESNT_EXIST = 1431 +FOREIGN_DATA_STRING_INVALID_CANT_CREATE = 1432 +FOREIGN_DATA_STRING_INVALID = 1433 +CANT_CREATE_FEDERATED_TABLE = 1434 +TRG_IN_WRONG_SCHEMA = 1435 +STACK_OVERRUN_NEED_MORE = 1436 +TOO_LONG_BODY = 1437 +WARN_CANT_DROP_DEFAULT_KEYCACHE = 1438 +TOO_BIG_DISPLAYWIDTH = 1439 +XAER_DUPID = 1440 +DATETIME_FUNCTION_OVERFLOW = 1441 +CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG = 1442 +VIEW_PREVENT_UPDATE = 1443 +PS_NO_RECURSION = 1444 +SP_CANT_SET_AUTOCOMMIT = 1445 +MALFORMED_DEFINER = 1446 +VIEW_FRM_NO_USER = 1447 +VIEW_OTHER_USER = 1448 +NO_SUCH_USER = 1449 +FORBID_SCHEMA_CHANGE = 1450 +ROW_IS_REFERENCED_2 = 1451 +NO_REFERENCED_ROW_2 = 1452 +SP_BAD_VAR_SHADOW = 1453 +TRG_NO_DEFINER = 1454 +OLD_FILE_FORMAT = 1455 +SP_RECURSION_LIMIT = 1456 +SP_PROC_TABLE_CORRUPT = 1457 +ERROR_LAST = 1457 + diff --git a/MySQLdb/MySQLdb/constants/FIELD_TYPE.py b/MySQLdb/MySQLdb/constants/FIELD_TYPE.py new file mode 100644 index 0000000..8a57b17 --- /dev/null +++ b/MySQLdb/MySQLdb/constants/FIELD_TYPE.py @@ -0,0 +1,37 @@ +"""MySQL FIELD_TYPE Constants + +These constants represent the various column (field) types that are +supported by MySQL. + +""" + +DECIMAL = 0 +TINY = 1 +SHORT = 2 +LONG = 3 +FLOAT = 4 +DOUBLE = 5 +NULL = 6 +TIMESTAMP = 7 +LONGLONG = 8 +INT24 = 9 +DATE = 10 +TIME = 11 +DATETIME = 12 +YEAR = 13 +NEWDATE = 14 +VARCHAR = 15 +BIT = 16 +NEWDECIMAL = 246 +ENUM = 247 +SET = 248 +TINY_BLOB = 249 +MEDIUM_BLOB = 250 +LONG_BLOB = 251 +BLOB = 252 +VAR_STRING = 253 +STRING = 254 +GEOMETRY = 255 + +CHAR = TINY +INTERVAL = ENUM diff --git a/MySQLdb/MySQLdb/constants/FLAG.py b/MySQLdb/MySQLdb/constants/FLAG.py new file mode 100644 index 0000000..00e6c7c --- /dev/null +++ b/MySQLdb/MySQLdb/constants/FLAG.py @@ -0,0 +1,23 @@ +"""MySQL FLAG Constants + +These flags are used along with the FIELD_TYPE to indicate various +properties of columns in a result set. + +""" + +NOT_NULL = 1 +PRI_KEY = 2 +UNIQUE_KEY = 4 +MULTIPLE_KEY = 8 +BLOB = 16 +UNSIGNED = 32 +ZEROFILL = 64 +BINARY = 128 +ENUM = 256 +AUTO_INCREMENT = 512 +TIMESTAMP = 1024 +SET = 2048 +NUM = 32768 +PART_KEY = 16384 +GROUP = 32768 +UNIQUE = 65536 diff --git a/MySQLdb/MySQLdb/constants/REFRESH.py b/MySQLdb/MySQLdb/constants/REFRESH.py new file mode 100644 index 0000000..4a08b94 --- /dev/null +++ b/MySQLdb/MySQLdb/constants/REFRESH.py @@ -0,0 +1,17 @@ +"""MySQL REFRESH Constants + +These constants seem to mostly deal with things internal to the +MySQL server. Forget you saw this. + +""" + +GRANT = 1 +LOG = 2 +TABLES = 4 +HOSTS = 8 +STATUS = 16 +THREADS = 32 +SLAVE = 64 +MASTER = 128 +READ_LOCK = 16384 +FAST = 32768 diff --git a/MySQLdb/MySQLdb/constants/__init__.py b/MySQLdb/MySQLdb/constants/__init__.py new file mode 100644 index 0000000..3da4a0e --- /dev/null +++ b/MySQLdb/MySQLdb/constants/__init__.py @@ -0,0 +1 @@ +__all__ = ['CR', 'FIELD_TYPE','CLIENT','REFRESH','ER','FLAG'] diff --git a/MySQLdb/MySQLdb/converters.py b/MySQLdb/MySQLdb/converters.py new file mode 100644 index 0000000..fbc24a1 --- /dev/null +++ b/MySQLdb/MySQLdb/converters.py @@ -0,0 +1,171 @@ +"""MySQLdb type conversion module + +This module handles all the type conversions for MySQL. If the default +type conversions aren't what you need, you can make your own. The +dictionary conversions maps some kind of type to a conversion function +which returns the corresponding value: + +Key: FIELD_TYPE.* (from MySQLdb.constants) + +Conversion function: + + Arguments: string + + Returns: Python object + +Key: Python type object (from types) or class + +Conversion function: + + Arguments: Python object of indicated type or class AND + conversion dictionary + + Returns: SQL literal value + + Notes: Most conversion functions can ignore the dictionary, but + it is a required parameter. It is necessary for converting + things like sequences and instances. + +Don't modify conversions if you can avoid it. Instead, make copies +(with the copy() method), modify the copies, and then pass them to +MySQL.connect(). + +""" + +from _mysql import string_literal, escape_sequence, escape_dict, escape, NULL +from constants import FIELD_TYPE, FLAG +from times import * +import types +import array + +try: + set +except NameError: + from sets import Set as set + +def Bool2Str(s, d): return str(int(s)) + +def Str2Set(s): + return set([ i for i in s.split(',') if i ]) + +def Set2Str(s, d): + return string_literal(','.join(s), d) + +def Thing2Str(s, d): + """Convert something into a string via str().""" + return str(s) + +def Unicode2Str(s, d): + """Convert a unicode object to a string using the default encoding. + This is only used as a placeholder for the real function, which + is connection-dependent.""" + return s.encode() + +Long2Int = Thing2Str + +def Float2Str(o, d): + return '%.15g' % o + +def None2NULL(o, d): + """Convert None to NULL.""" + return NULL # duh + +def Thing2Literal(o, d): + + """Convert something into a SQL string literal. If using + MySQL-3.23 or newer, string_literal() is a method of the + _mysql.MYSQL object, and this function will be overridden with + that method when the connection is created.""" + + return string_literal(o, d) + + +def Instance2Str(o, d): + + """ + + Convert an Instance to a string representation. If the __str__() + method produces acceptable output, then you don't need to add the + class to conversions; it will be handled by the default + converter. If the exact class is not found in d, it will use the + first class it can find for which o is an instance. + + """ + + if d.has_key(o.__class__): + return d[o.__class__](o, d) + cl = filter(lambda x,o=o: + type(x) is types.ClassType + and isinstance(o, x), d.keys()) + if not cl and hasattr(types, 'ObjectType'): + cl = filter(lambda x,o=o: + type(x) is types.TypeType + and isinstance(o, x) + and d[x] is not Instance2Str, + d.keys()) + if not cl: + return d[types.StringType](o,d) + d[o.__class__] = d[cl[0]] + return d[cl[0]](o, d) + +def char_array(s): + return array.array('c', s) + +def array2Str(o, d): + return Thing2Literal(o.tostring(), d) + +conversions = { + types.IntType: Thing2Str, + types.LongType: Long2Int, + types.FloatType: Float2Str, + types.NoneType: None2NULL, + types.TupleType: escape_sequence, + types.ListType: escape_sequence, + types.DictType: escape_dict, + types.InstanceType: Instance2Str, + array.ArrayType: array2Str, + types.StringType: Thing2Literal, # default + types.UnicodeType: Unicode2Str, + types.ObjectType: Instance2Str, + types.BooleanType: Bool2Str, + DateTimeType: DateTime2literal, + DateTimeDeltaType: DateTimeDelta2literal, + set: Set2Str, + FIELD_TYPE.TINY: int, + FIELD_TYPE.SHORT: int, + FIELD_TYPE.LONG: long, + FIELD_TYPE.FLOAT: float, + FIELD_TYPE.DOUBLE: float, + FIELD_TYPE.DECIMAL: float, + FIELD_TYPE.NEWDECIMAL: float, + FIELD_TYPE.LONGLONG: long, + FIELD_TYPE.INT24: int, + FIELD_TYPE.YEAR: int, + FIELD_TYPE.SET: Str2Set, + FIELD_TYPE.TIMESTAMP: mysql_timestamp_converter, + FIELD_TYPE.DATETIME: DateTime_or_None, + FIELD_TYPE.TIME: TimeDelta_or_None, + FIELD_TYPE.DATE: Date_or_None, + FIELD_TYPE.BLOB: [ + (FLAG.BINARY, str), + ], + FIELD_TYPE.STRING: [ + (FLAG.BINARY, str), + ], + FIELD_TYPE.VAR_STRING: [ + (FLAG.BINARY, str), + ], + FIELD_TYPE.VARCHAR: [ + (FLAG.BINARY, str), + ], + } + +try: + from decimal import Decimal + conversions[FIELD_TYPE.DECIMAL] = Decimal + conversions[FIELD_TYPE.NEWDECIMAL] = Decimal +except ImportError: + pass + + + diff --git a/MySQLdb/MySQLdb/cursors.py b/MySQLdb/MySQLdb/cursors.py new file mode 100644 index 0000000..920bc19 --- /dev/null +++ b/MySQLdb/MySQLdb/cursors.py @@ -0,0 +1,506 @@ +"""MySQLdb Cursors + +This module implements Cursors of various types for MySQLdb. By +default, MySQLdb uses the Cursor class. + +""" + +import re + +restr = (r"\svalues\s*" + r"(\(((?<!\\)'[^\)]*?\)[^\)]*(?<!\\)?'" + r"|[^\(\)]|" + r"(?:\([^\)]*\))" + r")+\))") + +insert_values= re.compile(restr) +from _mysql_exceptions import Warning, Error, InterfaceError, DataError, \ + DatabaseError, OperationalError, IntegrityError, InternalError, \ + NotSupportedError, ProgrammingError + + +class BaseCursor(object): + + """A base for Cursor classes. Useful attributes: + + description + A tuple of DB API 7-tuples describing the columns in + the last executed query; see PEP-249 for details. + + description_flags + Tuple of column flags for last query, one entry per column + in the result set. Values correspond to those in + MySQLdb.constants.FLAG. See MySQL documentation (C API) + for more information. Non-standard extension. + + arraysize + default number of rows fetchmany() will fetch + + """ + + from _mysql_exceptions import MySQLError, Warning, Error, InterfaceError, \ + DatabaseError, DataError, OperationalError, IntegrityError, \ + InternalError, ProgrammingError, NotSupportedError + + _defer_warnings = False + + def __init__(self, connection): + from weakref import proxy + + self.connection = proxy(connection) + self.description = None + self.description_flags = None + self.rowcount = -1 + self.arraysize = 1 + self._executed = None + self.lastrowid = None + self.messages = [] + self.errorhandler = connection.errorhandler + self._result = None + self._warnings = 0 + self._info = None + self.rownumber = None + + def __del__(self): + self.close() + self.errorhandler = None + self._result = None + + def close(self): + """Close the cursor. No further queries will be possible.""" + if not self.connection: return + while self.nextset(): pass + self.connection = None + + def _check_executed(self): + if not self._executed: + self.errorhandler(self, ProgrammingError, "execute() first") + + def _warning_check(self): + from warnings import warn + if self._warnings: + warnings = self._get_db().show_warnings() + if warnings: + # This is done in two loops in case + # Warnings are set to raise exceptions. + for w in warnings: + self.messages.append((self.Warning, w)) + for w in warnings: + warn(w[-1], self.Warning, 3) + elif self._info: + self.messages.append((self.Warning, self._info)) + warn(self._info, self.Warning, 3) + + def nextset(self): + """Advance to the next result set. + + Returns None if there are no more result sets. + """ + if self._executed: + self.fetchall() + del self.messages[:] + + db = self._get_db() + nr = db.next_result() + if nr == -1: + return None + self._do_get_result() + self._post_get_result() + self._warning_check() + return 1 + + def _post_get_result(self): pass + + def _do_get_result(self): + db = self._get_db() + self._result = self._get_result() + self.rowcount = db.affected_rows() + self.rownumber = 0 + self.description = self._result and self._result.describe() or None + self.description_flags = self._result and self._result.field_flags() or None + self.lastrowid = db.insert_id() + self._warnings = db.warning_count() + self._info = db.info() + + def setinputsizes(self, *args): + """Does nothing, required by DB API.""" + + def setoutputsizes(self, *args): + """Does nothing, required by DB API.""" + + def _get_db(self): + if not self.connection: + self.errorhandler(self, ProgrammingError, "cursor closed") + return self.connection + + def execute(self, query, args=None): + + """Execute a query. + + query -- string, query to execute on server + args -- optional sequence or mapping, parameters to use with query. + + Note: If args is a sequence, then %s must be used as the + parameter placeholder in the query. If a mapping is used, + %(key)s must be used as the placeholder. + + Returns long integer rows affected, if any + + """ + from types import ListType, TupleType + from sys import exc_info + del self.messages[:] + db = self._get_db() + charset = db.character_set_name() + if isinstance(query, unicode): + query = query.encode(charset) + if args is not None: + query = query % db.literal(args) + try: + r = self._query(query) + except TypeError, m: + if m.args[0] in ("not enough arguments for format string", + "not all arguments converted"): + self.messages.append((ProgrammingError, m.args[0])) + self.errorhandler(self, ProgrammingError, m.args[0]) + else: + self.messages.append((TypeError, m)) + self.errorhandler(self, TypeError, m) + except: + exc, value, tb = exc_info() + del tb + self.messages.append((exc, value)) + self.errorhandler(self, exc, value) + self._executed = query + if not self._defer_warnings: self._warning_check() + return r + + def executemany(self, query, args): + + """Execute a multi-row query. + + query -- string, query to execute on server + + args + + Sequence of sequences or mappings, parameters to use with + query. + + Returns long integer rows affected, if any. + + This method improves performance on multiple-row INSERT and + REPLACE. Otherwise it is equivalent to looping over args with + execute(). + + """ + del self.messages[:] + db = self._get_db() + if not args: return + charset = db.character_set_name() + if isinstance(query, unicode): query = query.encode(charset) + m = insert_values.search(query) + if not m: + r = 0 + for a in args: + r = r + self.execute(query, a) + return r + p = m.start(1) + e = m.end(1) + qv = m.group(1) + try: + q = [ qv % db.literal(a) for a in args ] + except TypeError, msg: + if msg.args[0] in ("not enough arguments for format string", + "not all arguments converted"): + self.messages.append((ProgrammingError, msg.args[0])) + self.errorhandler(self, ProgrammingError, msg.args[0]) + else: + self.messages.append((TypeError, msg)) + self.errorhandler(self, TypeError, msg) + except: + from sys import exc_info + exc, value, tb = exc_info() + del tb + self.errorhandler(self, exc, value) + r = self._query('\n'.join([query[:p], ',\n'.join(q), query[e:]])) + if not self._defer_warnings: self._warning_check() + return r + + def callproc(self, procname, args=()): + + """Execute stored procedure procname with args + + procname -- string, name of procedure to execute on server + + args -- Sequence of parameters to use with procedure + + Returns the original args. + + Compatibility warning: PEP-249 specifies that any modified + parameters must be returned. This is currently impossible + as they are only available by storing them in a server + variable and then retrieved by a query. Since stored + procedures return zero or more result sets, there is no + reliable way to get at OUT or INOUT parameters via callproc. + The server variables are named @_procname_n, where procname + is the parameter above and n is the position of the parameter + (from zero). Once all result sets generated by the procedure + have been fetched, you can issue a SELECT @_procname_0, ... + query using .execute() to get any OUT or INOUT values. + + Compatibility warning: The act of calling a stored procedure + itself creates an empty result set. This appears after any + result sets generated by the procedure. This is non-standard + behavior with respect to the DB-API. Be sure to use nextset() + to advance through all result sets; otherwise you may get + disconnected. + """ + + from types import UnicodeType + db = self._get_db() + charset = db.character_set_name() + for index, arg in enumerate(args): + q = "SET @_%s_%d=%s" % (procname, index, + db.literal(arg)) + if isinstance(q, unicode): + q = q.encode(charset) + self._query(q) + self.nextset() + + q = "CALL %s(%s)" % (procname, + ','.join(['@_%s_%d' % (procname, i) + for i in range(len(args))])) + if type(q) is UnicodeType: + q = q.encode(charset) + self._query(q) + self._executed = q + if not self._defer_warnings: self._warning_check() + return args + + def _do_query(self, q): + db = self._get_db() + self._last_executed = q + db.query(q) + self._do_get_result() + return self.rowcount + + def _query(self, q): return self._do_query(q) + + def _fetch_row(self, size=1): + if not self._result: + return () + return self._result.fetch_row(size, self._fetch_type) + + def __iter__(self): + return iter(self.fetchone, None) + + Warning = Warning + Error = Error + InterfaceError = InterfaceError + DatabaseError = DatabaseError + DataError = DataError + OperationalError = OperationalError + IntegrityError = IntegrityError + InternalError = InternalError + ProgrammingError = ProgrammingError + NotSupportedError = NotSupportedError + + +class CursorStoreResultMixIn(object): + + """This is a MixIn class which causes the entire result set to be + stored on the client side, i.e. it uses mysql_store_result(). If the + result set can be very large, consider adding a LIMIT clause to your + query, or using CursorUseResultMixIn instead.""" + + def _get_result(self): return self._get_db().store_result() + + def _query(self, q): + rowcount = self._do_query(q) + self._post_get_result() + return rowcount + + def _post_get_result(self): + self._rows = self._fetch_row(0) + self._result = None + + def fetchone(self): + """Fetches a single row from the cursor. None indicates that + no more rows are available.""" + self._check_executed() + if self.rownumber >= len(self._rows): return None + result = self._rows[self.rownumber] + self.rownumber = self.rownumber+1 + return result + + def fetchmany(self, size=None): + """Fetch up to size rows from the cursor. Result set may be smaller + than size. If size is not defined, cursor.arraysize is used.""" + self._check_executed() + end = self.rownumber + (size or self.arraysize) + result = self._rows[self.rownumber:end] + self.rownumber = min(end, len(self._rows)) + return result + + def fetchall(self): + """Fetchs all available rows from the cursor.""" + self._check_executed() + if self.rownumber: + result = self._rows[self.rownumber:] + else: + result = self._rows + self.rownumber = len(self._rows) + return result + + def scroll(self, value, mode='relative'): + """Scroll the cursor in the result set to a new position according + to mode. + + If mode is 'relative' (default), value is taken as offset to + the current position in the result set, if set to 'absolute', + value states an absolute target position.""" + self._check_executed() + if mode == 'relative': + r = self.rownumber + value + elif mode == 'absolute': + r = value + else: + self.errorhandler(self, ProgrammingError, + "unknown scroll mode %s" % `mode`) + if r < 0 or r >= len(self._rows): + self.errorhandler(self, IndexError, "out of range") + self.rownumber = r + + def __iter__(self): + self._check_executed() + result = self.rownumber and self._rows[self.rownumber:] or self._rows + return iter(result) + + +class CursorUseResultMixIn(object): + + """This is a MixIn class which causes the result set to be stored + in the server and sent row-by-row to client side, i.e. it uses + mysql_use_result(). You MUST retrieve the entire result set and + close() the cursor before additional queries can be peformed on + the connection.""" + + _defer_warnings = True + + def _get_result(self): return self._get_db().use_result() + + def fetchone(self): + """Fetches a single row from the cursor.""" + self._check_executed() + r = self._fetch_row(1) + if not r: + self._warning_check() + return None + self.rownumber = self.rownumber + 1 + return r[0] + + def fetchmany(self, size=None): + """Fetch up to size rows from the cursor. Result set may be smaller + than size. If size is not defined, cursor.arraysize is used.""" + self._check_executed() + r = self._fetch_row(size or self.arraysize) + self.rownumber = self.rownumber + len(r) + if not r: + self._warning_check() + return r + + def fetchall(self): + """Fetchs all available rows from the cursor.""" + self._check_executed() + r = self._fetch_row(0) + self.rownumber = self.rownumber + len(r) + self._warning_check() + return r + + def __iter__(self): + return self + + def next(self): + row = self.fetchone() + if row is None: + raise StopIteration + return row + + +class CursorTupleRowsMixIn(object): + + """This is a MixIn class that causes all rows to be returned as tuples, + which is the standard form required by DB API.""" + + _fetch_type = 0 + + +class CursorDictRowsMixIn(object): + + """This is a MixIn class that causes all rows to be returned as + dictionaries. This is a non-standard feature.""" + + _fetch_type = 1 + + def fetchoneDict(self): + """Fetch a single row as a dictionary. Deprecated: + Use fetchone() instead. Will be removed in 1.3.""" + from warnings import warn + warn("fetchoneDict() is non-standard and will be removed in 1.3", + DeprecationWarning, 2) + return self.fetchone() + + def fetchmanyDict(self, size=None): + """Fetch several rows as a list of dictionaries. Deprecated: + Use fetchmany() instead. Will be removed in 1.3.""" + from warnings import warn + warn("fetchmanyDict() is non-standard and will be removed in 1.3", + DeprecationWarning, 2) + return self.fetchmany(size) + + def fetchallDict(self): + """Fetch all available rows as a list of dictionaries. Deprecated: + Use fetchall() instead. Will be removed in 1.3.""" + from warnings import warn + warn("fetchallDict() is non-standard and will be removed in 1.3", + DeprecationWarning, 2) + return self.fetchall() + + +class CursorOldDictRowsMixIn(CursorDictRowsMixIn): + + """This is a MixIn class that returns rows as dictionaries with + the same key convention as the old Mysqldb (MySQLmodule). Don't + use this.""" + + _fetch_type = 2 + + +class Cursor(CursorStoreResultMixIn, CursorTupleRowsMixIn, + BaseCursor): + + """This is the standard Cursor class that returns rows as tuples + and stores the result set in the client.""" + + +class DictCursor(CursorStoreResultMixIn, CursorDictRowsMixIn, + BaseCursor): + + """This is a Cursor class that returns rows as dictionaries and + stores the result set in the client.""" + + +class SSCursor(CursorUseResultMixIn, CursorTupleRowsMixIn, + BaseCursor): + + """This is a Cursor class that returns rows as tuples and stores + the result set in the server.""" + + +class SSDictCursor(CursorUseResultMixIn, CursorDictRowsMixIn, + BaseCursor): + + """This is a Cursor class that returns rows as dictionaries and + stores the result set in the server.""" + + diff --git a/MySQLdb/MySQLdb/times.py b/MySQLdb/MySQLdb/times.py new file mode 100644 index 0000000..bb1c75c --- /dev/null +++ b/MySQLdb/MySQLdb/times.py @@ -0,0 +1,99 @@ +"""times module + +This module provides some Date and Time classes for dealing with MySQL data. + +Use Python datetime module to handle date and time columns.""" + +from time import localtime +from datetime import date, datetime, time, timedelta +from _mysql import string_literal + +Date = date +Time = time +TimeDelta = timedelta +Timestamp = datetime + +DateTimeDeltaType = timedelta +DateTimeType = datetime + +def DateFromTicks(ticks): + """Convert UNIX ticks into a date instance.""" + return date(*localtime(ticks)[:3]) + +def TimeFromTicks(ticks): + """Convert UNIX ticks into a time instance.""" + return time(*localtime(ticks)[3:6]) + +def TimestampFromTicks(ticks): + """Convert UNIX ticks into a datetime instance.""" + return datetime(*localtime(ticks)[:6]) + +format_TIME = format_DATE = str + +def format_TIMEDELTA(v): + seconds = int(v.seconds) % 60 + minutes = int(v.seconds / 60) % 60 + hours = int(v.seconds / 3600) % 24 + return '%d %d:%d:%d' % (v.days, hours, minutes, seconds) + +def format_TIMESTAMP(d): + return d.strftime("%Y-%m-%d %H:%M:%S") + + +def DateTime_or_None(s): + if ' ' in s: + sep = ' ' + elif 'T' in s: + sep = 'T' + else: + return Date_or_None(s) + + try: + d, t = s.split(sep, 1) + return datetime(*[ int(x) for x in d.split('-')+t.split(':') ]) + except: + return Date_or_None(s) + +def TimeDelta_or_None(s): + from math import modf + try: + h, m, s = s.split(':') + td = timedelta(hours=int(h), minutes=int(m), seconds=int(float(s)), + microseconds=int(modf(float(s))[0]*1000000)) + if h < 0: + return -td + else: + return td + except: + return None + +def Time_or_None(s): + from math import modf + try: + h, m, s = s.split(':') + return time(hour=int(h), minute=int(m), second=int(float(s)), + microsecond=int(modf(float(s))[0]*1000000)) + except: + return None + +def Date_or_None(s): + try: return date(*[ int(x) for x in s.split('-',2)]) + except: return None + +def DateTime2literal(d, c): + """Format a DateTime object as an ISO timestamp.""" + return string_literal(format_TIMESTAMP(d),c) + +def DateTimeDelta2literal(d, c): + """Format a DateTimeDelta object as a time.""" + return string_literal(format_TIMEDELTA(d),c) + +def mysql_timestamp_converter(s): + """Convert a MySQL TIMESTAMP to a Timestamp object.""" + # MySQL>4.1 returns TIMESTAMP in the same format as DATETIME + if s[4] == '-': return DateTime_or_None(s) + s = s + "0"*(14-len(s)) # padding + parts = map(int, filter(None, (s[:4],s[4:6],s[6:8], + s[8:10],s[10:12],s[12:14]))) + try: return Timestamp(*parts) + except: return None diff --git a/MySQLdb/README b/MySQLdb/README new file mode 100644 index 0000000..8b53277 --- /dev/null +++ b/MySQLdb/README @@ -0,0 +1,253 @@ +==================== +MySQLdb Installation +==================== + +.. contents:: +.. + +Prerequisites +------------- + ++ Python 2.3.4 or higher + + * http://www.python.org/ + + * Versions lower than 2.3 WON'T WORK. + + * 2.4 is the primary test environment. + + * Red Hat Linux: + + - Make sure you have the Python development headers and libraries + (python-devel). + ++ setuptools + + * http://pypi.python.org/pypi/setuptools + ++ MySQL 3.23.32 or higher + + * http://www.mysql.com/downloads/ + + * Versions lower than 3.22 definitely WON'T WORK. + + * Versions lower than 3.22.19 might not work. + + * MySQL-3.22 might work but isn't supported anymore. It's very old. + + * MySQL-3.23 ought to work, but it's pretty elderly. + + * MySQL-4.0 is supported, but not tested and slightly discouraged. + + * MySQL-4.1 is supported. The prepared statements API is not + supported, and won't be until MySQLdb-1.3 or 2.0, if ever. + + * MySQL-5.0 is supported and tested, including stored procedures. + + * MySQL-5.1 is supported (currently a release candidate) but untested. + It should work. + + * MySQL-6.0 is sorta-kinda-supported (currently alpha) but untested. + It should work. + + * Drizzle <https://launchpad.net/drizzle> is a fork of MySQL. So far + the C API looks really similar except everything is renamed. + Drizzle support probably won't happen in 1.2. There may be have to + be an entirely different module, but still using DB-API. + + * MaxDB, formerly known as SAP DB (and maybe Adabas D?), is a + completely different animal. Use the sapdb.sql module that comes + with MaxDB. + + * Red Hat Linux packages: + + - mysql-devel to compile + + - mysql and/or mysql-devel to run + + * MySQL.com RPM packages: + + - MySQL-devel to compile + + - MySQL-shared if you want to use their shared + library. Otherwise you'll get a statically-linked module, + which may or may not be what you want. + + - MySQL-shared to run if you compiled with MySQL-shared installed + + * Transactions (particularly InnoDB tables) are supported for + MySQL-3.23 and up. You may need a special package from your vendor + with this support turned on. + ++ zlib + + * Required for MySQL-3.23 and newer. + + * Red Hat Linux + + - zlib-devel to compile + + - zlib to run + ++ openssl + + * May be needed for MySQL-4.0 or newer, depending on compilation + options. If you need it, you probably already have it. + + - you may need openssl-devel on some platforms + ++ C compiler + + * Most free software-based systems already have this, usually gcc. + + * Most commercial UNIX platforms also come with a C compiler, or + you can also use gcc. + + * If you have some Windows flavor, you usually have to pay extra + for this, or you can use Cygwin_. + +.. _Cygwin: http://www.cygwin.com/ + + +Building and installing +----------------------- + +The setup.py script uses mysql_config to find all compiler and linker +options, and should work as is on any POSIX-like platform, so long as +mysql_config is in your path. + +Depending on which version of MySQL you have, you may have the option +of using three different client libraries. To select the client library, +edit the [options] section of site.cfg: + + embedded + use embedded server library (libmysqld) if True; otherwise use + one of the client libraries (default). + + threadsafe + thread-safe client library (libmysqlclient_r) if True (default); + otherwise use non-thread-safe (libmysqlclient). You should + always use the thread-safe library if you have the option; + otherwise you *may* have problems. + + static + if True, try to link against a static library; otherwise link + against dynamic libraries (default). You may need static linking + to use the embedded server. + + +Finally, putting it together:: + + $ tar xfz MySQL-python-1.2.1.tar.gz + $ cd MySQL-python-1.2.1 + $ # edit site.cfg if necessary + $ python setup.py build + $ sudo python setup.py install # or su first + + +Windows +....... + +I don't do Windows. However if someone provides me with a package for +Windows, I'll make it available. Don't ask me for help with Windows +because I can't help you. + +Generally, though, running setup.py is similar to above:: + + C:\...> python setup.py install + C:\...> python setup.py bdist_wininst + +The latter example should build a Windows installer package, if you +have the correct tools. In any event, you *must* have a C compiler. +Additionally, you have to set an environment variable (mysqlroot) +which is the path to your MySQL installation. In theory, it would be +possible to get this information out of the registry, but like I said, +I don't do Windows, but I'll accept a patch that does this. + +On Windows, you will definitely have to edit site.cfg since there is +no mysql_config in the MySQL package. + + +Zope +.... + +If you are using a binary package of Zope, you need run setup.py with +the python executable that came with Zope. Otherwise, you'll install +into the wrong Python tree and Zope (ZMySQLDA) will not be able to +find _mysql. + + +Binary Packages +--------------- + +I don't plan to make binary packages any more. However, if someone +contributes one, I will make it available. Several OS vendors have +their own packages available. + + +RPMs +.... + +If you prefer to install RPMs, you can use the bdist_rpm command with +setup.py. This only builds the RPM; it does not install it. You may +want to use the --python=XXX option, where XXX is the name of the +Python executable, i.e. python, python2, python2.4; the default is +python. Using this will incorporate the Python executable name into +the package name for the RPM so you have install the package multiple +times if you need to support more than one version of Python. You can +also set this in setup.cfg. + + +Red Hat Linux +............. + +MySQL-python is pre-packaged in Red Hat Linux 7.x and newer. This +includes Fedora Core and Red Hat Enterprise Linux. You can also +build your own RPM packages as described above. + + +Debian GNU/Linux +................ + +Packaged as `python-mysqldb`_:: + + # apt-get install python-mysqldb + +Or use Synaptic. + +.. _`python-mysqldb`: http://packages.debian.org/python-mysqldb + + +Ubuntu +...... + +Same as with Debian. + + +Gentoo Linux +............ + +Packaged as `mysql-python`_. :: + + # emerge sync + # emerge mysql-python + # emerge zmysqlda # if you use Zope + +.. _`mysql-python`: http://packages.gentoo.org/search/?sstring=mysql-python + + +BSD +... + +MySQL-python is a ported package in FreeBSD, NetBSD, and OpenBSD, +although the name may vary to match OS conventions. + + +License +------- + +GPL or the original license based on Python 1.5.2's license. + + +:Author: Andy Dustman <andy@dustman.net> +:Revision: $Id$ diff --git a/MySQLdb/_mysql.c b/MySQLdb/_mysql.c new file mode 100644 index 0000000..7b09335 --- /dev/null +++ b/MySQLdb/_mysql.c @@ -0,0 +1,2888 @@ +/* +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. Alternatively, you may use the original license +reproduced below. + +Copyright 1999 by Comstar.net, Inc., Atlanta, GA, US. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Comstar.net, Inc. +or COMSTAR not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior permission. + +COMSTAR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL COMSTAR BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF +USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "pymemcompat.h" +#include "structmember.h" +#if defined(_WIN32) || defined(_WIN64) || defined(__WIN32__) || defined(WIN32) || defined(MS_WIN32) +#include <windows.h> +#include <config-win.h> +#else +#include "my_config.h" +#endif +#ifndef uint +#define uint unsigned int +#endif +#include "mysql.h" +#include "mysqld_error.h" +#include "errmsg.h" + +#if PY_VERSION_HEX < 0x02020000 +# define MyTuple_Resize(t,n,d) _PyTuple_Resize(t, n, d) +# define MyMember(a,b,c,d,e) {a,b,c,d} +# define MyMemberlist(x) struct memberlist x +# define MyAlloc(s,t) PyObject_New(s,&t) +# define MyFree(o) PyObject_Del(o) +#else +# define MyTuple_Resize(t,n,d) _PyTuple_Resize(t, n) +# define MyMember(a,b,c,d,e) {a,b,c,d,e} +# define MyMemberlist(x) struct PyMemberDef x +# define MyAlloc(s,t) (s *) t.tp_alloc(&t,0) +# define MyFree(ob) ob->ob_type->tp_free((PyObject *)ob) +#endif + +#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) +typedef int Py_ssize_t; +#define PY_SSIZE_T_MAX INT_MAX +#define PY_SSIZE_T_MIN INT_MIN +#endif + +static PyObject *_mysql_MySQLError; +static PyObject *_mysql_Warning; +static PyObject *_mysql_Error; +static PyObject *_mysql_DatabaseError; +static PyObject *_mysql_InterfaceError; +static PyObject *_mysql_DataError; +static PyObject *_mysql_OperationalError; +static PyObject *_mysql_IntegrityError; +static PyObject *_mysql_InternalError; +static PyObject *_mysql_ProgrammingError; +static PyObject *_mysql_NotSupportedError; + +typedef struct { + PyObject_HEAD + MYSQL connection; + int open; + PyObject *converter; +} _mysql_ConnectionObject; + +#define check_connection(c) if (!(c->open)) return _mysql_Exception(c) +#define result_connection(r) ((_mysql_ConnectionObject *)r->conn) +#define check_result_connection(r) check_connection(result_connection(r)) + +extern PyTypeObject _mysql_ConnectionObject_Type; + +typedef struct { + PyObject_HEAD + PyObject *conn; + MYSQL_RES *result; + int nfields; + int use; + PyObject *converter; +} _mysql_ResultObject; + +extern PyTypeObject _mysql_ResultObject_Type; + +static int _mysql_server_init_done = 0; +#if MYSQL_VERSION_ID >= 40000 +#define check_server_init(x) if (!_mysql_server_init_done) { if (mysql_server_init(0, NULL, NULL)) { _mysql_Exception(NULL); return x; } else { _mysql_server_init_done = 1;} } +#else +#define check_server_init(x) if (!_mysql_server_init_done) _mysql_server_init_done = 1 +#endif + +PyObject * +_mysql_Exception(_mysql_ConnectionObject *c) +{ + PyObject *t, *e; + int merr; + + if (!(t = PyTuple_New(2))) return NULL; + if (!_mysql_server_init_done) { + e = _mysql_InternalError; + PyTuple_SET_ITEM(t, 0, PyInt_FromLong(-1L)); + PyTuple_SET_ITEM(t, 1, PyString_FromString("server not initialized")); + PyErr_SetObject(e, t); + Py_DECREF(t); + return NULL; + } + merr = mysql_errno(&(c->connection)); + if (!merr) + e = _mysql_InterfaceError; + else if (merr > CR_MAX_ERROR) { + PyTuple_SET_ITEM(t, 0, PyInt_FromLong(-1L)); + PyTuple_SET_ITEM(t, 1, PyString_FromString("error totally whack")); + PyErr_SetObject(_mysql_InterfaceError, t); + Py_DECREF(t); + return NULL; + } + else switch (merr) { + case CR_COMMANDS_OUT_OF_SYNC: + case ER_DB_CREATE_EXISTS: + case ER_SYNTAX_ERROR: + case ER_PARSE_ERROR: + case ER_NO_SUCH_TABLE: + case ER_WRONG_DB_NAME: + case ER_WRONG_TABLE_NAME: + case ER_FIELD_SPECIFIED_TWICE: + case ER_INVALID_GROUP_FUNC_USE: + case ER_UNSUPPORTED_EXTENSION: + case ER_TABLE_MUST_HAVE_COLUMNS: +#ifdef ER_CANT_DO_THIS_DURING_AN_TRANSACTION + case ER_CANT_DO_THIS_DURING_AN_TRANSACTION: +#endif + e = _mysql_ProgrammingError; + break; +#ifdef WARN_DATA_TRUNCATED + case WARN_DATA_TRUNCATED: +#ifdef WARN_NULL_TO_NOTNULL + case WARN_NULL_TO_NOTNULL: +#endif +#ifdef ER_WARN_DATA_OUT_OF_RANGE + case ER_WARN_DATA_OUT_OF_RANGE: +#endif +#ifdef ER_NO_DEFAULT + case ER_NO_DEFAULT: +#endif +#ifdef ER_PRIMARY_CANT_HAVE_NULL + case ER_PRIMARY_CANT_HAVE_NULL: +#endif +#ifdef ER_DATA_TOO_LONG + case ER_DATA_TOO_LONG: +#endif +#ifdef ER_DATETIME_FUNCTION_OVERFLOW + case ER_DATETIME_FUNCTION_OVERFLOW: +#endif + e = _mysql_DataError; + break; +#endif + case ER_DUP_ENTRY: +#ifdef ER_DUP_UNIQUE + case ER_DUP_UNIQUE: +#endif +#ifdef ER_NO_REFERENCED_ROW + case ER_NO_REFERENCED_ROW: +#endif +#ifdef ER_NO_REFERENCED_ROW_2 + case ER_NO_REFERENCED_ROW_2: +#endif +#ifdef ER_ROW_IS_REFERENCED + case ER_ROW_IS_REFERENCED: +#endif +#ifdef ER_ROW_IS_REFERENCED_2 + case ER_ROW_IS_REFERENCED_2: +#endif +#ifdef ER_CANNOT_ADD_FOREIGN + case ER_CANNOT_ADD_FOREIGN: +#endif + e = _mysql_IntegrityError; + break; +#ifdef ER_WARNING_NOT_COMPLETE_ROLLBACK + case ER_WARNING_NOT_COMPLETE_ROLLBACK: +#endif +#ifdef ER_NOT_SUPPORTED_YET + case ER_NOT_SUPPORTED_YET: +#endif +#ifdef ER_FEATURE_DISABLED + case ER_FEATURE_DISABLED: +#endif +#ifdef ER_UNKNOWN_STORAGE_ENGINE + case ER_UNKNOWN_STORAGE_ENGINE: +#endif + e = _mysql_NotSupportedError; + break; + default: + if (merr < 1000) + e = _mysql_InternalError; + else + e = _mysql_OperationalError; + break; + } + PyTuple_SET_ITEM(t, 0, PyInt_FromLong((long)merr)); + PyTuple_SET_ITEM(t, 1, PyString_FromString(mysql_error(&(c->connection)))); + PyErr_SetObject(e, t); + Py_DECREF(t); + return NULL; +} + +static char _mysql_server_init__doc__[] = +"Initialize embedded server. If this client is not linked against\n\ +the embedded server library, this function does nothing.\n\ +\n\ +args -- sequence of command-line arguments\n\ +groups -- sequence of groups to use in defaults files\n\ +"; + +static PyObject *_mysql_server_init( + PyObject *self, + PyObject *args, + PyObject *kwargs) { + static char *kwlist[] = {"args", "groups", NULL}; + char **cmd_args_c=NULL, **groups_c=NULL, *s; + int cmd_argc=0, i, groupc; + PyObject *cmd_args=NULL, *groups=NULL, *ret=NULL, *item; + + if (_mysql_server_init_done) { + PyErr_SetString(_mysql_ProgrammingError, + "already initialized"); + return NULL; + } + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO", kwlist, + &cmd_args, &groups)) + return NULL; + +#if MYSQL_VERSION_ID >= 40000 + if (cmd_args) { + if (!PySequence_Check(cmd_args)) { + PyErr_SetString(PyExc_TypeError, + "args must be a sequence"); + goto finish; + } + cmd_argc = PySequence_Size(cmd_args); + if (cmd_argc == -1) { + PyErr_SetString(PyExc_TypeError, + "args could not be sized"); + goto finish; + } + cmd_args_c = (char **) PyMem_Malloc(cmd_argc*sizeof(char *)); + for (i=0; i< cmd_argc; i++) { + item = PySequence_GetItem(cmd_args, i); + s = PyString_AsString(item); + Py_DECREF(item); + if (!s) { + PyErr_SetString(PyExc_TypeError, + "args must contain strings"); + goto finish; + } + cmd_args_c[i] = s; + } + } + if (groups) { + if (!PySequence_Check(groups)) { + PyErr_SetString(PyExc_TypeError, + "groups must be a sequence"); + goto finish; + } + groupc = PySequence_Size(groups); + if (groupc == -1) { + PyErr_SetString(PyExc_TypeError, + "groups could not be sized"); + goto finish; + } + groups_c = (char **) PyMem_Malloc((1+groupc)*sizeof(char *)); + for (i=0; i< groupc; i++) { + item = PySequence_GetItem(groups, i); + s = PyString_AsString(item); + Py_DECREF(item); + if (!s) { + PyErr_SetString(PyExc_TypeError, + "groups must contain strings"); + goto finish; + } + groups_c[i] = s; + } + groups_c[groupc] = (char *)NULL; + } + /* even though this may block, don't give up the interpreter lock + so that the server can't be initialized multiple times. */ + if (mysql_server_init(cmd_argc, cmd_args_c, groups_c)) { + _mysql_Exception(NULL); + goto finish; + } +#endif + ret = Py_None; + Py_INCREF(Py_None); + _mysql_server_init_done = 1; + finish: + PyMem_Free(groups_c); + PyMem_Free(cmd_args_c); + return ret; +} + +static char _mysql_server_end__doc__[] = +"Shut down embedded server. If not using an embedded server, this\n\ +does nothing."; + +static PyObject *_mysql_server_end( + PyObject *self, + PyObject *args) { + if (_mysql_server_init_done) { +#if MYSQL_VERSION_ID >= 40000 + mysql_server_end(); +#endif + _mysql_server_init_done = 0; + Py_INCREF(Py_None); + return Py_None; + } + return _mysql_Exception(NULL); +} + +#if MYSQL_VERSION_ID >= 32314 +static char _mysql_thread_safe__doc__[] = +"Indicates whether the client is compiled as thread-safe."; + +static PyObject *_mysql_thread_safe( + PyObject *self, + PyObject *args) { + PyObject *flag; + if (!PyArg_ParseTuple(args, "")) return NULL; + check_server_init(NULL); + if (!(flag=PyInt_FromLong((long)mysql_thread_safe()))) return NULL; + return flag; +} +#endif + +static char _mysql_ResultObject__doc__[] = +"result(connection, use=0, converter={}) -- Result set from a query.\n\ +\n\ +Creating instances of this class directly is an excellent way to\n\ +shoot yourself in the foot. If using _mysql.connection directly,\n\ +use connection.store_result() or connection.use_result() instead.\n\ +If using MySQLdb.Connection, this is done by the cursor class.\n\ +Just forget you ever saw this. Forget... FOR-GET..."; + +static int +_mysql_ResultObject_Initialize( + _mysql_ResultObject *self, + PyObject *args, + PyObject *kwargs) +{ + static char *kwlist[] = {"connection", "use", "converter", NULL}; + MYSQL_RES *result; + _mysql_ConnectionObject *conn=NULL; + int use=0; + PyObject *conv=NULL; + int n, i; + MYSQL_FIELD *fields; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|iO", kwlist, + &conn, &use, &conv)) + return -1; + if (!conv) conv = PyDict_New(); + if (!conv) return -1; + self->conn = (PyObject *) conn; + Py_INCREF(conn); + self->use = use; + Py_BEGIN_ALLOW_THREADS ; + if (use) + result = mysql_use_result(&(conn->connection)); + else + result = mysql_store_result(&(conn->connection)); + self->result = result; + Py_END_ALLOW_THREADS ; + if (!result) { + self->converter = PyTuple_New(0); + return 0; + } + n = mysql_num_fields(result); + self->nfields = n; + if (!(self->converter = PyTuple_New(n))) return -1; + fields = mysql_fetch_fields(result); + for (i=0; i<n; i++) { + PyObject *tmp, *fun; + tmp = PyInt_FromLong((long) fields[i].type); + if (!tmp) return -1; + fun = PyObject_GetItem(conv, tmp); + Py_DECREF(tmp); + if (!fun) { + PyErr_Clear(); + fun = Py_None; + Py_INCREF(Py_None); + } + if (PySequence_Check(fun)) { + int j, n2=PySequence_Size(fun); + PyObject *fun2=NULL; + for (j=0; j<n2; j++) { + PyObject *t = PySequence_GetItem(fun, j); + if (!t) continue; + if (!PyTuple_Check(t)) goto cleanup; + if (PyTuple_GET_SIZE(t) == 2) { + long mask; + PyObject *pmask=NULL; + pmask = PyTuple_GET_ITEM(t, 0); + fun2 = PyTuple_GET_ITEM(t, 1); + if (PyInt_Check(pmask)) { + mask = PyInt_AS_LONG(pmask); + if (mask & fields[i].flags) { + break; + } + else { + continue; + } + } else { + break; + } + } + cleanup: + Py_DECREF(t); + } + if (!fun2) fun2 = Py_None; + Py_INCREF(fun2); + Py_DECREF(fun); + fun = fun2; + } + PyTuple_SET_ITEM(self->converter, i, fun); + } + return 0; +} + +#if PY_VERSION_HEX >= 0x02020000 +static int _mysql_ResultObject_traverse( + _mysql_ResultObject *self, + visitproc visit, + void *arg) +{ + int r; + if (self->converter) { + if (!(r = visit(self->converter, arg))) return r; + } + if (self->conn) + return visit(self->conn, arg); + return 0; +} +#endif + +static int _mysql_ResultObject_clear( + _mysql_ResultObject *self) +{ + Py_XDECREF(self->converter); + self->converter = NULL; + Py_XDECREF(self->conn); + self->conn = NULL; + return 0; +} + +static int +_mysql_ConnectionObject_Initialize( + _mysql_ConnectionObject *self, + PyObject *args, + PyObject *kwargs) +{ + MYSQL *conn = NULL; + PyObject *conv = NULL; + PyObject *ssl = NULL; +#if HAVE_OPENSSL + char *key = NULL, *cert = NULL, *ca = NULL, + *capath = NULL, *cipher = NULL; +#endif + char *host = NULL, *user = NULL, *passwd = NULL, + *db = NULL, *unix_socket = NULL; + uint port = MYSQL_PORT; + uint client_flag = 0; + static char *kwlist[] = { "host", "user", "passwd", "db", "port", + "unix_socket", "conv", + "connect_timeout", "compress", + "named_pipe", "init_command", + "read_default_file", "read_default_group", + "client_flag", "ssl", + "local_infile", + NULL } ; + int connect_timeout = 0; + int compress = -1, named_pipe = -1, local_infile = -1; + char *init_command=NULL, + *read_default_file=NULL, + *read_default_group=NULL; + + self->converter = NULL; + self->open = 0; + check_server_init(-1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ssssisOiiisssiOi:connect", + kwlist, + &host, &user, &passwd, &db, + &port, &unix_socket, &conv, + &connect_timeout, + &compress, &named_pipe, + &init_command, &read_default_file, + &read_default_group, + &client_flag, &ssl, + &local_infile + )) + return -1; + + if (!conv) + conv = PyDict_New(); +#if PY_VERSION_HEX > 0x02000100 + else + Py_INCREF(conv); +#endif + if (!conv) + return -1; + self->converter = conv; + +#define _stringsuck(d,t,s) {t=PyMapping_GetItemString(s,#d);\ + if(t){d=PyString_AsString(t);Py_DECREF(t);}\ + PyErr_Clear();} + + if (ssl) { +#if HAVE_OPENSSL + PyObject *value = NULL; + _stringsuck(ca, value, ssl); + _stringsuck(capath, value, ssl); + _stringsuck(cert, value, ssl); + _stringsuck(key, value, ssl); + _stringsuck(cipher, value, ssl); +#else + PyErr_SetString(_mysql_NotSupportedError, + "client library does not have SSL support"); + return -1; +#endif + } + + Py_BEGIN_ALLOW_THREADS ; + conn = mysql_init(&(self->connection)); + if (connect_timeout) { + unsigned int timeout = connect_timeout; + mysql_options(&(self->connection), MYSQL_OPT_CONNECT_TIMEOUT, + (char *)&timeout); + } + if (compress != -1) { + mysql_options(&(self->connection), MYSQL_OPT_COMPRESS, 0); + client_flag |= CLIENT_COMPRESS; + } + if (named_pipe != -1) + mysql_options(&(self->connection), MYSQL_OPT_NAMED_PIPE, 0); + if (init_command != NULL) + mysql_options(&(self->connection), MYSQL_INIT_COMMAND, init_command); + if (read_default_file != NULL) + mysql_options(&(self->connection), MYSQL_READ_DEFAULT_FILE, read_default_file); + if (read_default_group != NULL) + mysql_options(&(self->connection), MYSQL_READ_DEFAULT_GROUP, read_default_group); + + if (local_infile != -1) + mysql_options(&(self->connection), MYSQL_OPT_LOCAL_INFILE, (char *) &local_infile); + +#if HAVE_OPENSSL + if (ssl) + mysql_ssl_set(&(self->connection), + key, cert, ca, capath, cipher); +#endif + + conn = mysql_real_connect(&(self->connection), host, user, passwd, db, + port, unix_socket, client_flag); + + Py_END_ALLOW_THREADS ; + + if (!conn) { + _mysql_Exception(self); + return -1; + } + /* + PyType_GenericAlloc() automatically sets up GC allocation and + tracking for GC objects, at least in 2.2.1, so it does not need to + be done here. tp_dealloc still needs to call PyObject_GC_UnTrack(), + however. + */ + self->open = 1; + return 0; +} + +static char _mysql_connect__doc__[] = +"Returns a MYSQL connection object. Exclusive use of\n\ +keyword parameters strongly recommended. Consult the\n\ +MySQL C API documentation for more details.\n\ +\n\ +host\n\ + string, host to connect\n\ +\n\ +user\n\ + string, user to connect as\n\ +\n\ +passwd\n\ + string, password to use\n\ +\n\ +db\n\ + string, database to use\n\ +\n\ +port\n\ + integer, TCP/IP port to connect to\n\ +\n\ +unix_socket\n\ + string, location of unix_socket (UNIX-ish only)\n\ +\n\ +conv\n\ + mapping, maps MySQL FIELD_TYPE.* to Python functions which\n\ + convert a string to the appropriate Python type\n\ +\n\ +connect_timeout\n\ + number of seconds to wait before the connection\n\ + attempt fails.\n\ +\n\ +compress\n\ + if set, gzip compression is enabled\n\ +\n\ +named_pipe\n\ + if set, connect to server via named pipe (Windows only)\n\ +\n\ +init_command\n\ + command which is run once the connection is created\n\ +\n\ +read_default_file\n\ + see the MySQL documentation for mysql_options()\n\ +\n\ +read_default_group\n\ + see the MySQL documentation for mysql_options()\n\ +\n\ +client_flag\n\ + client flags from MySQLdb.constants.CLIENT\n\ +\n\ +load_infile\n\ + int, non-zero enables LOAD LOCAL INFILE, zero disables\n\ +\n\ +"; + +static PyObject * +_mysql_connect( + PyObject *self, + PyObject *args, + PyObject *kwargs) +{ + _mysql_ConnectionObject *c=NULL; + + c = MyAlloc(_mysql_ConnectionObject, _mysql_ConnectionObject_Type); + if (c == NULL) return NULL; + if (_mysql_ConnectionObject_Initialize(c, args, kwargs)) { + Py_DECREF(c); + c = NULL; + } + return (PyObject *) c; +} + +#if PY_VERSION_HEX >= 0x02020000 +static int _mysql_ConnectionObject_traverse( + _mysql_ConnectionObject *self, + visitproc visit, + void *arg) +{ + if (self->converter) + return visit(self->converter, arg); + return 0; +} +#endif + +static int _mysql_ConnectionObject_clear( + _mysql_ConnectionObject *self) +{ + Py_XDECREF(self->converter); + self->converter = NULL; + return 0; +} + +static char _mysql_ConnectionObject_close__doc__[] = +"Close the connection. No further activity possible."; + +static PyObject * +_mysql_ConnectionObject_close( + _mysql_ConnectionObject *self, + PyObject *args) +{ + if (args) { + if (!PyArg_ParseTuple(args, "")) return NULL; + } + if (self->open) { + Py_BEGIN_ALLOW_THREADS + mysql_close(&(self->connection)); + Py_END_ALLOW_THREADS + self->open = 0; + } else { + PyErr_SetString(_mysql_ProgrammingError, + "closing a closed connection"); + return NULL; + } + _mysql_ConnectionObject_clear(self); + Py_INCREF(Py_None); + return Py_None; +} + +static char _mysql_ConnectionObject_affected_rows__doc__ [] = +"Return number of rows affected by the last query.\n\ +Non-standard. Use Cursor.rowcount.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_affected_rows( + _mysql_ConnectionObject *self, + PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + return PyLong_FromUnsignedLongLong(mysql_affected_rows(&(self->connection))); +} + +static char _mysql_debug__doc__[] = +"Does a DBUG_PUSH with the given string.\n\ +mysql_debug() uses the Fred Fish debug library.\n\ +To use this function, you must compile the client library to\n\ +support debugging.\n\ +"; +static PyObject * +_mysql_debug( + PyObject *self, + PyObject *args) +{ + char *debug; + if (!PyArg_ParseTuple(args, "s", &debug)) return NULL; + mysql_debug(debug); + Py_INCREF(Py_None); + return Py_None; +} + +static char _mysql_ConnectionObject_dump_debug_info__doc__[] = +"Instructs the server to write some debug information to the\n\ +log. The connected user must have the process privilege for\n\ +this to work. Non-standard.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_dump_debug_info( + _mysql_ConnectionObject *self, + PyObject *args) +{ + int err; + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + Py_BEGIN_ALLOW_THREADS + err = mysql_dump_debug_info(&(self->connection)); + Py_END_ALLOW_THREADS + if (err) return _mysql_Exception(self); + Py_INCREF(Py_None); + return Py_None; +} + +static char _mysql_ConnectionObject_autocommit__doc__[] = +"Set the autocommit mode. True values enable; False value disable.\n\ +"; +static PyObject * +_mysql_ConnectionObject_autocommit( + _mysql_ConnectionObject *self, + PyObject *args) +{ + int flag, err; + if (!PyArg_ParseTuple(args, "i", &flag)) return NULL; + Py_BEGIN_ALLOW_THREADS +#if MYSQL_VERSION_ID >= 40100 + err = mysql_autocommit(&(self->connection), flag); +#else + { + char query[256]; + snprintf(query, 256, "SET AUTOCOMMIT=%d", flag); + err = mysql_query(&(self->connection), query); + } +#endif + Py_END_ALLOW_THREADS + if (err) return _mysql_Exception(self); + Py_INCREF(Py_None); + return Py_None; +} + +static char _mysql_ConnectionObject_commit__doc__[] = +"Commits the current transaction\n\ +"; +static PyObject * +_mysql_ConnectionObject_commit( + _mysql_ConnectionObject *self, + PyObject *args) +{ + int err; + if (!PyArg_ParseTuple(args, "")) return NULL; + Py_BEGIN_ALLOW_THREADS +#if MYSQL_VERSION_ID >= 40100 + err = mysql_commit(&(self->connection)); +#else + err = mysql_query(&(self->connection), "COMMIT"); +#endif + Py_END_ALLOW_THREADS + if (err) return _mysql_Exception(self); + Py_INCREF(Py_None); + return Py_None; +} + +static char _mysql_ConnectionObject_rollback__doc__[] = +"Rolls backs the current transaction\n\ +"; +static PyObject * +_mysql_ConnectionObject_rollback( + _mysql_ConnectionObject *self, + PyObject *args) +{ + int err; + if (!PyArg_ParseTuple(args, "")) return NULL; + Py_BEGIN_ALLOW_THREADS +#if MYSQL_VERSION_ID >= 40100 + err = mysql_rollback(&(self->connection)); +#else + err = mysql_query(&(self->connection), "ROLLBACK"); +#endif + Py_END_ALLOW_THREADS + if (err) return _mysql_Exception(self); + Py_INCREF(Py_None); + return Py_None; +} + +static char _mysql_ConnectionObject_next_result__doc__[] = +"If more query results exist, next_result() reads the next query\n\ +results and returns the status back to application.\n\ +\n\ +After calling next_result() the state of the connection is as if\n\ +you had called query() for the next query. This means that you can\n\ +now call store_result(), warning_count(), affected_rows()\n\ +, and so forth. \n\ +\n\ +Returns 0 if there are more results; -1 if there are no more results\n\ +\n\ +Non-standard.\n\ +"; +static PyObject * +_mysql_ConnectionObject_next_result( + _mysql_ConnectionObject *self, + PyObject *args) +{ + int err; + if (!PyArg_ParseTuple(args, "")) return NULL; + Py_BEGIN_ALLOW_THREADS +#if MYSQL_VERSION_ID >= 40100 + err = mysql_next_result(&(self->connection)); +#else + err = -1; +#endif + Py_END_ALLOW_THREADS + if (err > 0) return _mysql_Exception(self); + return PyInt_FromLong(err); +} + +#if MYSQL_VERSION_ID >= 40100 + +static char _mysql_ConnectionObject_set_server_option__doc__[] = +"set_server_option(option) -- Enables or disables an option\n\ +for the connection.\n\ +\n\ +Non-standard.\n\ +"; +static PyObject * +_mysql_ConnectionObject_set_server_option( + _mysql_ConnectionObject *self, + PyObject *args) +{ + int err, flags=0; + if (!PyArg_ParseTuple(args, "i", &flags)) + return NULL; + Py_BEGIN_ALLOW_THREADS + err = mysql_set_server_option(&(self->connection), flags); + Py_END_ALLOW_THREADS + if (err) return _mysql_Exception(self); + return PyInt_FromLong(err); +} + +static char _mysql_ConnectionObject_sqlstate__doc__[] = +"Returns a string containing the SQLSTATE error code\n\ +for the last error. The error code consists of five characters.\n\ +'00000' means \"no error.\" The values are specified by ANSI SQL\n\ +and ODBC. For a list of possible values, see section 23\n\ +Error Handling in MySQL in the MySQL Manual.\n\ +\n\ +Note that not all MySQL errors are yet mapped to SQLSTATE's.\n\ +The value 'HY000' (general error) is used for unmapped errors.\n\ +\n\ +Non-standard.\n\ +"; +static PyObject * +_mysql_ConnectionObject_sqlstate( + _mysql_ConnectionObject *self, + PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) return NULL; + return PyString_FromString(mysql_sqlstate(&(self->connection))); +} + +static char _mysql_ConnectionObject_warning_count__doc__[] = +"Returns the number of warnings generated during execution\n\ +of the previous SQL statement.\n\ +\n\ +Non-standard.\n\ +"; +static PyObject * +_mysql_ConnectionObject_warning_count( + _mysql_ConnectionObject *self, + PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) return NULL; + return PyInt_FromLong(mysql_warning_count(&(self->connection))); +} + +#endif + +static char _mysql_ConnectionObject_errno__doc__[] = +"Returns the error code for the most recently invoked API function\n\ +that can succeed or fail. A return value of zero means that no error\n\ +occurred.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_errno( + _mysql_ConnectionObject *self, + PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + return PyInt_FromLong((long)mysql_errno(&(self->connection))); +} + +static char _mysql_ConnectionObject_error__doc__[] = +"Returns the error message for the most recently invoked API function\n\ +that can succeed or fail. An empty string ("") is returned if no error\n\ +occurred.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_error( + _mysql_ConnectionObject *self, + PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + return PyString_FromString(mysql_error(&(self->connection))); +} + +static char _mysql_escape_string__doc__[] = +"escape_string(s) -- quote any SQL-interpreted characters in string s.\n\ +\n\ +Use connection.escape_string(s), if you use it at all.\n\ +_mysql.escape_string(s) cannot handle character sets. You are\n\ +probably better off using connection.escape(o) instead, since\n\ +it will escape entire sequences as well as strings."; + +static PyObject * +_mysql_escape_string( + _mysql_ConnectionObject *self, + PyObject *args) +{ + PyObject *str; + char *in, *out; + int len, size; + if (!PyArg_ParseTuple(args, "s#:escape_string", &in, &size)) return NULL; + str = PyString_FromStringAndSize((char *) NULL, size*2+1); + if (!str) return PyErr_NoMemory(); + out = PyString_AS_STRING(str); +#if MYSQL_VERSION_ID < 32321 + len = mysql_escape_string(out, in, size); +#else + check_server_init(NULL); + if (self && self->open) + len = mysql_real_escape_string(&(self->connection), out, in, size); + else + len = mysql_escape_string(out, in, size); +#endif + if (_PyString_Resize(&str, len) < 0) return NULL; + return (str); +} + +static char _mysql_string_literal__doc__[] = +"string_literal(obj) -- converts object obj into a SQL string literal.\n\ +This means, any special SQL characters are escaped, and it is enclosed\n\ +within single quotes. In other words, it performs:\n\ +\n\ +\"'%s'\" % escape_string(str(obj))\n\ +\n\ +Use connection.string_literal(obj), if you use it at all.\n\ +_mysql.string_literal(obj) cannot handle character sets."; + +static PyObject * +_mysql_string_literal( + _mysql_ConnectionObject *self, + PyObject *args) +{ + PyObject *str, *s, *o, *d; + char *in, *out; + int len, size; + if (!PyArg_ParseTuple(args, "O|O:string_literal", &o, &d)) return NULL; + s = PyObject_Str(o); + if (!s) return NULL; + in = PyString_AsString(s); + size = PyString_GET_SIZE(s); + str = PyString_FromStringAndSize((char *) NULL, size*2+3); + if (!str) return PyErr_NoMemory(); + out = PyString_AS_STRING(str); +#if MYSQL_VERSION_ID < 32321 + len = mysql_escape_string(out+1, in, size); +#else + check_server_init(NULL); + if (self && self->open) + len = mysql_real_escape_string(&(self->connection), out+1, in, size); + else + len = mysql_escape_string(out+1, in, size); +#endif + *out = *(out+len+1) = '\''; + if (_PyString_Resize(&str, len+2) < 0) return NULL; + Py_DECREF(s); + return (str); +} + +static PyObject *_mysql_NULL; + +static PyObject * +_escape_item( + PyObject *item, + PyObject *d) +{ + PyObject *quoted=NULL, *itemtype, *itemconv; + if (!(itemtype = PyObject_Type(item))) + goto error; + itemconv = PyObject_GetItem(d, itemtype); + Py_DECREF(itemtype); + if (!itemconv) { + PyErr_Clear(); + itemconv = PyObject_GetItem(d, + (PyObject *) &PyString_Type); + } + if (!itemconv) { + PyErr_SetString(PyExc_TypeError, + "no default type converter defined"); + goto error; + } + quoted = PyObject_CallFunction(itemconv, "OO", item, d); + Py_DECREF(itemconv); +error: + return quoted; +} + +static char _mysql_escape__doc__[] = +"escape(obj, dict) -- escape any special characters in object obj\n\ +using mapping dict to provide quoting functions for each type.\n\ +Returns a SQL literal string."; +static PyObject * +_mysql_escape( + PyObject *self, + PyObject *args) +{ + PyObject *o=NULL, *d=NULL; + if (!PyArg_ParseTuple(args, "O|O:escape", &o, &d)) + return NULL; + if (d) { + if (!PyMapping_Check(d)) { + PyErr_SetString(PyExc_TypeError, + "argument 2 must be a mapping"); + return NULL; + } + return _escape_item(o, d); + } else { + if (!self) { + PyErr_SetString(PyExc_TypeError, + "argument 2 must be a mapping"); + return NULL; + } + return _escape_item(o, + ((_mysql_ConnectionObject *) self)->converter); + } +} + +static char _mysql_escape_sequence__doc__[] = +"escape_sequence(seq, dict) -- escape any special characters in sequence\n\ +seq using mapping dict to provide quoting functions for each type.\n\ +Returns a tuple of escaped items."; +static PyObject * +_mysql_escape_sequence( + PyObject *self, + PyObject *args) +{ + PyObject *o=NULL, *d=NULL, *r=NULL, *item, *quoted; + int i, n; + if (!PyArg_ParseTuple(args, "OO:escape_sequence", &o, &d)) + goto error; + if (!PyMapping_Check(d)) { + PyErr_SetString(PyExc_TypeError, + "argument 2 must be a mapping"); + return NULL; + } + if ((n = PyObject_Length(o)) == -1) goto error; + if (!(r = PyTuple_New(n))) goto error; + for (i=0; i<n; i++) { + item = PySequence_GetItem(o, i); + if (!item) goto error; + quoted = _escape_item(item, d); + Py_DECREF(item); + if (!quoted) goto error; + PyTuple_SET_ITEM(r, i, quoted); + } + return r; + error: + Py_XDECREF(r); + return NULL; +} + +static char _mysql_escape_dict__doc__[] = +"escape_sequence(d, dict) -- escape any special characters in\n\ +dictionary d using mapping dict to provide quoting functions for each type.\n\ +Returns a dictionary of escaped items."; +static PyObject * +_mysql_escape_dict( + PyObject *self, + PyObject *args) +{ + PyObject *o=NULL, *d=NULL, *r=NULL, *item, *quoted, *pkey; + Py_ssize_t ppos = 0; + if (!PyArg_ParseTuple(args, "O!O:escape_dict", &PyDict_Type, &o, &d)) + goto error; + if (!PyMapping_Check(d)) { + PyErr_SetString(PyExc_TypeError, + "argument 2 must be a mapping"); + return NULL; + } + if (!(r = PyDict_New())) goto error; + while (PyDict_Next(o, &ppos, &pkey, &item)) { + quoted = _escape_item(item, d); + if (!quoted) goto error; + if (PyDict_SetItem(r, pkey, quoted)==-1) goto error; + Py_DECREF(quoted); + } + return r; + error: + Py_XDECREF(r); + return NULL; +} + +static char _mysql_ResultObject_describe__doc__[] = +"Returns the sequence of 7-tuples required by the DB-API for\n\ +the Cursor.description attribute.\n\ +"; + +static PyObject * +_mysql_ResultObject_describe( + _mysql_ResultObject *self, + PyObject *args) +{ + PyObject *d; + MYSQL_FIELD *fields; + unsigned int i, n; + if (!PyArg_ParseTuple(args, "")) return NULL; + check_result_connection(self); + n = mysql_num_fields(self->result); + fields = mysql_fetch_fields(self->result); + if (!(d = PyTuple_New(n))) return NULL; + for (i=0; i<n; i++) { + PyObject *t; + t = Py_BuildValue("(siiiiii)", + fields[i].name, + (long) fields[i].type, + (long) fields[i].max_length, + (long) fields[i].length, + (long) fields[i].length, + (long) fields[i].decimals, + (long) !(IS_NOT_NULL(fields[i].flags))); + if (!t) goto error; + PyTuple_SET_ITEM(d, i, t); + } + return d; + error: + Py_XDECREF(d); + return NULL; +} + +static char _mysql_ResultObject_field_flags__doc__[] = +"Returns a tuple of field flags, one for each column in the result.\n\ +" ; + +static PyObject * +_mysql_ResultObject_field_flags( + _mysql_ResultObject *self, + PyObject *args) +{ + PyObject *d; + MYSQL_FIELD *fields; + unsigned int i, n; + if (!PyArg_ParseTuple(args, "")) return NULL; + check_result_connection(self); + n = mysql_num_fields(self->result); + fields = mysql_fetch_fields(self->result); + if (!(d = PyTuple_New(n))) return NULL; + for (i=0; i<n; i++) { + PyObject *f; + if (!(f = PyInt_FromLong((long)fields[i].flags))) goto error; + PyTuple_SET_ITEM(d, i, f); + } + return d; + error: + Py_XDECREF(d); + return NULL; +} + +static PyObject * +_mysql_field_to_python( + PyObject *converter, + char *rowitem, + unsigned long length) +{ + PyObject *v; + if (rowitem) { + if (converter != Py_None) + v = PyObject_CallFunction(converter, + "s#", + rowitem, + (int)length); + else + v = PyString_FromStringAndSize(rowitem, + (int)length); + if (!v) + return NULL; + } else { + Py_INCREF(Py_None); + v = Py_None; + } + return v; +} + +static PyObject * +_mysql_row_to_tuple( + _mysql_ResultObject *self, + MYSQL_ROW row) +{ + unsigned int n, i; + unsigned long *length; + PyObject *r, *c; + + n = mysql_num_fields(self->result); + if (!(r = PyTuple_New(n))) return NULL; + length = mysql_fetch_lengths(self->result); + for (i=0; i<n; i++) { + PyObject *v; + c = PyTuple_GET_ITEM(self->converter, i); + v = _mysql_field_to_python(c, row[i], length[i]); + if (!v) goto error; + PyTuple_SET_ITEM(r, i, v); + } + return r; + error: + Py_XDECREF(r); + return NULL; +} + +static PyObject * +_mysql_row_to_dict( + _mysql_ResultObject *self, + MYSQL_ROW row) +{ + unsigned int n, i; + unsigned long *length; + PyObject *r, *c; + MYSQL_FIELD *fields; + + n = mysql_num_fields(self->result); + if (!(r = PyDict_New())) return NULL; + length = mysql_fetch_lengths(self->result); + fields = mysql_fetch_fields(self->result); + for (i=0; i<n; i++) { + PyObject *v; + c = PyTuple_GET_ITEM(self->converter, i); + v = _mysql_field_to_python(c, row[i], length[i]); + if (!v) goto error; + if (!PyMapping_HasKeyString(r, fields[i].name)) { + PyMapping_SetItemString(r, fields[i].name, v); + } else { + int len; + char buf[256]; + strncpy(buf, fields[i].table, 256); + len = strlen(buf); + strncat(buf, ".", 256-len); + len = strlen(buf); + strncat(buf, fields[i].name, 256-len); + PyMapping_SetItemString(r, buf, v); + } + Py_DECREF(v); + } + return r; + error: + Py_XDECREF(r); + return NULL; +} + +static PyObject * +_mysql_row_to_dict_old( + _mysql_ResultObject *self, + MYSQL_ROW row) +{ + unsigned int n, i; + unsigned long *length; + PyObject *r, *c; + MYSQL_FIELD *fields; + + n = mysql_num_fields(self->result); + if (!(r = PyDict_New())) return NULL; + length = mysql_fetch_lengths(self->result); + fields = mysql_fetch_fields(self->result); + for (i=0; i<n; i++) { + PyObject *v; + c = PyTuple_GET_ITEM(self->converter, i); + v = _mysql_field_to_python(c, row[i], length[i]); + if (!v) goto error; + { + int len=0; + char buf[256]=""; + if (strlen(fields[i].table)) { + strncpy(buf, fields[i].table, 256); + len = strlen(buf); + strncat(buf, ".", 256-len); + len = strlen(buf); + } + strncat(buf, fields[i].name, 256-len); + PyMapping_SetItemString(r, buf, v); + } + Py_DECREF(v); + } + return r; + error: + Py_XDECREF(r); + return NULL; +} + +typedef PyObject *_PYFUNC(_mysql_ResultObject *, MYSQL_ROW); + +int +_mysql__fetch_row( + _mysql_ResultObject *self, + PyObject **r, + int skiprows, + int maxrows, + _PYFUNC *convert_row) +{ + unsigned int i; + MYSQL_ROW row; + + for (i = skiprows; i<(skiprows+maxrows); i++) { + PyObject *v; + if (!self->use) + row = mysql_fetch_row(self->result); + else { + Py_BEGIN_ALLOW_THREADS; + row = mysql_fetch_row(self->result); + Py_END_ALLOW_THREADS; + } + if (!row && mysql_errno(&(((_mysql_ConnectionObject *)(self->conn))->connection))) { + _mysql_Exception((_mysql_ConnectionObject *)self->conn); + goto error; + } + if (!row) { + if (MyTuple_Resize(r, i, 0) == -1) goto error; + break; + } + v = convert_row(self, row); + if (!v) goto error; + PyTuple_SET_ITEM(*r, i, v); + } + return i-skiprows; + error: + return -1; +} + +static char _mysql_ResultObject_fetch_row__doc__[] = +"fetch_row([maxrows, how]) -- Fetches up to maxrows as a tuple.\n\ +The rows are formatted according to how:\n\ +\n\ + 0 -- tuples (default)\n\ + 1 -- dictionaries, key=column or table.column if duplicated\n\ + 2 -- dictionaries, key=table.column\n\ +"; + +static PyObject * +_mysql_ResultObject_fetch_row( + _mysql_ResultObject *self, + PyObject *args, + PyObject *kwargs) +{ + typedef PyObject *_PYFUNC(_mysql_ResultObject *, MYSQL_ROW); + static char *kwlist[] = { "maxrows", "how", NULL }; + static _PYFUNC *row_converters[] = + { + _mysql_row_to_tuple, + _mysql_row_to_dict, + _mysql_row_to_dict_old + }; + _PYFUNC *convert_row; + unsigned int maxrows=1, how=0, skiprows=0, rowsadded; + PyObject *r=NULL; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii:fetch_row", kwlist, + &maxrows, &how)) + return NULL; + check_result_connection(self); + if (how < 0 || how >= sizeof(row_converters)) { + PyErr_SetString(PyExc_ValueError, "how out of range"); + return NULL; + } + convert_row = row_converters[how]; + if (maxrows) { + if (!(r = PyTuple_New(maxrows))) goto error; + rowsadded = _mysql__fetch_row(self, &r, skiprows, maxrows, + convert_row); + if (rowsadded == -1) goto error; + } else { + if (self->use) { + maxrows = 1000; + if (!(r = PyTuple_New(maxrows))) goto error; + while (1) { + rowsadded = _mysql__fetch_row(self, &r, skiprows, + maxrows, convert_row); + if (rowsadded == -1) goto error; + skiprows += rowsadded; + if (rowsadded < maxrows) break; + if (MyTuple_Resize(&r, skiprows+maxrows, 0) == -1) + goto error; + } + } else { + /* XXX if overflow, maxrows<0? */ + maxrows = (int) mysql_num_rows(self->result); + if (!(r = PyTuple_New(maxrows))) goto error; + rowsadded = _mysql__fetch_row(self, &r, 0, + maxrows, convert_row); + if (rowsadded == -1) goto error; + } + } + return r; + error: + Py_XDECREF(r); + return NULL; +} + +#if MYSQL_VERSION_ID >= 32303 + +static char _mysql_ConnectionObject_change_user__doc__[] = +"Changes the user and causes the database specified by db to\n\ +become the default (current) database on the connection\n\ +specified by mysql. In subsequent queries, this database is\n\ +the default for table references that do not include an\n\ +explicit database specifier.\n\ +\n\ +This function was introduced in MySQL Version 3.23.3.\n\ +\n\ +Fails unless the connected user can be authenticated or if he\n\ +doesn't have permission to use the database. In this case the\n\ +user and database are not changed.\n\ +\n\ +The db parameter may be set to None if you don't want to have\n\ +a default database.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_change_user( + _mysql_ConnectionObject *self, + PyObject *args, + PyObject *kwargs) +{ + char *user, *pwd=NULL, *db=NULL; + int r; + static char *kwlist[] = { "user", "passwd", "db", NULL } ; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|ss:change_user", + kwlist, &user, &pwd, &db)) + return NULL; + check_connection(self); + Py_BEGIN_ALLOW_THREADS + r = mysql_change_user(&(self->connection), user, pwd, db); + Py_END_ALLOW_THREADS + if (r) return _mysql_Exception(self); + Py_INCREF(Py_None); + return Py_None; +} +#endif + +static char _mysql_ConnectionObject_character_set_name__doc__[] = +"Returns the default character set for the current connection.\n\ +Non-standard.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_character_set_name( + _mysql_ConnectionObject *self, + PyObject *args) +{ + const char *s; + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); +#if MYSQL_VERSION_ID >= 32321 + s = mysql_character_set_name(&(self->connection)); +#else + s = "latin1"; +#endif + return PyString_FromString(s); +} + +#if MYSQL_VERSION_ID >= 50007 +static char _mysql_ConnectionObject_set_character_set__doc__[] = +"Sets the default character set for the current connection.\n\ +Non-standard.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_set_character_set( + _mysql_ConnectionObject *self, + PyObject *args) +{ + const char *s; + int err; + if (!PyArg_ParseTuple(args, "s", &s)) return NULL; + check_connection(self); + Py_BEGIN_ALLOW_THREADS + err = mysql_set_character_set(&(self->connection), s); + Py_END_ALLOW_THREADS + if (err) return _mysql_Exception(self); + Py_INCREF(Py_None); + return Py_None; +} +#endif + +#if MYSQL_VERSION_ID >= 50010 +static char _mysql_ConnectionObject_get_character_set_info__doc__[] = +"Returns a dict with information about the current character set:\n\ +\n\ +collation\n\ + collation name\n\ +name\n\ + character set name\n\ +comment\n\ + comment or descriptive name\n\ +dir\n\ + character set directory\n\ +mbminlen\n\ + min. length for multibyte string\n\ +mbmaxlen\n\ + max. length for multibyte string\n\ +\n\ +Not all keys may be present, particularly dir.\n\ +\n\ +Non-standard.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_get_character_set_info( + _mysql_ConnectionObject *self, + PyObject *args) +{ + PyObject *result; + MY_CHARSET_INFO cs; + + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + mysql_get_character_set_info(&(self->connection), &cs); + if (!(result = PyDict_New())) return NULL; + if (cs.csname) + PyDict_SetItemString(result, "name", PyString_FromString(cs.csname)); + if (cs.name) + PyDict_SetItemString(result, "collation", PyString_FromString(cs.name)); + if (cs.comment) + PyDict_SetItemString(result, "comment", PyString_FromString(cs.comment)); + if (cs.dir) + PyDict_SetItemString(result, "dir", PyString_FromString(cs.dir)); + PyDict_SetItemString(result, "mbminlen", PyInt_FromLong(cs.mbminlen)); + PyDict_SetItemString(result, "mbmaxlen", PyInt_FromLong(cs.mbmaxlen)); + return result; +} +#endif + +static char _mysql_get_client_info__doc__[] = +"get_client_info() -- Returns a string that represents\n\ +the client library version."; +static PyObject * +_mysql_get_client_info( + PyObject *self, + PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) return NULL; + check_server_init(NULL); + return PyString_FromString(mysql_get_client_info()); +} + +static char _mysql_ConnectionObject_get_host_info__doc__[] = +"Returns a string that represents the MySQL client library\n\ +version. Non-standard.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_get_host_info( + _mysql_ConnectionObject *self, + PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + return PyString_FromString(mysql_get_host_info(&(self->connection))); +} + +static char _mysql_ConnectionObject_get_proto_info__doc__[] = +"Returns an unsigned integer representing the protocol version\n\ +used by the current connection. Non-standard.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_get_proto_info( + _mysql_ConnectionObject *self, + PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + return PyInt_FromLong((long)mysql_get_proto_info(&(self->connection))); +} + +static char _mysql_ConnectionObject_get_server_info__doc__[] = +"Returns a string that represents the server version number.\n\ +Non-standard.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_get_server_info( + _mysql_ConnectionObject *self, + PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + return PyString_FromString(mysql_get_server_info(&(self->connection))); +} + +static char _mysql_ConnectionObject_info__doc__[] = +"Retrieves a string providing information about the most\n\ +recently executed query. Non-standard. Use messages or\n\ +Cursor.messages.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_info( + _mysql_ConnectionObject *self, + PyObject *args) +{ + const char *s; + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + s = mysql_info(&(self->connection)); + if (s) return PyString_FromString(s); + Py_INCREF(Py_None); + return Py_None; +} + +static char _mysql_ConnectionObject_insert_id__doc__[] = +"Returns the ID generated for an AUTO_INCREMENT column by the previous\n\ +query. Use this function after you have performed an INSERT query into a\n\ +table that contains an AUTO_INCREMENT field.\n\ +\n\ +Note that this returns 0 if the previous query does not\n\ +generate an AUTO_INCREMENT value. If you need to save the value for\n\ +later, be sure to call this immediately after the query\n\ +that generates the value.\n\ +\n\ +The ID is updated after INSERT and UPDATE statements that generate\n\ +an AUTO_INCREMENT value or that set a column value to\n\ +LAST_INSERT_ID(expr). See section 6.3.5.2 Miscellaneous Functions\n\ +in the MySQL documentation.\n\ +\n\ +Also note that the value of the SQL LAST_INSERT_ID() function always\n\ +contains the most recently generated AUTO_INCREMENT value, and is not\n\ +reset between queries because the value of that function is maintained\n\ +in the server.\n\ +" ; + +static PyObject * +_mysql_ConnectionObject_insert_id( + _mysql_ConnectionObject *self, + PyObject *args) +{ + my_ulonglong r; + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + Py_BEGIN_ALLOW_THREADS + r = mysql_insert_id(&(self->connection)); + Py_END_ALLOW_THREADS + return PyLong_FromUnsignedLongLong(r); +} + +static char _mysql_ConnectionObject_kill__doc__[] = +"Asks the server to kill the thread specified by pid.\n\ +Non-standard."; + +static PyObject * +_mysql_ConnectionObject_kill( + _mysql_ConnectionObject *self, + PyObject *args) +{ + unsigned long pid; + int r; + if (!PyArg_ParseTuple(args, "i:kill", &pid)) return NULL; + check_connection(self); + Py_BEGIN_ALLOW_THREADS + r = mysql_kill(&(self->connection), pid); + Py_END_ALLOW_THREADS + if (r) return _mysql_Exception(self); + Py_INCREF(Py_None); + return Py_None; +} + +static char _mysql_ConnectionObject_field_count__doc__[] = +"Returns the number of columns for the most recent query on the\n\ +connection. Non-standard. Will probably give you bogus results\n\ +on most cursor classes. Use Cursor.rowcount.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_field_count( + _mysql_ConnectionObject *self, + PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); +#if MYSQL_VERSION_ID < 32224 + return PyInt_FromLong((long)mysql_num_fields(&(self->connection))); +#else + return PyInt_FromLong((long)mysql_field_count(&(self->connection))); +#endif +} + +static char _mysql_ResultObject_num_fields__doc__[] = +"Returns the number of fields (column) in the result." ; + +static PyObject * +_mysql_ResultObject_num_fields( + _mysql_ResultObject *self, + PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) return NULL; + check_result_connection(self); + return PyInt_FromLong((long)mysql_num_fields(self->result)); +} + +static char _mysql_ResultObject_num_rows__doc__[] = +"Returns the number of rows in the result set. Note that if\n\ +use=1, this will not return a valid value until the entire result\n\ +set has been read.\n\ +"; + +static PyObject * +_mysql_ResultObject_num_rows( + _mysql_ResultObject *self, + PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) return NULL; + check_result_connection(self); + return PyLong_FromUnsignedLongLong(mysql_num_rows(self->result)); +} + +static char _mysql_ConnectionObject_ping__doc__[] = +"Checks whether or not the connection to the server is\n\ +working. If it has gone down, an automatic reconnection is\n\ +attempted.\n\ +\n\ +This function can be used by clients that remain idle for a\n\ +long while, to check whether or not the server has closed the\n\ +connection and reconnect if necessary.\n\ +\n\ +New in 1.2.2: Accepts an optional reconnect parameter. If True,\n\ +then the client will attempt reconnection. Note that this setting\n\ +is persistent. By default, this is on in MySQL<5.0.3, and off\n\ +thereafter.\n\ +\n\ +Non-standard. You should assume that ping() performs an\n\ +implicit rollback; use only when starting a new transaction.\n\ +You have been warned.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_ping( + _mysql_ConnectionObject *self, + PyObject *args) +{ + int r, reconnect = -1; + if (!PyArg_ParseTuple(args, "|I", &reconnect)) return NULL; + check_connection(self); + if ( reconnect != -1 ) self->connection.reconnect = reconnect; + Py_BEGIN_ALLOW_THREADS + r = mysql_ping(&(self->connection)); + Py_END_ALLOW_THREADS + if (r) return _mysql_Exception(self); + Py_INCREF(Py_None); + return Py_None; +} + +static char _mysql_ConnectionObject_query__doc__[] = +"Execute a query. store_result() or use_result() will get the\n\ +result set, if any. Non-standard. Use cursor() to create a cursor,\n\ +then cursor.execute().\n\ +" ; + +static PyObject * +_mysql_ConnectionObject_query( + _mysql_ConnectionObject *self, + PyObject *args) +{ + char *query; + int len, r; + if (!PyArg_ParseTuple(args, "s#:query", &query, &len)) return NULL; + check_connection(self); + Py_BEGIN_ALLOW_THREADS + r = mysql_real_query(&(self->connection), query, len); + Py_END_ALLOW_THREADS + if (r) return _mysql_Exception(self); + Py_INCREF(Py_None); + return Py_None; +} + + +static char _mysql_ConnectionObject_select_db__doc__[] = +"Causes the database specified by db to become the default\n\ +(current) database on the connection specified by mysql. In subsequent\n\ +queries, this database is the default for table references that do not\n\ +include an explicit database specifier.\n\ +\n\ +Fails unless the connected user can be authenticated as having\n\ +permission to use the database.\n\ +\n\ +Non-standard.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_select_db( + _mysql_ConnectionObject *self, + PyObject *args) +{ + char *db; + int r; + if (!PyArg_ParseTuple(args, "s:select_db", &db)) return NULL; + check_connection(self); + Py_BEGIN_ALLOW_THREADS + r = mysql_select_db(&(self->connection), db); + Py_END_ALLOW_THREADS + if (r) return _mysql_Exception(self); + Py_INCREF(Py_None); + return Py_None; +} + +static char _mysql_ConnectionObject_shutdown__doc__[] = +"Asks the database server to shut down. The connected user must\n\ +have shutdown privileges. Non-standard.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_shutdown( + _mysql_ConnectionObject *self, + PyObject *args) +{ + int r; + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + Py_BEGIN_ALLOW_THREADS + r = mysql_shutdown(&(self->connection) +#if MYSQL_VERSION_ID >= 40103 + , SHUTDOWN_DEFAULT +#endif + ); + Py_END_ALLOW_THREADS + if (r) return _mysql_Exception(self); + Py_INCREF(Py_None); + return Py_None; +} + +static char _mysql_ConnectionObject_stat__doc__[] = +"Returns a character string containing information similar to\n\ +that provided by the mysqladmin status command. This includes\n\ +uptime in seconds and the number of running threads,\n\ +questions, reloads, and open tables. Non-standard.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_stat( + _mysql_ConnectionObject *self, + PyObject *args) +{ + const char *s; + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + Py_BEGIN_ALLOW_THREADS + s = mysql_stat(&(self->connection)); + Py_END_ALLOW_THREADS + if (!s) return _mysql_Exception(self); + return PyString_FromString(s); +} + +static char _mysql_ConnectionObject_store_result__doc__[] = +"Returns a result object acquired by mysql_store_result\n\ +(results stored in the client). If no results are available,\n\ +None is returned. Non-standard.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_store_result( + _mysql_ConnectionObject *self, + PyObject *args) +{ + PyObject *arglist=NULL, *kwarglist=NULL, *result=NULL; + _mysql_ResultObject *r=NULL; + + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + arglist = Py_BuildValue("(OiO)", self, 0, self->converter); + if (!arglist) goto error; + kwarglist = PyDict_New(); + if (!kwarglist) goto error; + r = MyAlloc(_mysql_ResultObject, _mysql_ResultObject_Type); + if (!r) goto error; + if (_mysql_ResultObject_Initialize(r, arglist, kwarglist)) + goto error; + result = (PyObject *) r; + if (!(r->result)) { + Py_DECREF(result); + Py_INCREF(Py_None); + result = Py_None; + } + error: + Py_XDECREF(arglist); + Py_XDECREF(kwarglist); + return result; +} + +static char _mysql_ConnectionObject_thread_id__doc__[] = +"Returns the thread ID of the current connection. This value\n\ +can be used as an argument to kill() to kill the thread.\n\ +\n\ +If the connection is lost and you reconnect with ping(), the\n\ +thread ID will change. This means you should not get the\n\ +thread ID and store it for later. You should get it when you\n\ +need it.\n\ +\n\ +Non-standard."; + +static PyObject * +_mysql_ConnectionObject_thread_id( + _mysql_ConnectionObject *self, + PyObject *args) +{ + unsigned long pid; + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + Py_BEGIN_ALLOW_THREADS + pid = mysql_thread_id(&(self->connection)); + Py_END_ALLOW_THREADS + return PyInt_FromLong((long)pid); +} + +static char _mysql_ConnectionObject_use_result__doc__[] = +"Returns a result object acquired by mysql_use_result\n\ +(results stored in the server). If no results are available,\n\ +None is returned. Non-standard.\n\ +"; + +static PyObject * +_mysql_ConnectionObject_use_result( + _mysql_ConnectionObject *self, + PyObject *args) +{ + PyObject *arglist=NULL, *kwarglist=NULL, *result=NULL; + _mysql_ResultObject *r=NULL; + + if (!PyArg_ParseTuple(args, "")) return NULL; + check_connection(self); + arglist = Py_BuildValue("(OiO)", self, 1, self->converter); + if (!arglist) return NULL; + kwarglist = PyDict_New(); + if (!kwarglist) goto error; + r = MyAlloc(_mysql_ResultObject, _mysql_ResultObject_Type); + if (!r) goto error; + result = (PyObject *) r; + if (_mysql_ResultObject_Initialize(r, arglist, kwarglist)) + goto error; + if (!(r->result)) { + Py_DECREF(result); + Py_INCREF(Py_None); + result = Py_None; + } + error: + Py_DECREF(arglist); + Py_XDECREF(kwarglist); + return result; +} + +static void +_mysql_ConnectionObject_dealloc( + _mysql_ConnectionObject *self) +{ + PyObject *o; + + PyObject_GC_UnTrack(self); + if (self->open) { + o = _mysql_ConnectionObject_close(self, NULL); + Py_XDECREF(o); + } + MyFree(self); +} + +static PyObject * +_mysql_ConnectionObject_repr( + _mysql_ConnectionObject *self) +{ + char buf[300]; + if (self->open) + sprintf(buf, "<_mysql.connection open to '%.256s' at %lx>", + self->connection.host, + (long)self); + else + sprintf(buf, "<_mysql.connection closed at %lx>", + (long)self); + return PyString_FromString(buf); +} + +static char _mysql_ResultObject_data_seek__doc__[] = +"data_seek(n) -- seek to row n of result set"; +static PyObject * +_mysql_ResultObject_data_seek( + _mysql_ResultObject *self, + PyObject *args) +{ + unsigned int row; + if (!PyArg_ParseTuple(args, "i:data_seek", &row)) return NULL; + check_result_connection(self); + mysql_data_seek(self->result, row); + Py_INCREF(Py_None); + return Py_None; +} + +static char _mysql_ResultObject_row_seek__doc__[] = +"row_seek(n) -- seek by offset n rows of result set"; +static PyObject * +_mysql_ResultObject_row_seek( + _mysql_ResultObject *self, + PyObject *args) +{ + int offset; + MYSQL_ROW_OFFSET r; + if (!PyArg_ParseTuple(args, "i:row_seek", &offset)) return NULL; + check_result_connection(self); + if (self->use) { + PyErr_SetString(_mysql_ProgrammingError, + "cannot be used with connection.use_result()"); + return NULL; + } + r = mysql_row_tell(self->result); + mysql_row_seek(self->result, r+offset); + Py_INCREF(Py_None); + return Py_None; +} + +static char _mysql_ResultObject_row_tell__doc__[] = +"row_tell() -- return the current row number of the result set."; +static PyObject * +_mysql_ResultObject_row_tell( + _mysql_ResultObject *self, + PyObject *args) +{ + MYSQL_ROW_OFFSET r; + if (!PyArg_ParseTuple(args, "")) return NULL; + check_result_connection(self); + if (self->use) { + PyErr_SetString(_mysql_ProgrammingError, + "cannot be used with connection.use_result()"); + return NULL; + } + r = mysql_row_tell(self->result); + return PyInt_FromLong(r-self->result->data->data); +} + +static void +_mysql_ResultObject_dealloc( + _mysql_ResultObject *self) +{ + PyObject_GC_UnTrack((PyObject *)self); + mysql_free_result(self->result); + _mysql_ResultObject_clear(self); + MyFree(self); +} + +static PyObject * +_mysql_ResultObject_repr( + _mysql_ResultObject *self) +{ + char buf[300]; + sprintf(buf, "<_mysql.result object at %lx>", + (long)self); + return PyString_FromString(buf); +} + +static PyMethodDef _mysql_ConnectionObject_methods[] = { + { + "affected_rows", + (PyCFunction)_mysql_ConnectionObject_affected_rows, + METH_VARARGS, + _mysql_ConnectionObject_affected_rows__doc__ + }, + { + "autocommit", + (PyCFunction)_mysql_ConnectionObject_autocommit, + METH_VARARGS, + _mysql_ConnectionObject_autocommit__doc__ + }, + { + "commit", + (PyCFunction)_mysql_ConnectionObject_commit, + METH_VARARGS, + _mysql_ConnectionObject_commit__doc__ + }, + { + "rollback", + (PyCFunction)_mysql_ConnectionObject_rollback, + METH_VARARGS, + _mysql_ConnectionObject_rollback__doc__ + }, + { + "next_result", + (PyCFunction)_mysql_ConnectionObject_next_result, + METH_VARARGS, + _mysql_ConnectionObject_next_result__doc__ + }, +#if MYSQL_VERSION_ID >= 40100 + { + "set_server_option", + (PyCFunction)_mysql_ConnectionObject_set_server_option, + METH_VARARGS, + _mysql_ConnectionObject_set_server_option__doc__ + }, + { + "sqlstate", + (PyCFunction)_mysql_ConnectionObject_sqlstate, + METH_VARARGS, + _mysql_ConnectionObject_sqlstate__doc__ + }, + { + "warning_count", + (PyCFunction)_mysql_ConnectionObject_warning_count, + METH_VARARGS, + _mysql_ConnectionObject_warning_count__doc__ + }, +#endif +#if MYSQL_VERSION_ID >= 32303 + { + "change_user", + (PyCFunction)_mysql_ConnectionObject_change_user, + METH_VARARGS | METH_KEYWORDS, + _mysql_ConnectionObject_change_user__doc__ + }, +#endif + { + "character_set_name", + (PyCFunction)_mysql_ConnectionObject_character_set_name, + METH_VARARGS, + _mysql_ConnectionObject_character_set_name__doc__ + }, +#if MYSQL_VERSION_ID >= 50007 + { + "set_character_set", + (PyCFunction)_mysql_ConnectionObject_set_character_set, + METH_VARARGS, + _mysql_ConnectionObject_set_character_set__doc__ + }, +#endif +#if MYSQL_VERSION_ID >= 50010 + { + "get_character_set_info", + (PyCFunction)_mysql_ConnectionObject_get_character_set_info, + METH_VARARGS, + _mysql_ConnectionObject_get_character_set_info__doc__ + }, +#endif + { + "close", + (PyCFunction)_mysql_ConnectionObject_close, + METH_VARARGS, + _mysql_ConnectionObject_close__doc__ + }, + { + "dump_debug_info", + (PyCFunction)_mysql_ConnectionObject_dump_debug_info, + METH_VARARGS, + _mysql_ConnectionObject_dump_debug_info__doc__ + }, + { + "escape", + (PyCFunction)_mysql_escape, + METH_VARARGS, + _mysql_escape__doc__ + }, + { + "escape_string", + (PyCFunction)_mysql_escape_string, + METH_VARARGS, + _mysql_escape_string__doc__ + }, + { + "error", + (PyCFunction)_mysql_ConnectionObject_error, + METH_VARARGS, + _mysql_ConnectionObject_error__doc__ + }, + { + "errno", + (PyCFunction)_mysql_ConnectionObject_errno, + METH_VARARGS, + _mysql_ConnectionObject_errno__doc__ + }, + { + "field_count", + (PyCFunction)_mysql_ConnectionObject_field_count, + METH_VARARGS, + _mysql_ConnectionObject_field_count__doc__ + }, + { + "get_host_info", + (PyCFunction)_mysql_ConnectionObject_get_host_info, + METH_VARARGS, + _mysql_ConnectionObject_get_host_info__doc__ + }, + { + "get_proto_info", + (PyCFunction)_mysql_ConnectionObject_get_proto_info, + METH_VARARGS, + _mysql_ConnectionObject_get_proto_info__doc__ + }, + { + "get_server_info", + (PyCFunction)_mysql_ConnectionObject_get_server_info, + METH_VARARGS, + _mysql_ConnectionObject_get_server_info__doc__ + }, + { + "info", + (PyCFunction)_mysql_ConnectionObject_info, + METH_VARARGS, + _mysql_ConnectionObject_info__doc__ + }, + { + "insert_id", + (PyCFunction)_mysql_ConnectionObject_insert_id, + METH_VARARGS, + _mysql_ConnectionObject_insert_id__doc__ + }, + { + "kill", + (PyCFunction)_mysql_ConnectionObject_kill, + METH_VARARGS, + _mysql_ConnectionObject_kill__doc__ + }, + { + "ping", + (PyCFunction)_mysql_ConnectionObject_ping, + METH_VARARGS, + _mysql_ConnectionObject_ping__doc__ + }, + { + "query", + (PyCFunction)_mysql_ConnectionObject_query, + METH_VARARGS, + _mysql_ConnectionObject_query__doc__ + }, + { + "select_db", + (PyCFunction)_mysql_ConnectionObject_select_db, + METH_VARARGS, + _mysql_ConnectionObject_select_db__doc__ + }, + { + "shutdown", + (PyCFunction)_mysql_ConnectionObject_shutdown, + METH_VARARGS, + _mysql_ConnectionObject_shutdown__doc__ + }, + { + "stat", + (PyCFunction)_mysql_ConnectionObject_stat, + METH_VARARGS, + _mysql_ConnectionObject_stat__doc__ + }, + { + "store_result", + (PyCFunction)_mysql_ConnectionObject_store_result, + METH_VARARGS, + _mysql_ConnectionObject_store_result__doc__ + }, + { + "string_literal", + (PyCFunction)_mysql_string_literal, + METH_VARARGS, + _mysql_string_literal__doc__}, + { + "thread_id", + (PyCFunction)_mysql_ConnectionObject_thread_id, + METH_VARARGS, + _mysql_ConnectionObject_thread_id__doc__ + }, + { + "use_result", + (PyCFunction)_mysql_ConnectionObject_use_result, + METH_VARARGS, + _mysql_ConnectionObject_use_result__doc__ + }, + {NULL, NULL} /* sentinel */ +}; + +static MyMemberlist(_mysql_ConnectionObject_memberlist)[] = { + MyMember( + "open", + T_INT, + offsetof(_mysql_ConnectionObject,open), + RO, + "True if connection is open" + ), + MyMember( + "converter", + T_OBJECT, + offsetof(_mysql_ConnectionObject,converter), + 0, + "Type conversion mapping" + ), + MyMember( + "server_capabilities", + T_UINT, + offsetof(_mysql_ConnectionObject,connection.server_capabilities), + RO, + "Capabilites of server; consult MySQLdb.constants.CLIENT" + ), + MyMember( + "port", + T_UINT, + offsetof(_mysql_ConnectionObject,connection.port), + RO, + "TCP/IP port of the server connection" + ), + MyMember( + "client_flag", + T_UINT, + RO, + offsetof(_mysql_ConnectionObject,connection.client_flag), + "Client flags; refer to MySQLdb.constants.CLIENT" + ), + {NULL} /* Sentinel */ +}; + +static PyMethodDef _mysql_ResultObject_methods[] = { + { + "data_seek", + (PyCFunction)_mysql_ResultObject_data_seek, + METH_VARARGS, + _mysql_ResultObject_data_seek__doc__ + }, + { + "row_seek", + (PyCFunction)_mysql_ResultObject_row_seek, + METH_VARARGS, + _mysql_ResultObject_row_seek__doc__ + }, + { + "row_tell", + (PyCFunction)_mysql_ResultObject_row_tell, + METH_VARARGS, + _mysql_ResultObject_row_tell__doc__ + }, + { + "describe", + (PyCFunction)_mysql_ResultObject_describe, + METH_VARARGS, + _mysql_ResultObject_describe__doc__ + }, + { + "fetch_row", + (PyCFunction)_mysql_ResultObject_fetch_row, + METH_VARARGS | METH_KEYWORDS, + _mysql_ResultObject_fetch_row__doc__ + }, + { + "field_flags", + (PyCFunction)_mysql_ResultObject_field_flags, + METH_VARARGS, + _mysql_ResultObject_field_flags__doc__ + }, + { + "num_fields", + (PyCFunction)_mysql_ResultObject_num_fields, + METH_VARARGS, + _mysql_ResultObject_num_fields__doc__ + }, + { + "num_rows", + (PyCFunction)_mysql_ResultObject_num_rows, + METH_VARARGS, + _mysql_ResultObject_num_rows__doc__ + }, + {NULL, NULL} /* sentinel */ +}; + +static MyMemberlist(_mysql_ResultObject_memberlist)[] = { + MyMember( + "converter", + T_OBJECT, + offsetof(_mysql_ResultObject,converter), + RO, + "Type conversion mapping" + ), + {NULL} /* Sentinel */ +}; + +static PyObject * +_mysql_ConnectionObject_getattr( + _mysql_ConnectionObject *self, + char *name) +{ + PyObject *res; + + res = Py_FindMethod(_mysql_ConnectionObject_methods, (PyObject *)self, name); + if (res != NULL) + return res; + PyErr_Clear(); + if (strcmp(name, "closed") == 0) + return PyInt_FromLong((long)!(self->open)); +#if PY_VERSION_HEX < 0x02020000 + return PyMember_Get((char *)self, _mysql_ConnectionObject_memberlist, name); +#else + { + MyMemberlist(*l); + for (l = _mysql_ConnectionObject_memberlist; l->name != NULL; l++) { + if (strcmp(l->name, name) == 0) + return PyMember_GetOne((char *)self, l); + } + PyErr_SetString(PyExc_AttributeError, name); + return NULL; + } +#endif +} + +static PyObject * +_mysql_ResultObject_getattr( + _mysql_ResultObject *self, + char *name) +{ + PyObject *res; + + res = Py_FindMethod(_mysql_ResultObject_methods, (PyObject *)self, name); + if (res != NULL) + return res; + PyErr_Clear(); +#if PY_VERSION_HEX < 0x02020000 + return PyMember_Get((char *)self, _mysql_ResultObject_memberlist, name); +#else + { + MyMemberlist(*l); + for (l = _mysql_ResultObject_memberlist; l->name != NULL; l++) { + if (strcmp(l->name, name) == 0) + return PyMember_GetOne((char *)self, l); + } + PyErr_SetString(PyExc_AttributeError, name); + return NULL; + } +#endif +} + +static int +_mysql_ConnectionObject_setattr( + _mysql_ConnectionObject *self, + char *name, + PyObject *v) +{ + if (v == NULL) { + PyErr_SetString(PyExc_AttributeError, + "can't delete connection attributes"); + return -1; + } +#if PY_VERSION_HEX < 0x02020000 + return PyMember_Set((char *)self, _mysql_ConnectionObject_memberlist, name, v); +#else + { + MyMemberlist(*l); + for (l = _mysql_ConnectionObject_memberlist; l->name != NULL; l++) + if (strcmp(l->name, name) == 0) + return PyMember_SetOne((char *)self, l, v); + } + PyErr_SetString(PyExc_AttributeError, name); + return -1; +#endif +} + +static int +_mysql_ResultObject_setattr( + _mysql_ResultObject *self, + char *name, + PyObject *v) +{ + if (v == NULL) { + PyErr_SetString(PyExc_AttributeError, + "can't delete connection attributes"); + return -1; + } +#if PY_VERSION_HEX < 0x02020000 + return PyMember_Set((char *)self, _mysql_ResultObject_memberlist, name, v); +#else + { + MyMemberlist(*l); + for (l = _mysql_ResultObject_memberlist; l->name != NULL; l++) + if (strcmp(l->name, name) == 0) + return PyMember_SetOne((char *)self, l, v); + } + PyErr_SetString(PyExc_AttributeError, name); + return -1; +#endif +} + +PyTypeObject _mysql_ConnectionObject_Type = { + PyObject_HEAD_INIT(NULL) + 0, + "_mysql.connection", /* (char *)tp_name For printing */ + sizeof(_mysql_ConnectionObject), + 0, + (destructor)_mysql_ConnectionObject_dealloc, /* tp_dealloc */ + 0, /*tp_print*/ + (getattrfunc)_mysql_ConnectionObject_getattr, /* tp_getattr */ + (setattrfunc)_mysql_ConnectionObject_setattr, /* tp_setattr */ + 0, /*tp_compare*/ + (reprfunc)_mysql_ConnectionObject_repr, /* tp_repr */ + + /* Method suites for standard classes */ + + 0, /* (PyNumberMethods *) tp_as_number */ + 0, /* (PySequenceMethods *) tp_as_sequence */ + 0, /* (PyMappingMethods *) tp_as_mapping */ + + /* More standard operations (here for binary compatibility) */ + + 0, /* (hashfunc) tp_hash */ + 0, /* (ternaryfunc) tp_call */ + 0, /* (reprfunc) tp_str */ + 0, /* (getattrofunc) tp_getattro */ + 0, /* (setattrofunc) tp_setattro */ + + /* Functions to access object as input/output buffer */ + 0, /* (PyBufferProcs *) tp_as_buffer */ + + /* Flags to define presence of optional/expanded features */ +#if PY_VERSION_HEX < 0x02020000 + Py_TPFLAGS_DEFAULT, /* (long) tp_flags */ +#else + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, +#endif + _mysql_connect__doc__, /* (char *) tp_doc Documentation string */ +#if PY_VERSION_HEX >= 0x02000000 + /* Assigned meaning in release 2.0 */ +#if PY_VERSION_HEX >= 0x02020000 + /* call function for all accessible objects */ + (traverseproc) _mysql_ConnectionObject_traverse, /* tp_traverse */ + + /* delete references to contained objects */ + (inquiry) _mysql_ConnectionObject_clear, /* tp_clear */ +#else + /* not supporting pre-2.2 GC */ + 0, + 0, +#endif +#if PY_VERSION_HEX >= 0x02010000 + /* Assigned meaning in release 2.1 */ + /* rich comparisons */ + 0, /* (richcmpfunc) tp_richcompare */ + + /* weak reference enabler */ + 0, /* (long) tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + /* Added in release 2.2 */ + /* Iterators */ + 0, /* (getiterfunc) tp_iter */ + 0, /* (iternextfunc) tp_iternext */ + + /* Attribute descriptor and subclassing stuff */ + (struct PyMethodDef *)_mysql_ConnectionObject_methods, /* tp_methods */ + (MyMemberlist(*))_mysql_ConnectionObject_memberlist, /* tp_members */ + 0, /* (struct getsetlist *) tp_getset; */ + 0, /* (struct _typeobject *) tp_base; */ + 0, /* (PyObject *) tp_dict */ + 0, /* (descrgetfunc) tp_descr_get */ + 0, /* (descrsetfunc) tp_descr_set */ + 0, /* (long) tp_dictoffset */ + (initproc)_mysql_ConnectionObject_Initialize, /* tp_init */ + NULL, /* tp_alloc */ + NULL, /* tp_new */ + NULL, /* tp_free Low-level free-memory routine */ + 0, /* (PyObject *) tp_bases */ + 0, /* (PyObject *) tp_mro method resolution order */ + 0, /* (PyObject *) tp_defined */ +#endif /* python 2.2 */ +#endif /* python 2.1 */ +#endif /* python 2.0 */ +} ; + +PyTypeObject _mysql_ResultObject_Type = { + PyObject_HEAD_INIT(NULL) + 0, + "_mysql.result", + sizeof(_mysql_ResultObject), + 0, + (destructor)_mysql_ResultObject_dealloc, /* tp_dealloc */ + 0, /*tp_print*/ + (getattrfunc)_mysql_ResultObject_getattr, /* tp_getattr */ + (setattrfunc)_mysql_ResultObject_setattr, /* tp_setattr */ + 0, /*tp_compare*/ + (reprfunc)_mysql_ResultObject_repr, /* tp_repr */ + + /* Method suites for standard classes */ + + 0, /* (PyNumberMethods *) tp_as_number */ + 0, /* (PySequenceMethods *) tp_as_sequence */ + 0, /* (PyMappingMethods *) tp_as_mapping */ + + /* More standard operations (here for binary compatibility) */ + + 0, /* (hashfunc) tp_hash */ + 0, /* (ternaryfunc) tp_call */ + 0, /* (reprfunc) tp_str */ + 0, /* (getattrofunc) tp_getattro */ + 0, /* (setattrofunc) tp_setattro */ + + /* Functions to access object as input/output buffer */ + 0, /* (PyBufferProcs *) tp_as_buffer */ + + /* Flags to define presence of optional/expanded features */ +#if PY_VERSION_HEX < 0x02020000 + Py_TPFLAGS_DEFAULT, /* (long) tp_flags */ +#else + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, +#endif + + _mysql_ResultObject__doc__, /* (char *) tp_doc Documentation string */ +#if PY_VERSION_HEX >= 0x02000000 + /* Assigned meaning in release 2.0 */ +#if PY_VERSION_HEX >= 0x02020000 + /* call function for all accessible objects */ + (traverseproc) _mysql_ResultObject_traverse, /* tp_traverse */ + + /* delete references to contained objects */ + (inquiry) _mysql_ResultObject_clear, /* tp_clear */ +#else + /* not supporting pre-2.2 GC */ + 0, + 0, +#endif +#if PY_VERSION_HEX >= 0x02010000 + /* Assigned meaning in release 2.1 */ + /* rich comparisons */ + 0, /* (richcmpfunc) tp_richcompare */ + + /* weak reference enabler */ + 0, /* (long) tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + /* Added in release 2.2 */ + /* Iterators */ + 0, /* (getiterfunc) tp_iter */ + 0, /* (iternextfunc) tp_iternext */ + + /* Attribute descriptor and subclassing stuff */ + (struct PyMethodDef *) _mysql_ResultObject_methods, /* tp_methods */ + (MyMemberlist(*)) _mysql_ResultObject_memberlist, /*tp_members */ + 0, /* (struct getsetlist *) tp_getset; */ + 0, /* (struct _typeobject *) tp_base; */ + 0, /* (PyObject *) tp_dict */ + 0, /* (descrgetfunc) tp_descr_get */ + 0, /* (descrsetfunc) tp_descr_set */ + 0, /* (long) tp_dictoffset */ + (initproc)_mysql_ResultObject_Initialize, /* tp_init */ + NULL, /* tp_alloc */ + NULL, /* tp_new */ + NULL, /* tp_free Low-level free-memory routine */ + 0, /* (PyObject *) tp_bases */ + 0, /* (PyObject *) tp_mro method resolution order */ + 0, /* (PyObject *) tp_defined */ +#endif /* python 2.2 */ +#endif /* python 2.1 */ +#endif /* python 2.0 */ +}; + +static PyMethodDef +_mysql_methods[] = { + { + "connect", + (PyCFunction)_mysql_connect, + METH_VARARGS | METH_KEYWORDS, + _mysql_connect__doc__ + }, + { + "debug", + (PyCFunction)_mysql_debug, + METH_VARARGS, + _mysql_debug__doc__ + }, + { + "escape", + (PyCFunction)_mysql_escape, + METH_VARARGS, + _mysql_escape__doc__ + }, + { + "escape_sequence", + (PyCFunction)_mysql_escape_sequence, + METH_VARARGS, + _mysql_escape_sequence__doc__ + }, + { + "escape_dict", + (PyCFunction)_mysql_escape_dict, + METH_VARARGS, + _mysql_escape_dict__doc__ + }, + { + "escape_string", + (PyCFunction)_mysql_escape_string, + METH_VARARGS, + _mysql_escape_string__doc__ + }, + { + "string_literal", + (PyCFunction)_mysql_string_literal, + METH_VARARGS, + _mysql_string_literal__doc__ + }, + { + "get_client_info", + (PyCFunction)_mysql_get_client_info, + METH_VARARGS, + _mysql_get_client_info__doc__ + }, +#if MYSQL_VERSION_ID >= 32314 + { + "thread_safe", + (PyCFunction)_mysql_thread_safe, + METH_VARARGS, + _mysql_thread_safe__doc__ + }, +#endif + { + "server_init", + (PyCFunction)_mysql_server_init, + METH_VARARGS | METH_KEYWORDS, + _mysql_server_init__doc__ + }, + { + "server_end", + (PyCFunction)_mysql_server_end, + METH_VARARGS, + _mysql_server_end__doc__ + }, + {NULL, NULL} /* sentinel */ +}; + +static PyObject * +_mysql_NewException( + PyObject *dict, + PyObject *edict, + char *name) +{ + PyObject *e; + + if (!(e = PyDict_GetItemString(edict, name))) + return NULL; + if (PyDict_SetItemString(dict, name, e)) return NULL; + return e; +} + +#define QUOTE(X) _QUOTE(X) +#define _QUOTE(X) #X + +static char _mysql___doc__[] = +"an adaptation of the MySQL C API (mostly)\n\ +\n\ +You probably are better off using MySQLdb instead of using this\n\ +module directly.\n\ +\n\ +In general, renaming goes from mysql_* to _mysql.*. _mysql.connect()\n\ +returns a connection object (MYSQL). Functions which expect MYSQL * as\n\ +an argument are now methods of the connection object. A number of things\n\ +return result objects (MYSQL_RES). Functions which expect MYSQL_RES * as\n\ +an argument are now methods of the result object. Deprecated functions\n\ +(as of 3.23) are NOT implemented.\n\ +"; + +DL_EXPORT(void) +init_mysql(void) +{ + PyObject *dict, *module, *emod, *edict; + module = Py_InitModule4("_mysql", _mysql_methods, _mysql___doc__, + (PyObject *)NULL, PYTHON_API_VERSION); + if (!module) return; /* this really should never happen */ + _mysql_ConnectionObject_Type.ob_type = &PyType_Type; + _mysql_ResultObject_Type.ob_type = &PyType_Type; +#if PY_VERSION_HEX >= 0x02020000 + _mysql_ConnectionObject_Type.tp_alloc = PyType_GenericAlloc; + _mysql_ConnectionObject_Type.tp_new = PyType_GenericNew; + _mysql_ConnectionObject_Type.tp_free = _PyObject_GC_Del; + _mysql_ResultObject_Type.tp_alloc = PyType_GenericAlloc; + _mysql_ResultObject_Type.tp_new = PyType_GenericNew; + _mysql_ResultObject_Type.tp_free = _PyObject_GC_Del; +#endif + + if (!(dict = PyModule_GetDict(module))) goto error; + if (PyDict_SetItemString(dict, "version_info", + PyRun_String(QUOTE(version_info), Py_eval_input, + dict, dict))) + goto error; + if (PyDict_SetItemString(dict, "__version__", + PyString_FromString(QUOTE(__version__)))) + goto error; + if (PyDict_SetItemString(dict, "connection", + (PyObject *)&_mysql_ConnectionObject_Type)) + goto error; + Py_INCREF(&_mysql_ConnectionObject_Type); + if (PyDict_SetItemString(dict, "result", + (PyObject *)&_mysql_ResultObject_Type)) + goto error; + Py_INCREF(&_mysql_ResultObject_Type); + if (!(emod = PyImport_ImportModule("_mysql_exceptions"))) + goto error; + if (!(edict = PyModule_GetDict(emod))) goto error; + if (!(_mysql_MySQLError = + _mysql_NewException(dict, edict, "MySQLError"))) + goto error; + if (!(_mysql_Warning = + _mysql_NewException(dict, edict, "Warning"))) + goto error; + if (!(_mysql_Error = + _mysql_NewException(dict, edict, "Error"))) + goto error; + if (!(_mysql_InterfaceError = + _mysql_NewException(dict, edict, "InterfaceError"))) + goto error; + if (!(_mysql_DatabaseError = + _mysql_NewException(dict, edict, "DatabaseError"))) + goto error; + if (!(_mysql_DataError = + _mysql_NewException(dict, edict, "DataError"))) + goto error; + if (!(_mysql_OperationalError = + _mysql_NewException(dict, edict, "OperationalError"))) + goto error; + if (!(_mysql_IntegrityError = + _mysql_NewException(dict, edict, "IntegrityError"))) + goto error; + if (!(_mysql_InternalError = + _mysql_NewException(dict, edict, "InternalError"))) + goto error; + if (!(_mysql_ProgrammingError = + _mysql_NewException(dict, edict, "ProgrammingError"))) + goto error; + if (!(_mysql_NotSupportedError = + _mysql_NewException(dict, edict, "NotSupportedError"))) + goto error; + Py_DECREF(emod); + if (!(_mysql_NULL = PyString_FromString("NULL"))) + goto error; + if (PyDict_SetItemString(dict, "NULL", _mysql_NULL)) goto error; + error: + if (PyErr_Occurred()) + PyErr_SetString(PyExc_ImportError, + "_mysql: init failed"); + return; +} + + diff --git a/MySQLdb/_mysql_exceptions.py b/MySQLdb/_mysql_exceptions.py new file mode 100644 index 0000000..98037e5 --- /dev/null +++ b/MySQLdb/_mysql_exceptions.py @@ -0,0 +1,83 @@ +"""_mysql_exceptions: Exception classes for _mysql and MySQLdb. + +These classes are dictated by the DB API v2.0: + + http://www.python.org/topics/database/DatabaseAPI-2.0.html +""" + +from exceptions import Exception, StandardError, Warning + +class MySQLError(StandardError): + + """Exception related to operation with MySQL.""" + + +class Warning(Warning, MySQLError): + + """Exception raised for important warnings like data truncations + while inserting, etc.""" + +class Error(MySQLError): + + """Exception that is the base class of all other error exceptions + (not Warning).""" + + +class InterfaceError(Error): + + """Exception raised for errors that are related to the database + interface rather than the database itself.""" + + +class DatabaseError(Error): + + """Exception raised for errors that are related to the + database.""" + + +class DataError(DatabaseError): + + """Exception raised for errors that are due to problems with the + processed data like division by zero, numeric value out of range, + etc.""" + + +class OperationalError(DatabaseError): + + """Exception raised for errors that are related to the database's + operation and not necessarily under the control of the programmer, + e.g. an unexpected disconnect occurs, the data source name is not + found, a transaction could not be processed, a memory allocation + error occurred during processing, etc.""" + + +class IntegrityError(DatabaseError): + + """Exception raised when the relational integrity of the database + is affected, e.g. a foreign key check fails, duplicate key, + etc.""" + + +class InternalError(DatabaseError): + + """Exception raised when the database encounters an internal + error, e.g. the cursor is not valid anymore, the transaction is + out of sync, etc.""" + + +class ProgrammingError(DatabaseError): + + """Exception raised for programming errors, e.g. table not found + or already exists, syntax error in the SQL statement, wrong number + of parameters specified, etc.""" + + +class NotSupportedError(DatabaseError): + + """Exception raised in case a method or database API was used + which is not supported by the database, e.g. requesting a + .rollback() on a connection that does not support transaction or + has transactions turned off.""" + + +del Exception, StandardError diff --git a/MySQLdb/dbapi20.py b/MySQLdb/dbapi20.py new file mode 100644 index 0000000..5cde6d6 --- /dev/null +++ b/MySQLdb/dbapi20.py @@ -0,0 +1,853 @@ +#!/usr/bin/env python +''' Python DB API 2.0 driver compliance unit test suite. + + This software is Public Domain and may be used without restrictions. + + "Now we have booze and barflies entering the discussion, plus rumours of + DBAs on drugs... and I won't tell you what flashes through my mind each + time I read the subject line with 'Anal Compliance' in it. All around + this is turning out to be a thoroughly unwholesome unit test." + + -- Ian Bicking +''' + +__rcs_id__ = '$Id$' +__version__ = '$Revision$'[11:-2] +__author__ = 'Stuart Bishop <zen@shangri-la.dropbear.id.au>' + +import unittest +import time + +# $Log$ +# Revision 1.1.2.1 2006/02/25 03:44:32 adustman +# Generic DB-API unit test module +# +# Revision 1.10 2003/10/09 03:14:14 zenzen +# Add test for DB API 2.0 optional extension, where database exceptions +# are exposed as attributes on the Connection object. +# +# Revision 1.9 2003/08/13 01:16:36 zenzen +# Minor tweak from Stefan Fleiter +# +# Revision 1.8 2003/04/10 00:13:25 zenzen +# Changes, as per suggestions by M.-A. Lemburg +# - Add a table prefix, to ensure namespace collisions can always be avoided +# +# Revision 1.7 2003/02/26 23:33:37 zenzen +# Break out DDL into helper functions, as per request by David Rushby +# +# Revision 1.6 2003/02/21 03:04:33 zenzen +# Stuff from Henrik Ekelund: +# added test_None +# added test_nextset & hooks +# +# Revision 1.5 2003/02/17 22:08:43 zenzen +# Implement suggestions and code from Henrik Eklund - test that cursor.arraysize +# defaults to 1 & generic cursor.callproc test added +# +# Revision 1.4 2003/02/15 00:16:33 zenzen +# Changes, as per suggestions and bug reports by M.-A. Lemburg, +# Matthew T. Kromer, Federico Di Gregorio and Daniel Dittmar +# - Class renamed +# - Now a subclass of TestCase, to avoid requiring the driver stub +# to use multiple inheritance +# - Reversed the polarity of buggy test in test_description +# - Test exception heirarchy correctly +# - self.populate is now self._populate(), so if a driver stub +# overrides self.ddl1 this change propogates +# - VARCHAR columns now have a width, which will hopefully make the +# DDL even more portible (this will be reversed if it causes more problems) +# - cursor.rowcount being checked after various execute and fetchXXX methods +# - Check for fetchall and fetchmany returning empty lists after results +# are exhausted (already checking for empty lists if select retrieved +# nothing +# - Fix bugs in test_setoutputsize_basic and test_setinputsizes +# + +class DatabaseAPI20Test(unittest.TestCase): + ''' Test a database self.driver for DB API 2.0 compatibility. + This implementation tests Gadfly, but the TestCase + is structured so that other self.drivers can subclass this + test case to ensure compiliance with the DB-API. It is + expected that this TestCase may be expanded in the future + if ambiguities or edge conditions are discovered. + + The 'Optional Extensions' are not yet being tested. + + self.drivers should subclass this test, overriding setUp, tearDown, + self.driver, connect_args and connect_kw_args. Class specification + should be as follows: + + import dbapi20 + class mytest(dbapi20.DatabaseAPI20Test): + [...] + + Don't 'import DatabaseAPI20Test from dbapi20', or you will + confuse the unit tester - just 'import dbapi20'. + ''' + + # The self.driver module. This should be the module where the 'connect' + # method is to be found + driver = None + connect_args = () # List of arguments to pass to connect + connect_kw_args = {} # Keyword arguments for connect + table_prefix = 'dbapi20test_' # If you need to specify a prefix for tables + + ddl1 = 'create table %sbooze (name varchar(20))' % table_prefix + ddl2 = 'create table %sbarflys (name varchar(20))' % table_prefix + xddl1 = 'drop table %sbooze' % table_prefix + xddl2 = 'drop table %sbarflys' % table_prefix + + lowerfunc = 'lower' # Name of stored procedure to convert string->lowercase + + # Some drivers may need to override these helpers, for example adding + # a 'commit' after the execute. + def executeDDL1(self,cursor): + cursor.execute(self.ddl1) + + def executeDDL2(self,cursor): + cursor.execute(self.ddl2) + + def setUp(self): + ''' self.drivers should override this method to perform required setup + if any is necessary, such as creating the database. + ''' + pass + + def tearDown(self): + ''' self.drivers should override this method to perform required cleanup + if any is necessary, such as deleting the test database. + The default drops the tables that may be created. + ''' + con = self._connect() + try: + cur = con.cursor() + for ddl in (self.xddl1,self.xddl2): + try: + cur.execute(ddl) + con.commit() + except self.driver.Error: + # Assume table didn't exist. Other tests will check if + # execute is busted. + pass + finally: + con.close() + + def _connect(self): + try: + return self.driver.connect( + *self.connect_args,**self.connect_kw_args + ) + except AttributeError: + self.fail("No connect method found in self.driver module") + + def test_connect(self): + con = self._connect() + con.close() + + def test_apilevel(self): + try: + # Must exist + apilevel = self.driver.apilevel + # Must equal 2.0 + self.assertEqual(apilevel,'2.0') + except AttributeError: + self.fail("Driver doesn't define apilevel") + + def test_threadsafety(self): + try: + # Must exist + threadsafety = self.driver.threadsafety + # Must be a valid value + self.failUnless(threadsafety in (0,1,2,3)) + except AttributeError: + self.fail("Driver doesn't define threadsafety") + + def test_paramstyle(self): + try: + # Must exist + paramstyle = self.driver.paramstyle + # Must be a valid value + self.failUnless(paramstyle in ( + 'qmark','numeric','named','format','pyformat' + )) + except AttributeError: + self.fail("Driver doesn't define paramstyle") + + def test_Exceptions(self): + # Make sure required exceptions exist, and are in the + # defined heirarchy. + self.failUnless(issubclass(self.driver.Warning,StandardError)) + self.failUnless(issubclass(self.driver.Error,StandardError)) + self.failUnless( + issubclass(self.driver.InterfaceError,self.driver.Error) + ) + self.failUnless( + issubclass(self.driver.DatabaseError,self.driver.Error) + ) + self.failUnless( + issubclass(self.driver.OperationalError,self.driver.Error) + ) + self.failUnless( + issubclass(self.driver.IntegrityError,self.driver.Error) + ) + self.failUnless( + issubclass(self.driver.InternalError,self.driver.Error) + ) + self.failUnless( + issubclass(self.driver.ProgrammingError,self.driver.Error) + ) + self.failUnless( + issubclass(self.driver.NotSupportedError,self.driver.Error) + ) + + def test_ExceptionsAsConnectionAttributes(self): + # OPTIONAL EXTENSION + # Test for the optional DB API 2.0 extension, where the exceptions + # are exposed as attributes on the Connection object + # I figure this optional extension will be implemented by any + # driver author who is using this test suite, so it is enabled + # by default. + con = self._connect() + drv = self.driver + self.failUnless(con.Warning is drv.Warning) + self.failUnless(con.Error is drv.Error) + self.failUnless(con.InterfaceError is drv.InterfaceError) + self.failUnless(con.DatabaseError is drv.DatabaseError) + self.failUnless(con.OperationalError is drv.OperationalError) + self.failUnless(con.IntegrityError is drv.IntegrityError) + self.failUnless(con.InternalError is drv.InternalError) + self.failUnless(con.ProgrammingError is drv.ProgrammingError) + self.failUnless(con.NotSupportedError is drv.NotSupportedError) + + + def test_commit(self): + con = self._connect() + try: + # Commit must work, even if it doesn't do anything + con.commit() + finally: + con.close() + + def test_rollback(self): + con = self._connect() + # If rollback is defined, it should either work or throw + # the documented exception + if hasattr(con,'rollback'): + try: + con.rollback() + except self.driver.NotSupportedError: + pass + + def test_cursor(self): + con = self._connect() + try: + cur = con.cursor() + finally: + con.close() + + def test_cursor_isolation(self): + con = self._connect() + try: + # Make sure cursors created from the same connection have + # the documented transaction isolation level + cur1 = con.cursor() + cur2 = con.cursor() + self.executeDDL1(cur1) + cur1.execute("insert into %sbooze values ('Victoria Bitter')" % ( + self.table_prefix + )) + cur2.execute("select name from %sbooze" % self.table_prefix) + booze = cur2.fetchall() + self.assertEqual(len(booze),1) + self.assertEqual(len(booze[0]),1) + self.assertEqual(booze[0][0],'Victoria Bitter') + finally: + con.close() + + def test_description(self): + con = self._connect() + try: + cur = con.cursor() + self.executeDDL1(cur) + self.assertEqual(cur.description,None, + 'cursor.description should be none after executing a ' + 'statement that can return no rows (such as DDL)' + ) + cur.execute('select name from %sbooze' % self.table_prefix) + self.assertEqual(len(cur.description),1, + 'cursor.description describes too many columns' + ) + self.assertEqual(len(cur.description[0]),7, + 'cursor.description[x] tuples must have 7 elements' + ) + self.assertEqual(cur.description[0][0].lower(),'name', + 'cursor.description[x][0] must return column name' + ) + self.assertEqual(cur.description[0][1],self.driver.STRING, + 'cursor.description[x][1] must return column type. Got %r' + % cur.description[0][1] + ) + + # Make sure self.description gets reset + self.executeDDL2(cur) + self.assertEqual(cur.description,None, + 'cursor.description not being set to None when executing ' + 'no-result statements (eg. DDL)' + ) + finally: + con.close() + + def test_rowcount(self): + con = self._connect() + try: + cur = con.cursor() + self.executeDDL1(cur) + self.assertEqual(cur.rowcount,-1, + 'cursor.rowcount should be -1 after executing no-result ' + 'statements' + ) + cur.execute("insert into %sbooze values ('Victoria Bitter')" % ( + self.table_prefix + )) + self.failUnless(cur.rowcount in (-1,1), + 'cursor.rowcount should == number or rows inserted, or ' + 'set to -1 after executing an insert statement' + ) + cur.execute("select name from %sbooze" % self.table_prefix) + self.failUnless(cur.rowcount in (-1,1), + 'cursor.rowcount should == number of rows returned, or ' + 'set to -1 after executing a select statement' + ) + self.executeDDL2(cur) + self.assertEqual(cur.rowcount,-1, + 'cursor.rowcount not being reset to -1 after executing ' + 'no-result statements' + ) + finally: + con.close() + + lower_func = 'lower' + def test_callproc(self): + con = self._connect() + try: + cur = con.cursor() + if self.lower_func and hasattr(cur,'callproc'): + r = cur.callproc(self.lower_func,('FOO',)) + self.assertEqual(len(r),1) + self.assertEqual(r[0],'FOO') + r = cur.fetchall() + self.assertEqual(len(r),1,'callproc produced no result set') + self.assertEqual(len(r[0]),1, + 'callproc produced invalid result set' + ) + self.assertEqual(r[0][0],'foo', + 'callproc produced invalid results' + ) + finally: + con.close() + + def test_close(self): + con = self._connect() + try: + cur = con.cursor() + finally: + con.close() + + # cursor.execute should raise an Error if called after connection + # closed + self.assertRaises(self.driver.Error,self.executeDDL1,cur) + + # connection.commit should raise an Error if called after connection' + # closed.' + self.assertRaises(self.driver.Error,con.commit) + + # connection.close should raise an Error if called more than once + self.assertRaises(self.driver.Error,con.close) + + def test_execute(self): + con = self._connect() + try: + cur = con.cursor() + self._paraminsert(cur) + finally: + con.close() + + def _paraminsert(self,cur): + self.executeDDL1(cur) + cur.execute("insert into %sbooze values ('Victoria Bitter')" % ( + self.table_prefix + )) + self.failUnless(cur.rowcount in (-1,1)) + + if self.driver.paramstyle == 'qmark': + cur.execute( + 'insert into %sbooze values (?)' % self.table_prefix, + ("Cooper's",) + ) + elif self.driver.paramstyle == 'numeric': + cur.execute( + 'insert into %sbooze values (:1)' % self.table_prefix, + ("Cooper's",) + ) + elif self.driver.paramstyle == 'named': + cur.execute( + 'insert into %sbooze values (:beer)' % self.table_prefix, + {'beer':"Cooper's"} + ) + elif self.driver.paramstyle == 'format': + cur.execute( + 'insert into %sbooze values (%%s)' % self.table_prefix, + ("Cooper's",) + ) + elif self.driver.paramstyle == 'pyformat': + cur.execute( + 'insert into %sbooze values (%%(beer)s)' % self.table_prefix, + {'beer':"Cooper's"} + ) + else: + self.fail('Invalid paramstyle') + self.failUnless(cur.rowcount in (-1,1)) + + cur.execute('select name from %sbooze' % self.table_prefix) + res = cur.fetchall() + self.assertEqual(len(res),2,'cursor.fetchall returned too few rows') + beers = [res[0][0],res[1][0]] + beers.sort() + self.assertEqual(beers[0],"Cooper's", + 'cursor.fetchall retrieved incorrect data, or data inserted ' + 'incorrectly' + ) + self.assertEqual(beers[1],"Victoria Bitter", + 'cursor.fetchall retrieved incorrect data, or data inserted ' + 'incorrectly' + ) + + def test_executemany(self): + con = self._connect() + try: + cur = con.cursor() + self.executeDDL1(cur) + largs = [ ("Cooper's",) , ("Boag's",) ] + margs = [ {'beer': "Cooper's"}, {'beer': "Boag's"} ] + if self.driver.paramstyle == 'qmark': + cur.executemany( + 'insert into %sbooze values (?)' % self.table_prefix, + largs + ) + elif self.driver.paramstyle == 'numeric': + cur.executemany( + 'insert into %sbooze values (:1)' % self.table_prefix, + largs + ) + elif self.driver.paramstyle == 'named': + cur.executemany( + 'insert into %sbooze values (:beer)' % self.table_prefix, + margs + ) + elif self.driver.paramstyle == 'format': + cur.executemany( + 'insert into %sbooze values (%%s)' % self.table_prefix, + largs + ) + elif self.driver.paramstyle == 'pyformat': + cur.executemany( + 'insert into %sbooze values (%%(beer)s)' % ( + self.table_prefix + ), + margs + ) + else: + self.fail('Unknown paramstyle') + self.failUnless(cur.rowcount in (-1,2), + 'insert using cursor.executemany set cursor.rowcount to ' + 'incorrect value %r' % cur.rowcount + ) + cur.execute('select name from %sbooze' % self.table_prefix) + res = cur.fetchall() + self.assertEqual(len(res),2, + 'cursor.fetchall retrieved incorrect number of rows' + ) + beers = [res[0][0],res[1][0]] + beers.sort() + self.assertEqual(beers[0],"Boag's",'incorrect data retrieved') + self.assertEqual(beers[1],"Cooper's",'incorrect data retrieved') + finally: + con.close() + + def test_fetchone(self): + con = self._connect() + try: + cur = con.cursor() + + # cursor.fetchone should raise an Error if called before + # executing a select-type query + self.assertRaises(self.driver.Error,cur.fetchone) + + # cursor.fetchone should raise an Error if called after + # executing a query that cannnot return rows + self.executeDDL1(cur) + self.assertRaises(self.driver.Error,cur.fetchone) + + cur.execute('select name from %sbooze' % self.table_prefix) + self.assertEqual(cur.fetchone(),None, + 'cursor.fetchone should return None if a query retrieves ' + 'no rows' + ) + self.failUnless(cur.rowcount in (-1,0)) + + # cursor.fetchone should raise an Error if called after + # executing a query that cannnot return rows + cur.execute("insert into %sbooze values ('Victoria Bitter')" % ( + self.table_prefix + )) + self.assertRaises(self.driver.Error,cur.fetchone) + + cur.execute('select name from %sbooze' % self.table_prefix) + r = cur.fetchone() + self.assertEqual(len(r),1, + 'cursor.fetchone should have retrieved a single row' + ) + self.assertEqual(r[0],'Victoria Bitter', + 'cursor.fetchone retrieved incorrect data' + ) + self.assertEqual(cur.fetchone(),None, + 'cursor.fetchone should return None if no more rows available' + ) + self.failUnless(cur.rowcount in (-1,1)) + finally: + con.close() + + samples = [ + 'Carlton Cold', + 'Carlton Draft', + 'Mountain Goat', + 'Redback', + 'Victoria Bitter', + 'XXXX' + ] + + def _populate(self): + ''' Return a list of sql commands to setup the DB for the fetch + tests. + ''' + populate = [ + "insert into %sbooze values ('%s')" % (self.table_prefix,s) + for s in self.samples + ] + return populate + + def test_fetchmany(self): + con = self._connect() + try: + cur = con.cursor() + + # cursor.fetchmany should raise an Error if called without + #issuing a query + self.assertRaises(self.driver.Error,cur.fetchmany,4) + + self.executeDDL1(cur) + for sql in self._populate(): + cur.execute(sql) + + cur.execute('select name from %sbooze' % self.table_prefix) + r = cur.fetchmany() + self.assertEqual(len(r),1, + 'cursor.fetchmany retrieved incorrect number of rows, ' + 'default of arraysize is one.' + ) + cur.arraysize=10 + r = cur.fetchmany(3) # Should get 3 rows + self.assertEqual(len(r),3, + 'cursor.fetchmany retrieved incorrect number of rows' + ) + r = cur.fetchmany(4) # Should get 2 more + self.assertEqual(len(r),2, + 'cursor.fetchmany retrieved incorrect number of rows' + ) + r = cur.fetchmany(4) # Should be an empty sequence + self.assertEqual(len(r),0, + 'cursor.fetchmany should return an empty sequence after ' + 'results are exhausted' + ) + self.failUnless(cur.rowcount in (-1,6)) + + # Same as above, using cursor.arraysize + cur.arraysize=4 + cur.execute('select name from %sbooze' % self.table_prefix) + r = cur.fetchmany() # Should get 4 rows + self.assertEqual(len(r),4, + 'cursor.arraysize not being honoured by fetchmany' + ) + r = cur.fetchmany() # Should get 2 more + self.assertEqual(len(r),2) + r = cur.fetchmany() # Should be an empty sequence + self.assertEqual(len(r),0) + self.failUnless(cur.rowcount in (-1,6)) + + cur.arraysize=6 + cur.execute('select name from %sbooze' % self.table_prefix) + rows = cur.fetchmany() # Should get all rows + self.failUnless(cur.rowcount in (-1,6)) + self.assertEqual(len(rows),6) + self.assertEqual(len(rows),6) + rows = [r[0] for r in rows] + rows.sort() + + # Make sure we get the right data back out + for i in range(0,6): + self.assertEqual(rows[i],self.samples[i], + 'incorrect data retrieved by cursor.fetchmany' + ) + + rows = cur.fetchmany() # Should return an empty list + self.assertEqual(len(rows),0, + 'cursor.fetchmany should return an empty sequence if ' + 'called after the whole result set has been fetched' + ) + self.failUnless(cur.rowcount in (-1,6)) + + self.executeDDL2(cur) + cur.execute('select name from %sbarflys' % self.table_prefix) + r = cur.fetchmany() # Should get empty sequence + self.assertEqual(len(r),0, + 'cursor.fetchmany should return an empty sequence if ' + 'query retrieved no rows' + ) + self.failUnless(cur.rowcount in (-1,0)) + + finally: + con.close() + + def test_fetchall(self): + con = self._connect() + try: + cur = con.cursor() + # cursor.fetchall should raise an Error if called + # without executing a query that may return rows (such + # as a select) + self.assertRaises(self.driver.Error, cur.fetchall) + + self.executeDDL1(cur) + for sql in self._populate(): + cur.execute(sql) + + # cursor.fetchall should raise an Error if called + # after executing a a statement that cannot return rows + self.assertRaises(self.driver.Error,cur.fetchall) + + cur.execute('select name from %sbooze' % self.table_prefix) + rows = cur.fetchall() + self.failUnless(cur.rowcount in (-1,len(self.samples))) + self.assertEqual(len(rows),len(self.samples), + 'cursor.fetchall did not retrieve all rows' + ) + rows = [r[0] for r in rows] + rows.sort() + for i in range(0,len(self.samples)): + self.assertEqual(rows[i],self.samples[i], + 'cursor.fetchall retrieved incorrect rows' + ) + rows = cur.fetchall() + self.assertEqual( + len(rows),0, + 'cursor.fetchall should return an empty list if called ' + 'after the whole result set has been fetched' + ) + self.failUnless(cur.rowcount in (-1,len(self.samples))) + + self.executeDDL2(cur) + cur.execute('select name from %sbarflys' % self.table_prefix) + rows = cur.fetchall() + self.failUnless(cur.rowcount in (-1,0)) + self.assertEqual(len(rows),0, + 'cursor.fetchall should return an empty list if ' + 'a select query returns no rows' + ) + + finally: + con.close() + + def test_mixedfetch(self): + con = self._connect() + try: + cur = con.cursor() + self.executeDDL1(cur) + for sql in self._populate(): + cur.execute(sql) + + cur.execute('select name from %sbooze' % self.table_prefix) + rows1 = cur.fetchone() + rows23 = cur.fetchmany(2) + rows4 = cur.fetchone() + rows56 = cur.fetchall() + self.failUnless(cur.rowcount in (-1,6)) + self.assertEqual(len(rows23),2, + 'fetchmany returned incorrect number of rows' + ) + self.assertEqual(len(rows56),2, + 'fetchall returned incorrect number of rows' + ) + + rows = [rows1[0]] + rows.extend([rows23[0][0],rows23[1][0]]) + rows.append(rows4[0]) + rows.extend([rows56[0][0],rows56[1][0]]) + rows.sort() + for i in range(0,len(self.samples)): + self.assertEqual(rows[i],self.samples[i], + 'incorrect data retrieved or inserted' + ) + finally: + con.close() + + def help_nextset_setUp(self,cur): + ''' Should create a procedure called deleteme + that returns two result sets, first the + number of rows in booze then "name from booze" + ''' + raise NotImplementedError,'Helper not implemented' + #sql=""" + # create procedure deleteme as + # begin + # select count(*) from booze + # select name from booze + # end + #""" + #cur.execute(sql) + + def help_nextset_tearDown(self,cur): + 'If cleaning up is needed after nextSetTest' + raise NotImplementedError,'Helper not implemented' + #cur.execute("drop procedure deleteme") + + def test_nextset(self): + con = self._connect() + try: + cur = con.cursor() + if not hasattr(cur,'nextset'): + return + + try: + self.executeDDL1(cur) + sql=self._populate() + for sql in self._populate(): + cur.execute(sql) + + self.help_nextset_setUp(cur) + + cur.callproc('deleteme') + numberofrows=cur.fetchone() + assert numberofrows[0]== len(self.samples) + assert cur.nextset() + names=cur.fetchall() + assert len(names) == len(self.samples) + s=cur.nextset() + assert s == None,'No more return sets, should return None' + finally: + self.help_nextset_tearDown(cur) + + finally: + con.close() + + def test_nextset(self): + raise NotImplementedError,'Drivers need to override this test' + + def test_arraysize(self): + # Not much here - rest of the tests for this are in test_fetchmany + con = self._connect() + try: + cur = con.cursor() + self.failUnless(hasattr(cur,'arraysize'), + 'cursor.arraysize must be defined' + ) + finally: + con.close() + + def test_setinputsizes(self): + con = self._connect() + try: + cur = con.cursor() + cur.setinputsizes( (25,) ) + self._paraminsert(cur) # Make sure cursor still works + finally: + con.close() + + def test_setoutputsize_basic(self): + # Basic test is to make sure setoutputsize doesn't blow up + con = self._connect() + try: + cur = con.cursor() + cur.setoutputsize(1000) + cur.setoutputsize(2000,0) + self._paraminsert(cur) # Make sure the cursor still works + finally: + con.close() + + def test_setoutputsize(self): + # Real test for setoutputsize is driver dependant + raise NotImplementedError,'Driver need to override this test' + + def test_None(self): + con = self._connect() + try: + cur = con.cursor() + self.executeDDL1(cur) + cur.execute('insert into %sbooze values (NULL)' % self.table_prefix) + cur.execute('select name from %sbooze' % self.table_prefix) + r = cur.fetchall() + self.assertEqual(len(r),1) + self.assertEqual(len(r[0]),1) + self.assertEqual(r[0][0],None,'NULL value not returned as None') + finally: + con.close() + + def test_Date(self): + d1 = self.driver.Date(2002,12,25) + d2 = self.driver.DateFromTicks(time.mktime((2002,12,25,0,0,0,0,0,0))) + # Can we assume this? API doesn't specify, but it seems implied + # self.assertEqual(str(d1),str(d2)) + + def test_Time(self): + t1 = self.driver.Time(13,45,30) + t2 = self.driver.TimeFromTicks(time.mktime((2001,1,1,13,45,30,0,0,0))) + # Can we assume this? API doesn't specify, but it seems implied + # self.assertEqual(str(t1),str(t2)) + + def test_Timestamp(self): + t1 = self.driver.Timestamp(2002,12,25,13,45,30) + t2 = self.driver.TimestampFromTicks( + time.mktime((2002,12,25,13,45,30,0,0,0)) + ) + # Can we assume this? API doesn't specify, but it seems implied + # self.assertEqual(str(t1),str(t2)) + + def test_Binary(self): + b = self.driver.Binary('Something') + b = self.driver.Binary('') + + def test_STRING(self): + self.failUnless(hasattr(self.driver,'STRING'), + 'module.STRING must be defined' + ) + + def test_BINARY(self): + self.failUnless(hasattr(self.driver,'BINARY'), + 'module.BINARY must be defined.' + ) + + def test_NUMBER(self): + self.failUnless(hasattr(self.driver,'NUMBER'), + 'module.NUMBER must be defined.' + ) + + def test_DATETIME(self): + self.failUnless(hasattr(self.driver,'DATETIME'), + 'module.DATETIME must be defined.' + ) + + def test_ROWID(self): + self.failUnless(hasattr(self.driver,'ROWID'), + 'module.ROWID must be defined.' + ) + diff --git a/MySQLdb/doc/.cvsignore b/MySQLdb/doc/.cvsignore new file mode 100644 index 0000000..5367f6a --- /dev/null +++ b/MySQLdb/doc/.cvsignore @@ -0,0 +1,2 @@ +*.tex +*.html diff --git a/MySQLdb/doc/FAQ.txt b/MySQLdb/doc/FAQ.txt new file mode 100644 index 0000000..b6a4ce9 --- /dev/null +++ b/MySQLdb/doc/FAQ.txt @@ -0,0 +1,143 @@ +==================================== + MySQLdb Frequently Asked Questions +==================================== + +.. contents:: +.. + + +Build Errors +------------ + + ld: fatal: library -lmysqlclient_r: not found + +mysqlclient_r is the thread-safe library. It's not available on +all platforms, or all installations, apparently. You'll need to +reconfigure site.cfg (in MySQLdb-1.2.1 and newer) to have +threadsafe = False. + + mysql.h: No such file or directory + +This almost always mean you don't have development packages +installed. On some systems, C headers for various things (like MySQL) +are distributed as a seperate package. You'll need to figure out +what that is and install it, but often the name ends with -devel. + +Another possibility: Some older versions of mysql_config behave oddly +and may throw quotes around some of the path names, which confused +MySQLdb-1.2.0. 1.2.1 works around these problems. If you see things +like -I'/usr/local/include/mysql' in your compile command, that's +probably the issue, but it shouldn't happen any more. + + +ImportError +----------- + + ImportError: No module named _mysql + +If you see this, it's likely you did some wrong when installing +MySQLdb; re-read (or read) README. _mysql is the low-level C module +that interfaces with the MySQL client library. + +Various versions of MySQLdb in the past have had build issues on +"weird" platforms; "weird" in this case means "not Linux", though +generally there aren't problems on Unix/POSIX platforms, including +BSDs and Mac OS X. Windows has been more problematic, in part because +there is no `mysql_config` available in the Windows installation of +MySQL. 1.2.1 solves most, if not all, of these problems, but you will +still have to edit a configuration file so that the setup knows where +to find MySQL and what libraries to include. + + + ImportError: libmysqlclient_r.so.14: cannot open shared object file: No such file or directory + +The number after .so may vary, but this means you have a version of +MySQLdb compiled against one version of MySQL, and are now trying to +run it against a different version. The shared library version tends +to change between major releases. + +Solution: Rebuilt MySQLdb, or get the matching version of MySQL. + +Another thing that can cause this: The MySQL libraries may not be on +your system path. + +Solutions: + +* set the LD_LIBRARY_PATH environment variable so that it includes + the path to the MySQL libraries. + +* set static=True in site.cfg for static linking + +* reconfigure your system so that the MySQL libraries are on the + default loader path. In Linux, you edit /etc/ld.so.conf and run + ldconfig. For Solaris, see `Linker and Libraries Guide + <http://docs.sun.com/app/docs/doc/817-3677/6mj8mbtbe?a=view>`_. + + + ImportError: ld.so.1: python: fatal: libmtmalloc.so.1: DF_1_NOOPEN tagged object may not be dlopen()'ed + +This is a weird one from Solaris. What does it mean? I have no idea. +However, things like this can happen if there is some sort of a compiler +or environment mismatch between Python and MySQL. For example, on some +commercial systems, you might have some code compiled with their own +compiler, and other things compiled with GCC. They don't always mesh +together. One way to encounter this is by getting binary packages from +different vendors. + +Solution: Rebuild Python or MySQL (or maybe both) from source. + + ImportError: dlopen(./_mysql.so, 2): Symbol not found: _sprintf$LDBLStub + Referenced from: ./_mysql.so + Expected in: dynamic lookup + +This is one from Mac OS X. It seems to have been a compiler mismatch, +but this time between two different versions of GCC. It seems nearly +every major release of GCC changes the ABI in some why, so linking +code compiled with GCC-3.3 and GCC-4.0, for example, can be +problematic. + + +My data disappeared! (or won't go away!) +---------------------------------------- + +Starting with 1.2.0, MySQLdb disables autocommit by default, as +required by the DB-API standard (`PEP-249`_). If you are using InnoDB +tables or some other type of transactional table type, you'll need +to do connection.commit() before closing the connection, or else +none of your changes will be written to the database. + +Conversely, you can also use connection.rollback() to throw away +any changes you've made since the last commit. + +Important note: Some SQL statements -- specifically DDL statements +like CREATE TABLE -- are non-transactional, so they can't be +rolled back, and they cause pending transactions to commit. + + +Other Errors +------------ + + OperationalError: (1251, 'Client does not support authentication protocol requested by server; consider upgrading MySQL client') + +This means your server and client libraries are not the same version. +More specifically, it probably means you have a 4.1 or newer server +and 4.0 or older client. You can either upgrade the client side, or +try some of the workarounds in `Password Hashing as of MySQL 4.1 +<http://dev.mysql.com/doc/refman/5.0/en/password-hashing.html>`_. + + +Other Resources +--------------- + +* Help forum. Please search before posting. + +* `Google <http://www.google.com/>`_ + +* READ README! + +* Read the User's Guide + +* Read `PEP-249`_ + +.. _`PEP-249`: http://www.python.org/peps/pep-0249.html + diff --git a/MySQLdb/doc/MySQLdb.txt b/MySQLdb/doc/MySQLdb.txt new file mode 100644 index 0000000..fbc86e5 --- /dev/null +++ b/MySQLdb/doc/MySQLdb.txt @@ -0,0 +1,718 @@ +==================== +MySQLdb User's Guide +==================== + +.. contents:: +.. + +Introduction +------------ + +MySQLdb is an thread-compatible interface to the popular MySQL +database server that provides the Python database API. + +Installation +------------ + +The ``README`` file has complete installation instructions. + + +_mysql +------ + +If you want to write applications which are portable across databases, +use MySQLdb_, and avoid using this module directly. ``_mysql`` +provides an interface which mostly implements the MySQL C API. For +more information, see the `MySQL documentation`_. The documentation +for this module is intentionally weak because you probably should use +the higher-level MySQLdb module. If you really need it, use the +standard MySQL docs and transliterate as necessary. + +.. _`MySQL documentation`: http://dev.mysql.com/doc/ + + +MySQL C API translation +....................... + +The MySQL C API has been wrapped in an object-oriented way. The only +MySQL data structures which are implemented are the ``MYSQL`` +(database connection handle) and ``MYSQL_RES`` (result handle) +types. In general, any function which takes ``MYSQL *mysql`` as an +argument is now a method of the connection object, and any function +which takes ``MYSQL_RES *result`` as an argument is a method of the +result object. Functions requiring none of the MySQL data structures +are implemented as functions in the module. Functions requiring one of +the other MySQL data structures are generally not implemented. +Deprecated functions are not implemented. In all cases, the ``mysql_`` +prefix is dropped from the name. Most of the ``conn`` methods listed +are also available as MySQLdb Connection object methods. Their use is +non-portable. + +MySQL C API function mapping +............................ + +=================================== ================================== + C API ``_mysql`` +=================================== ================================== + ``mysql_affected_rows()`` ``conn.affected_rows()`` + ``mysql_autocommit()`` ``conn.autocommit()`` + ``mysql_character_set_name()`` ``conn.character_set_name()`` + ``mysql_close()`` ``conn.close()`` + ``mysql_commit()`` ``conn.commit()`` + ``mysql_connect()`` ``_mysql.connect()`` + ``mysql_data_seek()`` ``result.data_seek()`` + ``mysql_debug()`` ``_mysql.debug()`` + ``mysql_dump_debug_info`` ``conn.dump_debug_info()`` + ``mysql_escape_string()`` ``_mysql.escape_string()`` + ``mysql_fetch_row()`` ``result.fetch_row()`` + ``mysql_get_character_set_info()`` ``conn.get_character_set_info()`` + ``mysql_get_client_info()`` ``_mysql.get_client_info()`` + ``mysql_get_host_info()`` ``conn.get_host_info()`` + ``mysql_get_proto_info()`` ``conn.get_proto_info()`` + ``mysql_get_server_info()`` ``conn.get_server_info()`` + ``mysql_info()`` ``conn.info()`` + ``mysql_insert_id()`` ``conn.insert_id()`` + ``mysql_num_fields()`` ``result.num_fields()`` + ``mysql_num_rows()`` ``result.num_rows()`` + ``mysql_options()`` various options to ``_mysql.connect()`` + ``mysql_ping()`` ``conn.ping()`` + ``mysql_query()`` ``conn.query()`` + ``mysql_real_connect()`` ``_mysql.connect()`` + ``mysql_real_query()`` ``conn.query()`` + ``mysql_real_escape_string()`` ``conn.escape_string()`` + ``mysql_rollback()`` ``conn.rollback()`` + ``mysql_row_seek()`` ``result.row_seek()`` + ``mysql_row_tell()`` ``result.row_tell()`` + ``mysql_select_db()`` ``conn.select_db()`` + ``mysql_set_character_set()`` ``conn.set_character_set()`` + ``mysql_ssl_set()`` ``ssl`` option to ``_mysql.connect()`` + ``mysql_stat()`` ``conn.stat()`` + ``mysql_store_result()`` ``conn.store_result()`` + ``mysql_thread_id()`` ``conn.thread_id()`` + ``mysql_thread_safe_client()`` ``conn.thread_safe_client()`` + ``mysql_use_result()`` ``conn.use_result()`` + ``mysql_warning_count()`` ``conn.warning_count()`` + ``CLIENT_*`` ``MySQLdb.constants.CLIENT.*`` + ``CR_*`` ``MySQLdb.constants.CR.*`` + ``ER_*`` ``MySQLdb.constants.ER.*`` + ``FIELD_TYPE_*`` ``MySQLdb.constants.FIELD_TYPE.*`` + ``FLAG_*`` ``MySQLdb.constants.FLAG.*`` +=================================== ================================== + + +Some _mysql examples +.................... + +Okay, so you want to use ``_mysql`` anyway. Here are some examples. + +The simplest possible database connection is:: + + import _mysql + db=_mysql.connect() + +This creates a connection to the MySQL server running on the local +machine using the standard UNIX socket (or named pipe on Windows), +your login name (from the USER environment variable), no password, and +does not ``USE`` a database. Chances are you need to supply more +information.:: + + db=_mysql.connect("localhost","joebob","moonpie","thangs") + +This creates a connection to the MySQL server running on the local +machine via a UNIX socket (or named pipe), the user name "joebob", the +password "moonpie", and selects the initial database "thangs". + +We haven't even begun to touch upon all the parameters ``connect()`` +can take. For this reason, I prefer to use keyword parameters:: + + db=_mysql.connect(host="localhost",user="joebob", + passwd="moonpie",db="thangs") + +This does exactly what the last example did, but is arguably easier to +read. But since the default host is "localhost", and if your login +name really was "joebob", you could shorten it to this:: + + db=_mysql.connect(passwd="moonpie",db="thangs") + +UNIX sockets and named pipes don't work over a network, so if you +specify a host other than localhost, TCP will be used, and you can +specify an odd port if you need to (the default port is 3306):: + + db=_mysql.connect(host="outhouse",port=3307,passwd="moonpie",db="thangs") + +If you really had to, you could connect to the local host with TCP by +specifying the full host name, or 127.0.0.1. + +Generally speaking, putting passwords in your code is not such a good +idea:: + + db=_mysql.connect(host="outhouse",db="thangs",read_default_file="~/.my.cnf") + +This does what the previous example does, but gets the username and +password and other parameters from ~/.my.cnf (UNIX-like systems). Read +about `option files`_ for more details. + +.. _`option files`: http://dev.mysql.com/doc/mysql/en/Option_files.html + +So now you have an open connection as ``db`` and want to do a +query. Well, there are no cursors in MySQL, and no parameter +substitution, so you have to pass a complete query string to +``db.query()``:: + + db.query("""SELECT spam, eggs, sausage FROM breakfast + WHERE price < 5""") + +There's no return value from this, but exceptions can be raised. The +exceptions are defined in a separate module, ``_mysql_exceptions``, +but ``_mysql`` exports them. Read DB API specification PEP-249_ to +find out what they are, or you can use the catch-all ``MySQLError``. + +.. _PEP-249: http://www.python.org/peps/pep-0249.html + +At this point your query has been executed and you need to get the +results. You have two options:: + + r=db.store_result() + # ...or... + r=db.use_result() + +Both methods return a result object. What's the difference? +``store_result()`` returns the entire result set to the client +immediately. If your result set is really large, this could be a +problem. One way around this is to add a ``LIMIT`` clause to your +query, to limit the number of rows returned. The other is to use +``use_result()``, which keeps the result set in the server and sends +it row-by-row when you fetch. This does, however, tie up server +resources, and it ties up the connection: You cannot do any more +queries until you have fetched **all** the rows. Generally I +recommend using ``store_result()`` unless your result set is really +huge and you can't use ``LIMIT`` for some reason. + +Now, for actually getting real results:: + + >>> r.fetch_row() + (('3','2','0'),) + +This might look a little odd. The first thing you should know is, +``fetch_row()`` takes some additional parameters. The first one is, +how many rows (``maxrows``) should be returned. By default, it returns +one row. It may return fewer rows than you asked for, but never +more. If you set ``maxrows=0``, it returns all rows of the result +set. If you ever get an empty tuple back, you ran out of rows. + +The second parameter (``how``) tells it how the row should be +represented. By default, it is zero which means, return as a tuple. +``how=1`` means, return it as a dictionary, where the keys are the +column names, or ``table.column`` if there are two columns with the +same name (say, from a join). ``how=2`` means the same as ``how=1`` +except that the keys are *always* ``table.column``; this is for +compatibility with the old ``Mysqldb`` module. + +OK, so why did we get a 1-tuple with a tuple inside? Because we +implicitly asked for one row, since we didn't specify ``maxrows``. + +The other oddity is: Assuming these are numeric columns, why are they +returned as strings? Because MySQL returns all data as strings and +expects you to convert it yourself. This would be a real pain in the +ass, but in fact, ``_mysql`` can do this for you. (And ``MySQLdb`` +does do this for you.) To have automatic type conversion done, you +need to create a type converter dictionary, and pass this to +``connect()`` as the ``conv`` keyword parameter. + +The keys of ``conv`` should be MySQL column types, which in the +C API are ``FIELD_TYPE_*``. You can get these values like this:: + + from MySQLdb.constants import FIELD_TYPE + +By default, any column type that can't be found in ``conv`` is +returned as a string, which works for a lot of stuff. For our +purposes, we probably want this:: + + my_conv = { FIELD_TYPE.LONG: int } + +This means, if it's a ``FIELD_TYPE_LONG``, call the builtin ``int()`` +function on it. Note that ``FIELD_TYPE_LONG`` is an ``INTEGER`` +column, which corresponds to a C ``long``, which is also the type used +for a normal Python integer. But beware: If it's really an ``UNSIGNED +INTEGER`` column, this could cause overflows. For this reason, +``MySQLdb`` actually uses ``long()`` to do the conversion. But we'll +ignore this potential problem for now. + +Then if you use ``db=_mysql.connect(conv=my_conv...)``, the +results will come back ``((3, 2, 0),)``, which is what you would +expect. + +MySQLdb +------- + +MySQLdb is a thin Python wrapper around ``_mysql`` which makes it +compatible with the Python DB API interface (version 2). In reality, +a fair amount of the code which implements the API is in ``_mysql`` +for the sake of efficiency. + +The DB API specification PEP-249_ should be your primary guide for +using this module. Only deviations from the spec and other +database-dependent things will be documented here. + +Functions and attributes +........................ + +Only a few top-level functions and attributes are defined within +MySQLdb. + +connect(parameters...) + Constructor for creating a connection to the + database. Returns a Connection Object. Parameters are the + same as for the MySQL C API. In addition, there are a few + additional keywords that correspond to what you would pass + ``mysql_options()`` before connecting. Note that some + parameters must be specified as keyword arguments! The + default value for each parameter is NULL or zero, as + appropriate. Consult the MySQL documentation for more + details. The important parameters are: + + host + name of host to connect to. Default: use the local host + via a UNIX socket (where applicable) + + user + user to authenticate as. Default: current effective user. + + passwd + password to authenticate with. Default: no password. + + db + database to use. Default: no default database. + + port + TCP port of MySQL server. Default: standard port (3306). + + unix_socket + location of UNIX socket. Default: use default location or + TCP for remote hosts. + + conv + type conversion dictionary. Default: a copy of + ``MySQLdb.converters.conversions`` + + compress + Enable protocol compression. Default: no compression. + + connect_timeout + Abort if connect is not completed within + given number of seconds. Default: no timeout (?) + + named_pipe + Use a named pipe (Windows). Default: don't. + + init_command + Initial command to issue to server upon + connection. Default: Nothing. + + read_default_file + MySQL configuration file to read; see + the MySQL documentation for ``mysql_options()``. + + read_default_group + Default group to read; see the MySQL + documentation for ``mysql_options()``. + + cursorclass + cursor class that ``cursor()`` uses, unless + overridden. Default: ``MySQLdb.cursors.Cursor``. *This + must be a keyword parameter.* + + use_unicode + If True, CHAR and VARCHAR and TEXT columns are returned as + Unicode strings, using the configured character set. It is + best to set the default encoding in the server + configuration, or client configuration (read with + read_default_file). If you change the character set after + connecting (MySQL-4.1 and later), you'll need to put the + correct character set name in connection.charset. + + If False, text-like columns are returned as normal strings, + but you can always write Unicode strings. + + *This must be a keyword parameter.* + + charset + If present, the connection character set will be changed + to this character set, if they are not equal. Support for + changing the character set requires MySQL-4.1 and later + server; if the server is too old, UnsupportedError will be + raised. This option implies use_unicode=True, but you can + override this with use_unicode=False, though you probably + shouldn't. + + If not present, the default character set is used. + + *This must be a keyword parameter.* + + sql_mode + If present, the session SQL mode will be set to the given + string. For more information on sql_mode, see the MySQL + documentation. Only available for 4.1 and newer servers. + + If not present, the session SQL mode will be unchanged. + + *This must be a keyword parameter.* + + ssl + This parameter takes a dictionary or mapping, where the + keys are parameter names used by the mysql_ssl_set_ MySQL + C API call. If this is set, it initiates an SSL connection + to the server; if there is no SSL support in the client, + an exception is raised. *This must be a keyword + parameter.* + +.. _mysql_ssl_set: http://dev.mysql.com/doc/mysql/en/mysql_ssl_set.html + + +apilevel + String constant stating the supported DB API level. '2.0' + +threadsafety + Integer constant stating the level of thread safety the + interface supports. This is set to 1, which means: Threads may + share the module. + + The MySQL protocol can not handle multiple threads using the + same connection at once. Some earlier versions of MySQLdb + utilized locking to achieve a threadsafety of 2. While this is + not terribly hard to accomplish using the standard Cursor class + (which uses ``mysql_store_result()``), it is complicated by + SSCursor (which uses ``mysql_use_result()``; with the latter you + must ensure all the rows have been read before another query can + be executed. It is further complicated by the addition of + transactions, since transactions start when a cursor execute a + query, but end when ``COMMIT`` or ``ROLLBACK`` is executed by + the Connection object. Two threads simply cannot share a + connection while a transaction is in progress, in addition to + not being able to share it during query execution. This + excessively complicated the code to the point where it just + isn't worth it. + + The general upshot of this is: Don't share connections between + threads. It's really not worth your effort or mine, and in the + end, will probably hurt performance, since the MySQL server runs + a separate thread for each connection. You can certainly do + things like cache connections in a pool, and give those + connections to one thread at a time. If you let two threads use + a connection simultaneously, the MySQL client library will + probably upchuck and die. You have been warned. + + For threaded applications, try using a connection pool. + This can be done using the `Pool module`_. + + .. _`Pool module`: http://dustman.net/andy/python/Pool + +charset + The character set used by the connection. In MySQL-4.1 and newer, + it is possible (but not recommended) to change the connection's + character set with an SQL statement. If you do this, you'll also + need to change this attribute. Otherwise, you'll get encoding + errors. + +paramstyle + String constant stating the type of parameter marker formatting + expected by the interface. Set to 'format' = ANSI C printf + format codes, e.g. '...WHERE name=%s'. If a mapping object is + used for conn.execute(), then the interface actually uses + 'pyformat' = Python extended format codes, e.g. '...WHERE + name=%(name)s'. However, the API does not presently allow the + specification of more than one style in paramstyle. + + Note that any literal percent signs in the query string passed + to execute() must be escaped, i.e. %%. + + Parameter placeholders can **only** be used to insert column + values. They can **not** be used for other parts of SQL, such as + table names, statements, etc. + +conv + A dictionary or mapping which controls how types are converted + from MySQL to Python and vice versa. + + If the key is a MySQL type (from ``FIELD_TYPE.*``), then the value + can be either: + + * a callable object which takes a string argument (the MySQL + value),' returning a Python value + + * a sequence of 2-tuples, where the first value is a combination + of flags from ``MySQLdb.constants.FLAG``, and the second value + is a function as above. The sequence is tested until the flags + on the field match those of the first value. If both values + are None, then the default conversion is done. Presently this + is only used to distinquish TEXT and BLOB columns. + + If the key is a Python type or class, then the value is a + callable Python object (usually a function) taking two arguments + (value to convert, and the conversion dictionary) which converts + values of this type to a SQL literal string value. + + This is initialized with reasonable defaults for most + types. When creating a Connection object, you can pass your own + type converter dictionary as a keyword parameter. Otherwise, it + uses a copy of ``MySQLdb.converters.conversions``. Several + non-standard types are returned as strings, which is how MySQL + returns all columns. For more details, see the built-in module + documentation. + + +Connection Objects +.................. + +Connection objects are returned by the ``connect()`` function. + +commit() + If the database and the tables support transactions, this + commits the current transaction; otherwise this method + successfully does nothing. + +rollback() + If the database and tables support transactions, this rolls back + (cancels) the current transaction; otherwise a + ``NotSupportedError`` is raised. + +cursor([cursorclass]) + MySQL does not support cursors; however, cursors are easily + emulated. You can supply an alternative cursor class as an + optional parameter. If this is not present, it defaults to the + value given when creating the connection object, or the standard + ``Cursor`` class. Also see the additional supplied cursor + classes in the usage section. + +There are many more methods defined on the connection object which +are MySQL-specific. For more information on them, consult the internal +documentation using ``pydoc``. + + +Cursor Objects +.............. + +callproc(procname, args) + Calls stored procedure procname with the sequence of arguments + in args. Returns the original arguments. Stored procedure + support only works with MySQL-5.0 and newer. + + **Compatibility note:** PEP-249_ specifies that if there are + OUT or INOUT parameters, the modified values are to be + returned. This is not consistently possible with MySQL. Stored + procedure arguments must be passed as server variables, and + can only be returned with a SELECT statement. Since a stored + procedure may return zero or more result sets, it is impossible + for MySQLdb to determine if there are result sets to fetch + before the modified parmeters are accessible. + + The parameters are stored in the server as @_*procname*_*n*, + where *n* is the position of the parameter. I.e., if you + cursor.callproc('foo', (a, b, c)), the parameters will be + accessible by a SELECT statement as @_foo_0, @_foo_1, and + @_foo_2. + + **Compatibility note:** It appears that the mere act of + executing the CALL statement produces an empty result set, which + appears after any result sets which might be generated by the + stored procedure. Thus, you will always need to use nextset() to + advance result sets. + +close() + Closes the cursor. Future operations raise ``ProgrammingError``. + If you are using server-side cursors, it is very important to + close the cursor when you are done with it and before creating a + new one. + +info() + Returns some information about the last query. Normally + you don't need to check this. If there are any MySQL + warnings, it will cause a Warning to be issued through + the Python warning module. By default, Warning causes a + message to appear on the console. However, it is possible + to filter these out or cause Warning to be raised as exception. + See the MySQL docs for ``mysql_info()``, and the Python warning + module. (Non-standard) + +setinputsizes() + Does nothing, successfully. + +setoutputsizes() + Does nothing, successfully. + +nextset() + Advances the cursor to the next result set, discarding the remaining + rows in the current result set. If there are no additional result + sets, it returns None; otherwise it returns a true value. + + Note that MySQL doesn't support multiple result sets until 4.1. + + +Some examples +............. + +The ``connect()`` method works nearly the same as with `_mysql`_:: + + import MySQLdb + db=MySQLdb.connect(passwd="moonpie",db="thangs") + +To perform a query, you first need a cursor, and then you can execute +queries on it:: + + c=db.cursor() + max_price=5 + c.execute("""SELECT spam, eggs, sausage FROM breakfast + WHERE price < %s""", (max_price,)) + +In this example, ``max_price=5`` Why, then, use ``%s`` in the +string? Because MySQLdb will convert it to a SQL literal value, which +is the string '5'. When it's finished, the query will actually say, +"...WHERE price < 5". + +Why the tuple? Because the DB API requires you to pass in any +parameters as a sequence. Due to the design of the parser, (max_price) +is interpreted as using algebraic grouping and simply as max_price and +not a tuple. Adding a comma, i.e. (max_price,) forces it to make a +tuple. + +And now, the results:: + + >>> c.fetchone() + (3L, 2L, 0L) + +Quite unlike the ``_mysql`` example, this returns a single tuple, +which is the row, and the values are properly converted by default... +except... What's with the L's? + +As mentioned earlier, while MySQL's INTEGER column translates +perfectly into a Python integer, UNSIGNED INTEGER could overflow, so +these values are converted to Python long integers instead. + +If you wanted more rows, you could use ``c.fetchmany(n)`` or +``c.fetchall()``. These do exactly what you think they do. On +``c.fetchmany(n)``, the ``n`` is optional and defaults to +``c.arraysize``, which is normally 1. Both of these methods return a +sequence of rows, or an empty sequence if there are no more rows. If +you use a weird cursor class, the rows themselves might not be tuples. + +Note that in contrast to the above, ``c.fetchone()`` returns ``None`` +when there are no more rows to fetch. + +The only other method you are very likely to use is when you have to +do a multi-row insert:: + + c.executemany( + """INSERT INTO breakfast (name, spam, eggs, sausage, price) + VALUES (%s, %s, %s, %s, %s)""", + [ + ("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ), + ("Not So Much Spam Plate", 3, 2, 0, 3.95 ), + ("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 ) + ] ) + +Here we are inserting three rows of five values. Notice that there is +a mix of types (strings, ints, floats) though we still only use +``%s``. And also note that we only included format strings for one +row. MySQLdb picks those out and duplicates them for each row. + +Using and extending +------------------- + +In general, it is probably wise to not directly interact with the DB +API except for small applicatons. Databases, even SQL databases, vary +widely in capabilities and may have non-standard features. The DB API +does a good job of providing a reasonably portable interface but some +methods are non-portable. Specifically, the parameters accepted by +``connect()`` are completely implementation-dependent. + +If you believe your application may need to run on several different +databases, the author recommends the following approach, based on +personal experience: Write a simplified API for your application which +implements the specific queries and operations your application needs +to perform. Implement this API as a base class which should be have +few database dependencies, and then derive a subclass from this which +implements the necessary dependencies. In this way, porting your +application to a new database should be a relatively simple matter of +creating a new subclass, assuming the new database is reasonably +standard. + +Because MySQLdb's Connection and Cursor objects are written in Python, +you can easily derive your own subclasses. There are several Cursor +classes in MySQLdb.cursors: + +BaseCursor + The base class for Cursor objects. This does not raise Warnings. + +CursorStoreResultMixIn + Causes the Cursor to use the ``mysql_store_result()`` function to + get the query result. The entire result set is stored on the + client side. + +CursorUseResultMixIn + Causes the cursor to use the ``mysql_use_result()`` function to + get the query result. The result set is stored on the server side + and is transferred row by row using fetch operations. + +CursorTupleRowsMixIn + Causes the cursor to return rows as a tuple of the column values. + +CursorDictRowsMixIn + + Causes the cursor to return rows as a dictionary, where the keys + are column names and the values are column values. Note that if + the column names are not unique, i.e., you are selecting from two + tables that share column names, some of them will be rewritten as + ``table.column``. This can be avoided by using the SQL ``AS`` + keyword. (This is yet-another reason not to use ``*`` in SQL + queries, particularly where ``JOIN`` is involved.) + +Cursor + The default cursor class. This class is composed of + ``CursorWarningMixIn``, ``CursorStoreResultMixIn``, + ``CursorTupleRowsMixIn,`` and ``BaseCursor``, i.e. it raises + ``Warning``, uses ``mysql_store_result()``, and returns rows as + tuples. + +DictCursor + Like ``Cursor`` except it returns rows as dictionaries. + +SSCursor + A "server-side" cursor. Like ``Cursor`` but uses + ``CursorUseResultMixIn``. Use only if you are dealing with + potentially large result sets. + +SSDictCursor + Like ``SSCursor`` except it returns rows as dictionaries. + + +Embedded Server +--------------- + +Instead of connecting to a stand-alone server over the network, +the embedded server support lets you run a full server right in +your Python code or application server. + +If you have built MySQLdb with embedded server support, there +are two additional functions you will need to make use of: + + server_init(args, groups) + Initialize embedded server. If this client is not linked against + the embedded server library, this function does nothing. + + args + sequence of command-line arguments + groups + sequence of groups to use in defaults files + + server_end() + Shut down embedded server. If not using an embedded server, this + does nothing. + +See the MySQL documentation for more information on the embedded +server. + + + +:Title: MySQLdb: a Python interface for MySQL +:Author: Andy Dustman +:Version: $Revision$ diff --git a/MySQLdb/ez_setup.py b/MySQLdb/ez_setup.py new file mode 100644 index 0000000..d24e845 --- /dev/null +++ b/MySQLdb/ez_setup.py @@ -0,0 +1,276 @@ +#!python +"""Bootstrap setuptools installation + +If you want to use setuptools in your package's setup.py, just include this +file in the same directory with it, and add this to the top of your setup.py:: + + from ez_setup import use_setuptools + use_setuptools() + +If you want to require a specific version of setuptools, set a download +mirror, or use an alternate download directory, you can do so by supplying +the appropriate options to ``use_setuptools()``. + +This file can also be run as a script to install or upgrade setuptools. +""" +import sys +DEFAULT_VERSION = "0.6c9" +DEFAULT_URL = "http://pypi.python.org/packages/%s/s/setuptools/" % sys.version[:3] + +md5_data = { + 'setuptools-0.6b1-py2.3.egg': '8822caf901250d848b996b7f25c6e6ca', + 'setuptools-0.6b1-py2.4.egg': 'b79a8a403e4502fbb85ee3f1941735cb', + 'setuptools-0.6b2-py2.3.egg': '5657759d8a6d8fc44070a9d07272d99b', + 'setuptools-0.6b2-py2.4.egg': '4996a8d169d2be661fa32a6e52e4f82a', + 'setuptools-0.6b3-py2.3.egg': 'bb31c0fc7399a63579975cad9f5a0618', + 'setuptools-0.6b3-py2.4.egg': '38a8c6b3d6ecd22247f179f7da669fac', + 'setuptools-0.6b4-py2.3.egg': '62045a24ed4e1ebc77fe039aa4e6f7e5', + 'setuptools-0.6b4-py2.4.egg': '4cb2a185d228dacffb2d17f103b3b1c4', + 'setuptools-0.6c1-py2.3.egg': 'b3f2b5539d65cb7f74ad79127f1a908c', + 'setuptools-0.6c1-py2.4.egg': 'b45adeda0667d2d2ffe14009364f2a4b', + 'setuptools-0.6c2-py2.3.egg': 'f0064bf6aa2b7d0f3ba0b43f20817c27', + 'setuptools-0.6c2-py2.4.egg': '616192eec35f47e8ea16cd6a122b7277', + 'setuptools-0.6c3-py2.3.egg': 'f181fa125dfe85a259c9cd6f1d7b78fa', + 'setuptools-0.6c3-py2.4.egg': 'e0ed74682c998bfb73bf803a50e7b71e', + 'setuptools-0.6c3-py2.5.egg': 'abef16fdd61955514841c7c6bd98965e', + 'setuptools-0.6c4-py2.3.egg': 'b0b9131acab32022bfac7f44c5d7971f', + 'setuptools-0.6c4-py2.4.egg': '2a1f9656d4fbf3c97bf946c0a124e6e2', + 'setuptools-0.6c4-py2.5.egg': '8f5a052e32cdb9c72bcf4b5526f28afc', + 'setuptools-0.6c5-py2.3.egg': 'ee9fd80965da04f2f3e6b3576e9d8167', + 'setuptools-0.6c5-py2.4.egg': 'afe2adf1c01701ee841761f5bcd8aa64', + 'setuptools-0.6c5-py2.5.egg': 'a8d3f61494ccaa8714dfed37bccd3d5d', + 'setuptools-0.6c6-py2.3.egg': '35686b78116a668847237b69d549ec20', + 'setuptools-0.6c6-py2.4.egg': '3c56af57be3225019260a644430065ab', + 'setuptools-0.6c6-py2.5.egg': 'b2f8a7520709a5b34f80946de5f02f53', + 'setuptools-0.6c7-py2.3.egg': '209fdf9adc3a615e5115b725658e13e2', + 'setuptools-0.6c7-py2.4.egg': '5a8f954807d46a0fb67cf1f26c55a82e', + 'setuptools-0.6c7-py2.5.egg': '45d2ad28f9750e7434111fde831e8372', + 'setuptools-0.6c8-py2.3.egg': '50759d29b349db8cfd807ba8303f1902', + 'setuptools-0.6c8-py2.4.egg': 'cba38d74f7d483c06e9daa6070cce6de', + 'setuptools-0.6c8-py2.5.egg': '1721747ee329dc150590a58b3e1ac95b', + 'setuptools-0.6c9-py2.3.egg': 'a83c4020414807b496e4cfbe08507c03', + 'setuptools-0.6c9-py2.4.egg': '260a2be2e5388d66bdaee06abec6342a', + 'setuptools-0.6c9-py2.5.egg': 'fe67c3e5a17b12c0e7c541b7ea43a8e6', + 'setuptools-0.6c9-py2.6.egg': 'ca37b1ff16fa2ede6e19383e7b59245a', +} + +import sys, os +try: from hashlib import md5 +except ImportError: from md5 import md5 + +def _validate_md5(egg_name, data): + if egg_name in md5_data: + digest = md5(data).hexdigest() + if digest != md5_data[egg_name]: + print >>sys.stderr, ( + "md5 validation of %s failed! (Possible download problem?)" + % egg_name + ) + sys.exit(2) + return data + +def use_setuptools( + version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir, + download_delay=15 +): + """Automatically find/download setuptools and make it available on sys.path + + `version` should be a valid setuptools version number that is available + as an egg for download under the `download_base` URL (which should end with + a '/'). `to_dir` is the directory where setuptools will be downloaded, if + it is not already available. If `download_delay` is specified, it should + be the number of seconds that will be paused before initiating a download, + should one be required. If an older version of setuptools is installed, + this routine will print a message to ``sys.stderr`` and raise SystemExit in + an attempt to abort the calling script. + """ + was_imported = 'pkg_resources' in sys.modules or 'setuptools' in sys.modules + def do_download(): + egg = download_setuptools(version, download_base, to_dir, download_delay) + sys.path.insert(0, egg) + import setuptools; setuptools.bootstrap_install_from = egg + try: + import pkg_resources + except ImportError: + return do_download() + try: + pkg_resources.require("setuptools>="+version); return + except pkg_resources.VersionConflict, e: + if was_imported: + print >>sys.stderr, ( + "The required version of setuptools (>=%s) is not available, and\n" + "can't be installed while this script is running. Please install\n" + " a more recent version first, using 'easy_install -U setuptools'." + "\n\n(Currently using %r)" + ) % (version, e.args[0]) + sys.exit(2) + else: + del pkg_resources, sys.modules['pkg_resources'] # reload ok + return do_download() + except pkg_resources.DistributionNotFound: + return do_download() + +def download_setuptools( + version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir, + delay = 15 +): + """Download setuptools from a specified location and return its filename + + `version` should be a valid setuptools version number that is available + as an egg for download under the `download_base` URL (which should end + with a '/'). `to_dir` is the directory where the egg will be downloaded. + `delay` is the number of seconds to pause before an actual download attempt. + """ + import urllib2, shutil + egg_name = "setuptools-%s-py%s.egg" % (version,sys.version[:3]) + url = download_base + egg_name + saveto = os.path.join(to_dir, egg_name) + src = dst = None + if not os.path.exists(saveto): # Avoid repeated downloads + try: + from distutils import log + if delay: + log.warn(""" +--------------------------------------------------------------------------- +This script requires setuptools version %s to run (even to display +help). I will attempt to download it for you (from +%s), but +you may need to enable firewall access for this script first. +I will start the download in %d seconds. + +(Note: if this machine does not have network access, please obtain the file + + %s + +and place it in this directory before rerunning this script.) +---------------------------------------------------------------------------""", + version, download_base, delay, url + ); from time import sleep; sleep(delay) + log.warn("Downloading %s", url) + src = urllib2.urlopen(url) + # Read/write all in one block, so we don't create a corrupt file + # if the download is interrupted. + data = _validate_md5(egg_name, src.read()) + dst = open(saveto,"wb"); dst.write(data) + finally: + if src: src.close() + if dst: dst.close() + return os.path.realpath(saveto) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def main(argv, version=DEFAULT_VERSION): + """Install or upgrade setuptools and EasyInstall""" + try: + import setuptools + except ImportError: + egg = None + try: + egg = download_setuptools(version, delay=0) + sys.path.insert(0,egg) + from setuptools.command.easy_install import main + return main(list(argv)+[egg]) # we're done here + finally: + if egg and os.path.exists(egg): + os.unlink(egg) + else: + if setuptools.__version__ == '0.0.1': + print >>sys.stderr, ( + "You have an obsolete version of setuptools installed. Please\n" + "remove it from your system entirely before rerunning this script." + ) + sys.exit(2) + + req = "setuptools>="+version + import pkg_resources + try: + pkg_resources.require(req) + except pkg_resources.VersionConflict: + try: + from setuptools.command.easy_install import main + except ImportError: + from easy_install import main + main(list(argv)+[download_setuptools(delay=0)]) + sys.exit(0) # try to force an exit + else: + if argv: + from setuptools.command.easy_install import main + main(argv) + else: + print "Setuptools version",version,"or greater has been installed." + print '(Run "ez_setup.py -U setuptools" to reinstall or upgrade.)' + +def update_md5(filenames): + """Update our built-in md5 registry""" + + import re + + for name in filenames: + base = os.path.basename(name) + f = open(name,'rb') + md5_data[base] = md5(f.read()).hexdigest() + f.close() + + data = [" %r: %r,\n" % it for it in md5_data.items()] + data.sort() + repl = "".join(data) + + import inspect + srcfile = inspect.getsourcefile(sys.modules[__name__]) + f = open(srcfile, 'rb'); src = f.read(); f.close() + + match = re.search("\nmd5_data = {\n([^}]+)}", src) + if not match: + print >>sys.stderr, "Internal error!" + sys.exit(2) + + src = src[:match.start(1)] + repl + src[match.end(1):] + f = open(srcfile,'w') + f.write(src) + f.close() + + +if __name__=='__main__': + if len(sys.argv)>2 and sys.argv[1]=='--md5update': + update_md5(sys.argv[2:]) + else: + main(sys.argv[1:]) + + + + + + diff --git a/MySQLdb/metadata.cfg b/MySQLdb/metadata.cfg new file mode 100644 index 0000000..e72d671 --- /dev/null +++ b/MySQLdb/metadata.cfg @@ -0,0 +1,60 @@ +[metadata] +version: 1.2.3 +version_info: (1,2,3,'beta',1) +description: Python interface to MySQL +long_description: + ========================= + Python interface to MySQL + ========================= + \n + MySQLdb is an interface to the popular MySQL_ database server for + Python. The design goals are: + \n + - Compliance with Python database API version 2.0 [PEP-0249]_ + \n + - Thread-safety + \n + - Thread-friendliness (threads will not block each other) + \n + MySQL-3.23 through 5.0 and Python-2.3 through 2.5 are currently + supported. + \n + MySQLdb is `Free Software`_. + \n + .. _MySQL: http://www.mysql.com/ + .. _`Free Software`: http://www.gnu.org/ + .. [PEP-0249] http://www.python.org/peps/pep-0249.html +author: Andy Dustman +author_email: adustman@users.sourceforge.net +license: GPL +platforms: ALL +url: http://sourceforge.net/projects/mysql-python +download_url: http://osdn.dl.sourceforge.net/sourceforge/mysql-python/MySQL-python-%(version)s.tar.gz +classifiers: + Development Status :: 5 - Production/Stable + Environment :: Other Environment + License :: OSI Approved :: GNU General Public License (GPL) + Operating System :: MacOS :: MacOS X + Operating System :: Microsoft :: Windows :: Windows NT/2000 + Operating System :: OS Independent + Operating System :: POSIX + Operating System :: POSIX :: Linux + Operating System :: Unix + Programming Language :: C + Programming Language :: Python + Topic :: Database + Topic :: Database :: Database Engines/Servers +py_modules: + _mysql_exceptions + MySQLdb.converters + MySQLdb.connections + MySQLdb.cursors + MySQLdb.release + MySQLdb.times + MySQLdb.constants.CR + MySQLdb.constants.FIELD_TYPE + MySQLdb.constants.ER + MySQLdb.constants.FLAG + MySQLdb.constants.REFRESH + MySQLdb.constants.CLIENT + diff --git a/MySQLdb/pymemcompat.h b/MySQLdb/pymemcompat.h new file mode 100644 index 0000000..e7c538c --- /dev/null +++ b/MySQLdb/pymemcompat.h @@ -0,0 +1,87 @@ + +/* The idea of this file is that you bundle it with your extension, + #include it, program to Python 2.3's memory API and have your + extension build with any version of Python from 1.5.2 through to + 2.3 (and hopefully beyond). */ + +#ifndef Py_PYMEMCOMPAT_H +#define Py_PYMEMCOMPAT_H + +#include "Python.h" + +/* There are three "families" of memory API: the "raw memory", "object + memory" and "object" families. (This is ignoring the matter of the + cycle collector, about which more is said below). + + Raw Memory: + + PyMem_Malloc, PyMem_Realloc, PyMem_Free + + Object Memory: + + PyObject_Malloc, PyObject_Realloc, PyObject_Free + + Object: + + PyObject_New, PyObject_NewVar, PyObject_Del + + The raw memory and object memory allocators both mimic the + malloc/realloc/free interface from ANSI C, but the object memory + allocator can (and, since 2.3, does by default) use a different + allocation strategy biased towards lots of lots of "small" + allocations. + + The object family is used for allocating Python objects, and the + initializers take care of some basic initialization (setting the + refcount to 1 and filling out the ob_type field) as well as having + a somewhat different interface. + + Do not mix the families! E.g. do not allocate memory with + PyMem_Malloc and free it with PyObject_Free. You may get away with + it quite a lot of the time, but there *are* scenarios where this + will break. You Have Been Warned. + + Also, in many versions of Python there are an insane amount of + memory interfaces to choose from. Use the ones described above. */ + +#if PY_VERSION_HEX < 0x01060000 +/* raw memory interface already present */ + +/* there is no object memory interface in 1.5.2 */ +#define PyObject_Malloc PyMem_Malloc +#define PyObject_Realloc PyMem_Realloc +#define PyObject_Free PyMem_Free + +/* the object interface is there, but the names have changed */ +#define PyObject_New PyObject_NEW +#define PyObject_NewVar PyObject_NEW_VAR +#define PyObject_Del PyMem_Free +#endif + +/* If your object is a container you probably want to support the + cycle collector, which was new in Python 2.0. + + Unfortunately, the interface to the collector that was present in + Python 2.0 and 2.1 proved to be tricky to use, and so changed in + 2.2 -- in a way that can't easily be papered over with macros. + + This file contains macros that let you program to the 2.2 GC API. + Your module will compile against any Python since version 1.5.2, + but the type will only participate in the GC in versions 2.2 and + up. Some work is still necessary on your part to only fill out the + tp_traverse and tp_clear fields when they exist and set tp_flags + appropriately. + + It is possible to support both the 2.0 and 2.2 GC APIs, but it's + not pretty and this comment block is too narrow to contain a + desciption of what's required... */ + +#if PY_VERSION_HEX < 0x020200B1 +#define PyObject_GC_New PyObject_New +#define PyObject_GC_NewVar PyObject_NewVar +#define PyObject_GC_Del PyObject_Del +#define PyObject_GC_Track(op) +#define PyObject_GC_UnTrack(op) +#endif + +#endif /* !Py_PYMEMCOMPAT_H */ diff --git a/MySQLdb/setup.cfg b/MySQLdb/setup.cfg new file mode 100644 index 0000000..132666b --- /dev/null +++ b/MySQLdb/setup.cfg @@ -0,0 +1,16 @@ +[build_ext] +## Only uncomment/set these if the default configuration doesn't work +## Also see http://docs.python.org/dist/setup-config.html +# include-dirs = ? +# library-dirs = ? +# link-objects = ? +# rpath = ? +# libraries = ? + +[bdist_rpm] +doc_files = README MANIFEST doc/*.txt +vendor = MySQL-python SourceForge Project +packager = Andy Dustman <adustman@users.sourceforge.net> +distribution-name = Red Stains Linux +requires = python +build-requires = python-devel mysql-devel zlib-devel openssl-devel diff --git a/MySQLdb/setup.py b/MySQLdb/setup.py new file mode 100644 index 0000000..ead5a42 --- /dev/null +++ b/MySQLdb/setup.py @@ -0,0 +1,18 @@ +#!/usr/bin/env python + +import os +import sys +from setuptools import setup, Extension + +if sys.version_info < (2, 3): + raise Error("Python-2.3 or newer is required") + +if os.name == "posix": + from setup_posix import get_config +else: # assume windows + from setup_windows import get_config + +metadata, options = get_config() +metadata['ext_modules'] = [Extension(sources=['_mysql.c'], **options)] +metadata['long_description'] = metadata['long_description'].replace(r'\n', '') +setup(**metadata) diff --git a/MySQLdb/setup_common.py b/MySQLdb/setup_common.py new file mode 100644 index 0000000..f3f7d06 --- /dev/null +++ b/MySQLdb/setup_common.py @@ -0,0 +1,32 @@ +from ConfigParser import SafeConfigParser + +def get_metadata_and_options(): + config = SafeConfigParser() + config.read(['metadata.cfg', 'site.cfg']) + + metadata = dict(config.items('metadata')) + options = dict(config.items('options')) + + metadata['py_modules'] = filter(None, metadata['py_modules'].split('\n')) + metadata['classifiers'] = filter(None, metadata['classifiers'].split('\n')) + + return metadata, options + +def enabled(options, option): + value = options[option] + s = value.lower() + if s in ('yes','true','1','y'): + return True + elif s in ('no', 'false', '0', 'n'): + return False + else: + raise Abort, "Unknown value %s for option %s" % (value, option) + +def create_release_file(metadata): + rel = open("MySQLdb/release.py",'w') + rel.write(""" +__author__ = "%(author)s <%(author_email)s>" +version_info = %(version_info)s +__version__ = "%(version)s" +""" % metadata) + rel.close() diff --git a/MySQLdb/setup_posix.py b/MySQLdb/setup_posix.py new file mode 100644 index 0000000..d38df23 --- /dev/null +++ b/MySQLdb/setup_posix.py @@ -0,0 +1,94 @@ +from ConfigParser import SafeConfigParser + +# This dequote() business is required for some older versions +# of mysql_config + +def dequote(s): + if s[0] in "\"'" and s[0] == s[-1]: + s = s[1:-1] + return s + +def compiler_flag(f): + return "-%s" % f + +def mysql_config(what): + from os import popen + + f = popen("%s --%s" % (mysql_config.path, what)) + data = f.read().strip().split() + ret = f.close() + if ret: + if ret/256: + data = [] + if ret/256 > 1: + raise EnvironmentError, "%s not found" % mysql_config.path + return data +mysql_config.path = "mysql_config" + +def get_config(): + import os, sys + from setup_common import get_metadata_and_options, enabled, create_release_file + + metadata, options = get_metadata_and_options() + + if 'mysql_config' in options: + mysql_config.path = options['mysql_config'] + + extra_objects = [] + static = enabled(options, 'static') + if enabled(options, 'embedded'): + libs = mysql_config("libmysqld-libs") + client = "mysqld" + elif enabled(options, 'threadsafe'): + libs = mysql_config("libs_r") + client = "mysqlclient_r" + if not libs: + libs = mysql_config("libs") + client = "mysqlclient" + else: + libs = mysql_config("libs") + client = "mysqlclient" + + library_dirs = [ dequote(i[2:]) for i in libs if i.startswith(compiler_flag("L")) ] + libraries = [ dequote(i[2:]) for i in libs if i.startswith(compiler_flag("l")) ] + + removable_compile_args = [ compiler_flag(f) for f in "ILl" ] + extra_compile_args = [ i.replace("%", "%%") for i in mysql_config("cflags") + if i[:2] not in removable_compile_args ] + include_dirs = [ dequote(i[2:]) + for i in mysql_config('include') + if i.startswith(compiler_flag('I')) ] + if not include_dirs: # fix for MySQL-3.23 + include_dirs = [ dequote(i[2:]) + for i in mysql_config('cflags') + if i.startswith(compiler_flag('I')) ] + + if static: + extra_objects.append(os.path.join( + library_dirs[0],'lib%s.a' % client)) + + name = "MySQL-python" + if enabled(options, 'embedded'): + name = name + "-embedded" + metadata['name'] = name + + define_macros = [ + ('version_info', metadata['version_info']), + ('__version__', metadata['version']), + ] + create_release_file(metadata) + del metadata['version_info'] + ext_options = dict( + name = "_mysql", + library_dirs = library_dirs, + libraries = libraries, + extra_compile_args = extra_compile_args, + include_dirs = include_dirs, + extra_objects = extra_objects, + define_macros = define_macros, + ) + return metadata, ext_options + +if __name__ == "__main__": + print """You shouldn't be running this directly; it is used by setup.py.""" + diff --git a/MySQLdb/setup_windows.py b/MySQLdb/setup_windows.py new file mode 100644 index 0000000..411b773 --- /dev/null +++ b/MySQLdb/setup_windows.py @@ -0,0 +1,47 @@ +def get_config(): + import os, sys, _winreg + from setup_common import get_metadata_and_options, enabled, create_release_file + + metadata, options = get_metadata_and_options() + + serverKey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, options['registry_key']) + mysql_root, dummy = _winreg.QueryValueEx(serverKey,'Location') + + extra_objects = [] + static = enabled(options, 'static') + # XXX static doesn't actually do anything on Windows + if enabled(options, 'embedded'): + client = "mysqld" + else: + client = "mysqlclient" + + library_dirs = [ os.path.join(mysql_root, r'lib\opt') ] + libraries = [ 'kernel32', 'advapi32', 'wsock32', client ] + include_dirs = [ os.path.join(mysql_root, r'include') ] + extra_compile_args = [ '/Zl' ] + + name = "MySQL-python" + if enabled(options, 'embedded'): + name = name + "-embedded" + metadata['name'] = name + + define_macros = [ + ('version_info', metadata['version_info']), + ('__version__', metadata['version']), + ] + create_release_file(metadata) + del metadata['version_info'] + ext_options = dict( + name = "_mysql", + library_dirs = library_dirs, + libraries = libraries, + extra_compile_args = extra_compile_args, + include_dirs = include_dirs, + extra_objects = extra_objects, + define_macros = define_macros, + ) + return metadata, ext_options + +if __name__ == "__main__": + print """You shouldn't be running this directly; it is used by setup.py.""" + diff --git a/MySQLdb/site.cfg b/MySQLdb/site.cfg new file mode 100644 index 0000000..5413a1e --- /dev/null +++ b/MySQLdb/site.cfg @@ -0,0 +1,18 @@ +[options] +# embedded: link against the embedded server library +# threadsafe: use the threadsafe client +# static: link against a static library (probably required for embedded) + +embedded = False +threadsafe = True +static = False + +# The path to mysql_config. +# Only use this if mysql_config is not on your PATH, or you have some weird +# setup that requires it. +#mysql_config = /usr/local/bin/mysql_config + +# The Windows registry key for MySQL. +# This has to be set for Windows builds to work. +# Only change this if you have a different version. +registry_key = SOFTWARE\MySQL AB\MySQL Server 5.0 diff --git a/MySQLdb/test_MySQLdb_capabilities.py b/MySQLdb/test_MySQLdb_capabilities.py new file mode 100644 index 0000000..5f6321d --- /dev/null +++ b/MySQLdb/test_MySQLdb_capabilities.py @@ -0,0 +1,82 @@ +#!/usr/bin/env python +import test_capabilities +import unittest +import MySQLdb +import warnings + +warnings.filterwarnings('error') + +class test_MySQLdb(test_capabilities.DatabaseTest): + + db_module = MySQLdb + connect_args = () + connect_kwargs = dict(db='test', read_default_file='~/.my.cnf', + charset='utf8', sql_mode="ANSI,STRICT_TRANS_TABLES,TRADITIONAL") + create_table_extra = "ENGINE=INNODB CHARACTER SET UTF8" + leak_test = False + + def quote_identifier(self, ident): + return "`%s`" % ident + + def test_TIME(self): + from datetime import timedelta + def generator(row,col): + return timedelta(0, row*8000) + self.check_data_integrity( + ('col1 TIME',), + generator) + + def test_TINYINT(self): + # Number data + def generator(row,col): + v = (row*row) % 256 + if v > 127: + v = v-256 + return v + self.check_data_integrity( + ('col1 TINYINT',), + generator) + + def test_stored_procedures(self): + db = self.connection + c = self.cursor + self.create_table(('pos INT', 'tree CHAR(20)')) + c.executemany("INSERT INTO %s (pos,tree) VALUES (%%s,%%s)" % self.table, + list(enumerate('ash birch cedar larch pine'.split()))) + db.commit() + + c.execute(""" + CREATE PROCEDURE test_sp(IN t VARCHAR(255)) + BEGIN + SELECT pos FROM %s WHERE tree = t; + END + """ % self.table) + db.commit() + + c.callproc('test_sp', ('larch',)) + rows = c.fetchall() + self.assertEquals(len(rows), 1) + self.assertEquals(rows[0][0], 3) + c.nextset() + + c.execute("DROP PROCEDURE test_sp") + c.execute('drop table %s' % (self.table)) + + def test_small_CHAR(self): + # Character data + def generator(row,col): + i = (row*col+62)%256 + if i == 62: return '' + if i == 63: return None + return chr(i) + self.check_data_integrity( + ('col1 char(1)','col2 char(1)'), + generator) + +if __name__ == '__main__': + if test_MySQLdb.leak_test: + import gc + gc.enable() + gc.set_debug(gc.DEBUG_LEAK) + unittest.main() + print '''"Huh-huh, he said 'unit'." -- Butthead''' diff --git a/MySQLdb/test_MySQLdb_dbapi20.py b/MySQLdb/test_MySQLdb_dbapi20.py new file mode 100644 index 0000000..a466611 --- /dev/null +++ b/MySQLdb/test_MySQLdb_dbapi20.py @@ -0,0 +1,205 @@ +#!/usr/bin/env python +import dbapi20 +import unittest +import MySQLdb + +class test_MySQLdb(dbapi20.DatabaseAPI20Test): + driver = MySQLdb + connect_args = () + connect_kw_args = dict(db='test', + read_default_file='~/.my.cnf', + charset='utf8', + sql_mode="ANSI,STRICT_TRANS_TABLES,TRADITIONAL") + + def test_setoutputsize(self): pass + def test_setoutputsize_basic(self): pass + def test_nextset(self): pass + + """The tests on fetchone and fetchall and rowcount bogusly + test for an exception if the statement cannot return a + result set. MySQL always returns a result set; it's just that + some things return empty result sets.""" + + def test_fetchall(self): + con = self._connect() + try: + cur = con.cursor() + # cursor.fetchall should raise an Error if called + # without executing a query that may return rows (such + # as a select) + self.assertRaises(self.driver.Error, cur.fetchall) + + self.executeDDL1(cur) + for sql in self._populate(): + cur.execute(sql) + + # cursor.fetchall should raise an Error if called + # after executing a a statement that cannot return rows +## self.assertRaises(self.driver.Error,cur.fetchall) + + cur.execute('select name from %sbooze' % self.table_prefix) + rows = cur.fetchall() + self.failUnless(cur.rowcount in (-1,len(self.samples))) + self.assertEqual(len(rows),len(self.samples), + 'cursor.fetchall did not retrieve all rows' + ) + rows = [r[0] for r in rows] + rows.sort() + for i in range(0,len(self.samples)): + self.assertEqual(rows[i],self.samples[i], + 'cursor.fetchall retrieved incorrect rows' + ) + rows = cur.fetchall() + self.assertEqual( + len(rows),0, + 'cursor.fetchall should return an empty list if called ' + 'after the whole result set has been fetched' + ) + self.failUnless(cur.rowcount in (-1,len(self.samples))) + + self.executeDDL2(cur) + cur.execute('select name from %sbarflys' % self.table_prefix) + rows = cur.fetchall() + self.failUnless(cur.rowcount in (-1,0)) + self.assertEqual(len(rows),0, + 'cursor.fetchall should return an empty list if ' + 'a select query returns no rows' + ) + + finally: + con.close() + + def test_fetchone(self): + con = self._connect() + try: + cur = con.cursor() + + # cursor.fetchone should raise an Error if called before + # executing a select-type query + self.assertRaises(self.driver.Error,cur.fetchone) + + # cursor.fetchone should raise an Error if called after + # executing a query that cannnot return rows + self.executeDDL1(cur) +## self.assertRaises(self.driver.Error,cur.fetchone) + + cur.execute('select name from %sbooze' % self.table_prefix) + self.assertEqual(cur.fetchone(),None, + 'cursor.fetchone should return None if a query retrieves ' + 'no rows' + ) + self.failUnless(cur.rowcount in (-1,0)) + + # cursor.fetchone should raise an Error if called after + # executing a query that cannnot return rows + cur.execute("insert into %sbooze values ('Victoria Bitter')" % ( + self.table_prefix + )) +## self.assertRaises(self.driver.Error,cur.fetchone) + + cur.execute('select name from %sbooze' % self.table_prefix) + r = cur.fetchone() + self.assertEqual(len(r),1, + 'cursor.fetchone should have retrieved a single row' + ) + self.assertEqual(r[0],'Victoria Bitter', + 'cursor.fetchone retrieved incorrect data' + ) +## self.assertEqual(cur.fetchone(),None, +## 'cursor.fetchone should return None if no more rows available' +## ) + self.failUnless(cur.rowcount in (-1,1)) + finally: + con.close() + + # Same complaint as for fetchall and fetchone + def test_rowcount(self): + con = self._connect() + try: + cur = con.cursor() + self.executeDDL1(cur) +## self.assertEqual(cur.rowcount,-1, +## 'cursor.rowcount should be -1 after executing no-result ' +## 'statements' +## ) + cur.execute("insert into %sbooze values ('Victoria Bitter')" % ( + self.table_prefix + )) +## self.failUnless(cur.rowcount in (-1,1), +## 'cursor.rowcount should == number or rows inserted, or ' +## 'set to -1 after executing an insert statement' +## ) + cur.execute("select name from %sbooze" % self.table_prefix) + self.failUnless(cur.rowcount in (-1,1), + 'cursor.rowcount should == number of rows returned, or ' + 'set to -1 after executing a select statement' + ) + self.executeDDL2(cur) +## self.assertEqual(cur.rowcount,-1, +## 'cursor.rowcount not being reset to -1 after executing ' +## 'no-result statements' +## ) + finally: + con.close() + + def test_callproc(self): + pass # performed in test_MySQL_capabilities + + def help_nextset_setUp(self,cur): + ''' Should create a procedure called deleteme + that returns two result sets, first the + number of rows in booze then "name from booze" + ''' + sql=""" + create procedure deleteme() + begin + select count(*) from %(tp)sbooze; + select name from %(tp)sbooze; + end + """ % dict(tp=self.table_prefix) + cur.execute(sql) + + def help_nextset_tearDown(self,cur): + 'If cleaning up is needed after nextSetTest' + cur.execute("drop procedure deleteme") + + def test_nextset(self): + from warnings import warn + con = self._connect() + try: + cur = con.cursor() + if not hasattr(cur,'nextset'): + return + + try: + self.executeDDL1(cur) + sql=self._populate() + for sql in self._populate(): + cur.execute(sql) + + self.help_nextset_setUp(cur) + + cur.callproc('deleteme') + numberofrows=cur.fetchone() + assert numberofrows[0]== len(self.samples) + assert cur.nextset() + names=cur.fetchall() + assert len(names) == len(self.samples) + s=cur.nextset() + if s: + empty = cur.fetchall() + self.assertEquals(len(empty), 0, + "non-empty result set after other result sets") + #warn("Incompatibility: MySQL returns an empty result set for the CALL itself", + # Warning) + #assert s == None,'No more return sets, should return None' + finally: + self.help_nextset_tearDown(cur) + + finally: + con.close() + + +if __name__ == '__main__': + unittest.main() + print '''"Huh-huh, he said 'unit'." -- Butthead''' diff --git a/MySQLdb/test_capabilities.py b/MySQLdb/test_capabilities.py new file mode 100644 index 0000000..886a968 --- /dev/null +++ b/MySQLdb/test_capabilities.py @@ -0,0 +1,289 @@ +#!/usr/bin/env python -O +""" Script to test database capabilities and the DB-API interface + for functionality and memory leaks. + + Adapted from a script by M-A Lemburg. + +""" +from time import time +import array +import unittest + + +class DatabaseTest(unittest.TestCase): + + db_module = None + connect_args = () + connect_kwargs = dict() + create_table_extra = '' + rows = 10 + debug = False + + def setUp(self): + import gc + db = self.db_module.connect(*self.connect_args, **self.connect_kwargs) + self.connection = db + self.cursor = db.cursor() + self.BLOBText = ''.join([chr(i) for i in range(256)] * 100); + self.BLOBUText = u''.join([unichr(i) for i in range(16384)]) + self.BLOBBinary = self.db_module.Binary(''.join([chr(i) for i in range(256)] * 16)) + + leak_test = True + + def tearDown(self): + if self.leak_test: + import gc + del self.cursor + orphans = gc.collect() + self.failIf(orphans, "%d orphaned objects found after deleting cursor" % orphans) + + del self.connection + orphans = gc.collect() + self.failIf(orphans, "%d orphaned objects found after deleting connection" % orphans) + + def table_exists(self, name): + try: + self.cursor.execute('select * from %s where 1=0' % name) + except: + return False + else: + return True + + def quote_identifier(self, ident): + return '"%s"' % ident + + def new_table_name(self): + i = id(self.cursor) + while True: + name = self.quote_identifier('tb%08x' % i) + if not self.table_exists(name): + return name + i = i + 1 + + def create_table(self, columndefs): + + """ Create a table using a list of column definitions given in + columndefs. + + generator must be a function taking arguments (row_number, + col_number) returning a suitable data object for insertion + into the table. + + """ + self.table = self.new_table_name() + self.cursor.execute('CREATE TABLE %s (%s) %s' % + (self.table, + ',\n'.join(columndefs), + self.create_table_extra)) + + def check_data_integrity(self, columndefs, generator): + # insert + self.create_table(columndefs) + insert_statement = ('INSERT INTO %s VALUES (%s)' % + (self.table, + ','.join(['%s'] * len(columndefs)))) + data = [ [ generator(i,j) for j in range(len(columndefs)) ] + for i in range(self.rows) ] + if self.debug: + print data + self.cursor.executemany(insert_statement, data) + self.connection.commit() + # verify + self.cursor.execute('select * from %s' % self.table) + l = self.cursor.fetchall() + if self.debug: + print l + self.assertEquals(len(l), self.rows) + try: + for i in range(self.rows): + for j in range(len(columndefs)): + self.assertEquals(l[i][j], generator(i,j)) + finally: + if not self.debug: + self.cursor.execute('drop table %s' % (self.table)) + + def test_transactions(self): + columndefs = ( 'col1 INT', 'col2 VARCHAR(255)') + def generator(row, col): + if col == 0: return row + else: return ('%i' % (row%10))*255 + self.create_table(columndefs) + insert_statement = ('INSERT INTO %s VALUES (%s)' % + (self.table, + ','.join(['%s'] * len(columndefs)))) + data = [ [ generator(i,j) for j in range(len(columndefs)) ] + for i in range(self.rows) ] + self.cursor.executemany(insert_statement, data) + # verify + self.connection.commit() + self.cursor.execute('select * from %s' % self.table) + l = self.cursor.fetchall() + self.assertEquals(len(l), self.rows) + for i in range(self.rows): + for j in range(len(columndefs)): + self.assertEquals(l[i][j], generator(i,j)) + delete_statement = 'delete from %s where col1=%%s' % self.table + self.cursor.execute(delete_statement, (0,)) + self.cursor.execute('select col1 from %s where col1=%s' % \ + (self.table, 0)) + l = self.cursor.fetchall() + self.failIf(l, "DELETE didn't work") + self.connection.rollback() + self.cursor.execute('select col1 from %s where col1=%s' % \ + (self.table, 0)) + l = self.cursor.fetchall() + self.failUnless(len(l) == 1, "ROLLBACK didn't work") + self.cursor.execute('drop table %s' % (self.table)) + + def test_truncation(self): + columndefs = ( 'col1 INT', 'col2 VARCHAR(255)') + def generator(row, col): + if col == 0: return row + else: return ('%i' % (row%10))*((255-self.rows/2)+row) + self.create_table(columndefs) + insert_statement = ('INSERT INTO %s VALUES (%s)' % + (self.table, + ','.join(['%s'] * len(columndefs)))) + + try: + self.cursor.execute(insert_statement, (0, '0'*256)) + except Warning: + if self.debug: print self.cursor.messages + except self.connection.DataError: + pass + else: + self.fail("Over-long column did not generate warnings/exception with single insert") + + self.connection.rollback() + + try: + for i in range(self.rows): + data = [] + for j in range(len(columndefs)): + data.append(generator(i,j)) + self.cursor.execute(insert_statement,tuple(data)) + except Warning: + if self.debug: print self.cursor.messages + except self.connection.DataError: + pass + else: + self.fail("Over-long columns did not generate warnings/exception with execute()") + + self.connection.rollback() + + try: + data = [ [ generator(i,j) for j in range(len(columndefs)) ] + for i in range(self.rows) ] + self.cursor.executemany(insert_statement, data) + except Warning: + if self.debug: print self.cursor.messages + except self.connection.DataError: + pass + else: + self.fail("Over-long columns did not generate warnings/exception with executemany()") + + self.connection.rollback() + self.cursor.execute('drop table %s' % (self.table)) + + def test_CHAR(self): + # Character data + def generator(row,col): + return ('%i' % ((row+col) % 10)) * 255 + self.check_data_integrity( + ('col1 char(255)','col2 char(255)'), + generator) + + def test_INT(self): + # Number data + def generator(row,col): + return row*row + self.check_data_integrity( + ('col1 INT',), + generator) + + def test_DECIMAL(self): + # DECIMAL + def generator(row,col): + from decimal import Decimal + return Decimal("%d.%02d" % (row, col)) + self.check_data_integrity( + ('col1 DECIMAL(5,2)',), + generator) + + def test_DATE(self): + ticks = time() + def generator(row,col): + return self.db_module.DateFromTicks(ticks+row*86400-col*1313) + self.check_data_integrity( + ('col1 DATE',), + generator) + + def test_TIME(self): + ticks = time() + def generator(row,col): + return self.db_module.TimeFromTicks(ticks+row*86400-col*1313) + self.check_data_integrity( + ('col1 TIME',), + generator) + + def test_DATETIME(self): + ticks = time() + def generator(row,col): + return self.db_module.TimestampFromTicks(ticks+row*86400-col*1313) + self.check_data_integrity( + ('col1 DATETIME',), + generator) + + def test_TIMESTAMP(self): + ticks = time() + def generator(row,col): + return self.db_module.TimestampFromTicks(ticks+row*86400-col*1313) + self.check_data_integrity( + ('col1 TIMESTAMP',), + generator) + + def test_fractional_TIMESTAMP(self): + ticks = time() + def generator(row,col): + return self.db_module.TimestampFromTicks(ticks+row*86400-col*1313+row*0.7*col/3.0) + self.check_data_integrity( + ('col1 TIMESTAMP',), + generator) + + def test_LONG(self): + def generator(row,col): + if col == 0: + return row + else: + return self.BLOBUText # 'BLOB Text ' * 1024 + self.check_data_integrity( + ('col1 INT','col2 LONG'), + generator) + + def test_TEXT(self): + def generator(row,col): + return self.BLOBUText # 'BLOB Text ' * 1024 + self.check_data_integrity( + ('col2 TEXT',), + generator) + + def test_LONG_BYTE(self): + def generator(row,col): + if col == 0: + return row + else: + return self.BLOBBinary # 'BLOB\000Binary ' * 1024 + self.check_data_integrity( + ('col1 INT','col2 LONG BYTE'), + generator) + + def test_BLOB(self): + def generator(row,col): + if col == 0: + return row + else: + return self.BLOBBinary # 'BLOB\000Binary ' * 1024 + self.check_data_integrity( + ('col1 INT','col2 BLOB'), + generator) + |