python/mysqlclient
1
0
Fork 0
mirror of https://github.com/PyMySQL/mysqlclient.git synced 2025-08-15 11:10:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

Mostly documentation updates, and some code cleanups

Browse Source
This commit is contained in:
adustman
2002-06-18 01:01:47 +00:00
parent 58866a76fa
commit 05199fb0f9
5 changed files with 364 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
MySQLdb/MANIFEST.in
View File

@ -1,5 +1,5 @@
prune CVS
recursive-include doc *
recursive-include doc *.html *.sgml
recursive-include examples *
include README.MySQLmodule
include license.py

4
MySQLdb/MySQLdb/__init__.py
View File

@ -19,8 +19,8 @@ version_info = (
0,
9,
2,
"beta",
2)
"gamma",
1)
if version_info[3] == "final": __version__ = "%d.%d.%d" % version_info[:3]
else: __version__ = "%d.%d.%d%1.1s%d" % version_info[:5]

109
MySQLdb/MySQLdb/connections.py
View File

@ -18,35 +18,34 @@ def defaulterrorhandler(connection, cursor, errorclass, errorvalue):
connection.messages.append(errorvalue)
raise errorclass, errorvalue
class Connection:
"""Create a connection to the database. It is strongly recommended
that you only use keyword parameters. "NULL pointer" indicates that
NULL will be passed to mysql_real_connect(); the value in parenthesis
indicates how MySQL interprets the NULL. Consult the MySQL C API
"""
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 to or NULL pointer (localhost)
user -- string, user to connect as or NULL pointer (your username)
passwd -- string, password to use or NULL pointer (no password)
db -- string, database to use or NULL (no DB selected)
port -- integer, TCP/IP port to connect to or default MySQL port
unix_socket -- string, location of unix_socket to use or use TCP
client_flags -- integer, flags to use or 0 (see MySQL docs)
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_time -- 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 -- see the MySQL documentation for mysql_options()
read_default_group -- see the MySQL documentation for mysql_options()
cursorclass -- class object, used to create cursors or cursors.Cursor.
This parameter MUST be specified as a keyword parameter.
Returns a Connection object.
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)
There are a number of undocumented, non-standard methods. See the
documentation for the MySQL C API for some hints on what they do.
"""
default_cursor = cursors.Cursor
@ -73,84 +72,58 @@ class Connection:
def __del__(self):
if hasattr(self, '_db'): self.close()
def close(self):
"""Close the connection. No further activity possible."""
self._db.close()
def __getattr__(self, attr):
return getattr(self._db, attr)
def begin(self):
"""Explicitly begin a transaction. Non-standard."""
self._db.query("BEGIN")
self.query("BEGIN")
def commit(self):
"""Commit the current transaction."""
if self._transactional:
self._db.query("COMMIT")
self.query("COMMIT")
def rollback(self):
"""Rollback the current transaction."""
if self._transactional:
self._db.query("ROLLBACK")
self.query("ROLLBACK")
else:
raise NotSupportedError, "Not supported by server"
def cursor(self, cursorclass=None):
"""Create a cursor on which queries may be performed. The
"""
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."""
used.
"""
return (cursorclass or self.cursorclass)(self)
# Non-portable MySQL-specific stuff
# Methods not included on purpose (use Cursors instead):
# query, store_result, use_result
def literal(self, o):
"""If o is a single object, returns an SQL literal as a string.
If o is a non-string sequences, the items of the sequence are
converted and returned as a sequence."""
"""
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.
"""
import _mysql
return _mysql.escape(o, self._db.converter)
def unicode_literal(self, u, dummy=None):
"""Convert a unicode object u to a string using the current
"""
Convert a unicode object u to a string using the current
character set as the encoding. If that's not available,
use latin1."""
try: charset = self.character_set_name()
except: charset = 'latin1'
return self.literal(u.encode(charset))
def affected_rows(self): return self._db.affected_rows()
def dump_debug_info(self): return self._db.dump_debug_info()
def escape_string(self, s): return self._db.escape_string(s)
def get_host_info(self): return self._db.get_host_info()
def get_proto_info(self): return self._db.get_proto_info()
def get_server_info(self): return self._db.get_server_info()
def info(self): return self._db.info()
def kill(self, p): return self._db.kill(p)
def field_count(self): return self._db.field_count()
num_fields = field_count # used prior to MySQL-3.22.24
def ping(self): return self._db.ping()
def row_tell(self): return self._db.row_tell()
def select_db(self, db): return self._db.select_db(db)
def shutdown(self): return self._db.shutdown()
def stat(self): return self._db.stat()
def string_literal(self, s): return self._db.string_literal(s)
def thread_id(self): return self._db.thread_id()
def _try_feature(self, feature, *args, **kwargs):
try:
return apply(getattr(self._db, feature), args, kwargs)
except AttributeError:
self.errorhandler(self, None, NotSupportedError,
"not supported by MySQL library")
def character_set_name(self):
return self._try_feature('character_set_name')
def change_user(self, *args, **kwargs):
return apply(self._try_feature, ('change_user',)+args, kwargs)
latin1 is used.
"""
return self.literal(u.encode(self.character_set_name()))
Warning = Warning
Error = Error
InterfaceError = InterfaceError

29
MySQLdb/MySQLdb/converters.py
View File

@ -66,22 +66,34 @@ def Thing2Literal(o, d):
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)
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)==types.ClassType and isinstance(o,x), d.keys())
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), d.keys())
if not cl:
return d[types.StringType](o,d)
d[o.__class__] = d[cl[0]]
return d[cl[0]](o, d)
conversions = {
types.IntType: Thing2Str,
types.LongType: Long2Int,
@ -110,6 +122,9 @@ conversions = {
FIELD_TYPE.DATE: Date_or_None,
}
if hasattr(types, 'UnicodeType'):
conversions[types.UnicodeType] = Unicode2Str
if hasattr(types, 'ObjectType'):
conversions[types.ObjectType] = Instance2Str

340
MySQLdb/_mysql.c
View File

@ -201,22 +201,22 @@ _mysql_ResultObject_New(
}
static char _mysql_connect__doc__[] =
"connect() -- returns a MYSQL connection object. Exclusive use of\n\
keyword parameters strongly recommended. Consult the\n\
MySQL C API documentation for more details.\n\
"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 -- string, host to connect to or NULL pointer (localhost)\n\
user -- string, user to connect as or NULL (your username)\n\
passwd -- string, password to use or NULL (no password)\n\
db -- string, database to use or NULL (no DB selected)\n\
port -- integer, TCP/IP port to connect to or default MySQL port\n\
unix_socket -- string, location of unix_socket to use or use TCP\n\
client_flags -- integer, flags to use or 0 (see MySQL docs)\n\
conv -- dictionary, maps MySQL FIELD_TYPE.* to Python functions which\n\
host -- string, host to connect\n\
user -- string, user to connect as\n\
passwd -- string, password to use\n\
db -- string, database to use\n\
port -- integer, TCP/IP port to connect to\n\
unix_socket -- string, location of unix_socket (UNIX-ish only)\n\
conv -- mapping, maps MySQL FIELD_TYPE.* to Python functions which\n\
convert a string to the appropriate Python type\n\
connect_time -- number of seconds to wait before the connection\n\
connect_timeout -- number of seconds to wait before the connection\n\
attempt fails.\n\
compress -- if set, compression is enabled\n\
compress -- if set, gzip compression is enabled\n\
named_pipe -- if set, connect to server via named pipe (Windows only)\n\
init_command -- command which is run once the connection is created\n\
read_default_file -- see the MySQL documentation for mysql_options()\n\
read_default_group -- see the MySQL documentation for mysql_options()\n\
@ -308,6 +308,9 @@ _mysql_connect(
return (PyObject *) c;
}
static char _mysql_ConnectionObject_close__doc__[] =
"Close the connection. No further activity possible.";
static PyObject *
_mysql_ConnectionObject_close(
_mysql_ConnectionObject *self,
@ -326,6 +329,11 @@ _mysql_ConnectionObject_close(
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,
@ -337,7 +345,7 @@ _mysql_ConnectionObject_affected_rows(
}
static char _mysql_debug__doc__[] =
"debug(s) -- Does a DBUG_PUSH with the given string.\n\
"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\
@ -354,6 +362,12 @@ _mysql_debug(
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,
@ -370,6 +384,12 @@ _mysql_ConnectionObject_dump_debug_info(
return Py_None;
}
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,
@ -380,6 +400,12 @@ _mysql_ConnectionObject_errno(
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,
@ -878,6 +904,24 @@ _mysql_ResultObject_fetch_row(
}
#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,
@ -893,7 +937,7 @@ _mysql_ConnectionObject_change_user(
return NULL;
check_connection(self);
Py_BEGIN_ALLOW_THREADS
r = mysql_change_user(&(self->connection), user, pwd, db);
r = mysql_change_user(&(self->connection), user, pwd, db);
Py_END_ALLOW_THREADS
if (r) return _mysql_Exception(self);
Py_INCREF(Py_None);
@ -901,7 +945,11 @@ _mysql_ConnectionObject_change_user(
}
#endif
#if MYSQL_VERSION_ID >= 32321
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,
@ -910,10 +958,13 @@ _mysql_ConnectionObject_character_set_name(
const char *s;
if (!PyArg_NoArgs(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);
}
#endif
static char _mysql_get_client_info__doc__[] =
"get_client_info() -- Returns a string that represents\n\
@ -927,6 +978,11 @@ _mysql_get_client_info(
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,
@ -937,6 +993,11 @@ _mysql_ConnectionObject_get_host_info(
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,
@ -947,6 +1008,11 @@ _mysql_ConnectionObject_get_proto_info(
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,
@ -957,6 +1023,12 @@ _mysql_ConnectionObject_get_server_info(
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,
@ -971,6 +1043,27 @@ _mysql_ConnectionObject_info(
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,
@ -985,6 +1078,9 @@ _mysql_ConnectionObject_insert_id(
return PyLong_FromUnsignedLongLong(r);
}
static char _mysql_ConnectionObject_kill__doc__[] =
"Asks the server to kill the thread specified by pid.\n";
static PyObject *
_mysql_ConnectionObject_kill(
_mysql_ConnectionObject *self,
@ -1002,6 +1098,12 @@ _mysql_ConnectionObject_kill(
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,
@ -1036,6 +1138,18 @@ _mysql_ResultObject_num_rows(
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\
Non-standard.\n\
";
static PyObject *
_mysql_ConnectionObject_ping(
_mysql_ConnectionObject *self,
@ -1069,6 +1183,19 @@ _mysql_ConnectionObject_query(
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,
@ -1086,6 +1213,11 @@ _mysql_ConnectionObject_select_db(
return Py_None;
}
static char _mysql_ConnectionObject_shutdown__doc__[] =
"Asks the database server to shut down. The connected user must\n\
have shutdown privileges.\n\
";
static PyObject *
_mysql_ConnectionObject_shutdown(
_mysql_ConnectionObject *self,
@ -1102,6 +1234,13 @@ _mysql_ConnectionObject_shutdown(
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,
@ -1137,6 +1276,16 @@ _mysql_ConnectionObject_store_result(
self->converter);
}
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\
";
static PyObject *
_mysql_ConnectionObject_thread_id(
_mysql_ConnectionObject *self,
@ -1266,34 +1415,141 @@ _mysql_ResultObject_repr(
}
static PyMethodDef _mysql_ConnectionObject_methods[] = {
{"affected_rows", (PyCFunction)_mysql_ConnectionObject_affected_rows, 0},
{
"affected_rows",
(PyCFunction)_mysql_ConnectionObject_affected_rows,
0,
_mysql_ConnectionObject_affected_rows__doc__
},
#if MYSQL_VERSION_ID >= 32303
{"change_user", (PyCFunction)_mysql_ConnectionObject_change_user, METH_VARARGS | METH_KEYWORDS},
{
"change_user",
(PyCFunction)_mysql_ConnectionObject_change_user,
METH_VARARGS | METH_KEYWORDS,
_mysql_ConnectionObject_change_user__doc__
},
#endif
#if MYSQL_VERSION_ID >= 32321
{"character_set_name", (PyCFunction)_mysql_ConnectionObject_character_set_name, 0},
#endif
{"close", (PyCFunction)_mysql_ConnectionObject_close, 0},
{"dump_debug_info", (PyCFunction)_mysql_ConnectionObject_dump_debug_info, 0},
{"escape", (PyCFunction)_mysql_escape, 1},
{"escape_string", (PyCFunction)_mysql_escape_string, 1},
{"error", (PyCFunction)_mysql_ConnectionObject_error, 0},
{"errno", (PyCFunction)_mysql_ConnectionObject_errno, 0},
{"field_count", (PyCFunction)_mysql_ConnectionObject_field_count, 0},
{"get_host_info", (PyCFunction)_mysql_ConnectionObject_get_host_info, 0},
{"get_proto_info", (PyCFunction)_mysql_ConnectionObject_get_proto_info, 0},
{"get_server_info", (PyCFunction)_mysql_ConnectionObject_get_server_info, 0},
{"info", (PyCFunction)_mysql_ConnectionObject_info, 0},
{"insert_id", (PyCFunction)_mysql_ConnectionObject_insert_id, 0},
{"kill", (PyCFunction)_mysql_ConnectionObject_kill, 1},
{"ping", (PyCFunction)_mysql_ConnectionObject_ping, 0},
{"query", (PyCFunction)_mysql_ConnectionObject_query, 1},
{"select_db", (PyCFunction)_mysql_ConnectionObject_select_db, 1},
{"shutdown", (PyCFunction)_mysql_ConnectionObject_shutdown, 0},
{"stat", (PyCFunction)_mysql_ConnectionObject_stat, 0},
{
"character_set_name",
(PyCFunction)_mysql_ConnectionObject_character_set_name,
METH_VARARGS,
_mysql_ConnectionObject_character_set_name__doc__
},
{
"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,
1,
_mysql_ConnectionObject_kill__doc__
},
{
"ping",
(PyCFunction)_mysql_ConnectionObject_ping,
0,
_mysql_ConnectionObject_ping__doc__
},
{
"query",
(PyCFunction)_mysql_ConnectionObject_query,
1,
},
{
"select_db",
(PyCFunction)_mysql_ConnectionObject_select_db,
1,
_mysql_ConnectionObject_select_db__doc__
},
{
"shutdown",
(PyCFunction)_mysql_ConnectionObject_shutdown,
0,
_mysql_ConnectionObject_shutdown__doc__
},
{
"stat",
(PyCFunction)_mysql_ConnectionObject_stat,
METH_VARARGS,
_mysql_ConnectionObject_stat__doc__
},
{"store_result", (PyCFunction)_mysql_ConnectionObject_store_result, 0},
{"string_literal", (PyCFunction)_mysql_string_literal, 1},
{"thread_id", (PyCFunction)_mysql_ConnectionObject_thread_id, 0},
{
"thread_id",
(PyCFunction)_mysql_ConnectionObject_thread_id,
METH_VARARGS,
_mysql_ConnectionObject_thread_id__doc__
},
{"use_result", (PyCFunction)_mysql_ConnectionObject_use_result, 0},
{NULL, NULL} /* sentinel */
};
@ -1485,7 +1741,7 @@ _mysql_NewException(
}
static char _mysql___doc__[] =
"_mysql: an adaptation of the MySQL C API (mostly)\n\
"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\