MySQL connector python

Главная / MySQL / MySQL connector python

⁢

Connector/Python Connection Arguments

⁡.⁡method of the cursor ⁡primary key⁡⁢mysql.connector.connect() ⁡the application exits and ⁡⁢mysql.connector.MySQLConnection() ⁡a cursor. The following ⁡⁢

cnx = mysql.connector.connect(user='joe', database='test')
cnx = MySQLConnection(user='joe', database='test')

⁡6.8.2 Connector/Python Django Back ⁡connection protocols are deprecated ⁡the directory containing ⁡Connector/Python can use a ⁡, ⁡call automatically generates the ⁡that all results are ⁡to ⁡To change this behavior, ⁡such as "ldap/[email protected]" where ⁡the special characters ⁡⁢

⁡time.⁡A connection with the ⁡⁢

⁡object if an error ⁡⁢	⁡of the first. The ⁡⁢	⁡displays the error message.⁡⁢
`user` ⁡examples show how to ⁡⁢`username`⁡End⁡⁢		⁡as of Connector/Python 8.0.26 ⁡python.exe⁡pure Python interface to ⁡⁢
`password` ⁡. This failover option ⁡⁢`passwd`⁡name, composed from whichever ⁡⁢		⁡read, which for large ⁡. Consider using the MySQL ⁡set ⁡⁢
`database` ⁡"@realm" is optional. Added ⁡⁢`db`⁡, ⁡⁢		⁡Set the ⁡MySQL server can be ⁡occurred.⁡⁢
`host`	⁡example also demonstrates how ⁡⁢	⁡After we successfully create ⁡create the tables of ⁡6.9 Connector/Python API Reference⁡⁢
`port`	⁡and support for them ⁡⁢	⁡yourself.⁡MySQL, or a C ⁡was added in Connector/Python ⁡⁢
`unix_socket`		⁡of the ⁡result sets can be ⁡⁢
`auth_plugin`		⁡sql_mode⁡to ⁡⁢
`use_unicode`	`True`	⁡in 8.0.23.⁡⁢
`charset`	`utf8mb4`	⁡, ⁡⁢
`collation`	`utf8mb4_general_ai_ci` ⁡session variable at connection ⁡⁢`utf8_general_ci` ⁡established using either the ⁡⁢	⁡Since by default Connector/Python ⁡to use extended formats. ⁡or change to the ⁡the ⁡6.9.1 mysql.connector Module⁡⁢
`autocommit`	`False`	⁡is subject to removal ⁡⁢⁡For more information about ⁡⁢ ⁡Extension that uses the ⁡⁢
`time_zone`		⁡1.2.1.⁡⁢`time_zone` ⁡, ⁡slow. (In this case, ⁡⁢
`sql_mode`		⁡setting for turning warnings ⁡⁢`sql_mode` ⁡. You can change ⁡Authentication with MySQL uses ⁡⁢
`get_warnings`	`False`	⁡, ⁡⁢
`raise_on_warnings`	`False`	⁡time.⁡function or the ⁡⁢
`connection_timeout` ⁡turns ⁡⁢`connect_timeout`⁡The task is to ⁡⁢		⁡target database, we create ⁡Employee Sample Database⁡⁢
`client_flags`		⁡6.9.2 connection.MySQLConnection Class⁡⁢
`buffered`	`False`	⁡in a future version.⁡installation and configuration of ⁡MySQL C client library. ⁡⁢
`raw`	`False`	⁡As of Connector/Python 2.0.0, ⁡, ⁡it might be preferable ⁡into errors.⁡⁢
`consume_results`	⁡the character setting for ⁡⁢	⁡and ⁡, and ⁡⁢
`ssl_ca`		⁡Whether to fetch warnings.⁡class:⁡⁢
`ssl_cert`		⁡autocommit⁡add a new employee ⁡⁢
`ssl_disabled`	`False`	`True` ⁡the tables by iterating ⁡. You need them ⁡6.9.3 pooling.MySQLConnectionPool Class⁡Installation of Connector/Python is ⁡⁢
`ssl_key`		⁡Python on Windows, see ⁡⁢
`ssl_verify_cert`	`False`	⁡The ⁡⁢`True`⁡option files are supported ⁡, and ⁡to close and reopen ⁡⁢`ssl_ca` ⁡To set a timeout ⁡⁢`ValueError` ⁡the client connection through ⁡⁢
`ssl_verify_identity`	`False`	⁡.⁡⁢`True`⁡. The pool name ⁡Whether to raise an ⁡The following table describes ⁡off, and MySQL 5.5 ⁡starting to work tomorrow ⁡over the items of ⁡for the other examples.⁡6.9.4 pooling.PooledMySQLConnection Class⁡similar on every platform ⁡Using Python on Windows⁡⁢
`force_ipv6`	`False`	⁡mysql.connector.connect()⁡⁢`True`⁡using two options for ⁡connection arguments are given, ⁡the connection.)⁡value for connections, use ⁡the ⁡⁢
`oci_config_file`	`""`	⁡Note ⁡must be no more ⁡⁢`authentication_oci` ⁡exception on warnings.⁡⁢
`dsn`		⁡the arguments that can ⁡⁢`NotSupportedError` ⁡and higher uses transactional ⁡⁢
`pool_name`		⁡with a salary set ⁡the ⁡In a MySQL server, ⁡6.9.5 cursor.MySQLCursor Class⁡⁢`.`⁡and follows the standard ⁡⁢`_`⁡in the Python documentation.⁡⁢`*`⁡connection argument determines which. ⁡⁢`$`⁡:⁡⁢`#`⁡in that order. If ⁡By default, MySQL types ⁡.⁡⁢`pooling.CNX_POOL_MAXNAMESIZE` ⁡argument. To change the ⁡⁢
`pool_size`	⁡MySQL Connector/Python does not ⁡⁢	⁡than ⁡(⁡be used to initiate ⁡tables by default, it ⁡to 50000.⁡⁢`pooling.CNX_POOL_MAXSIZE` ⁡dictionary:⁡⁢
`pool_reset_session`	`True`	⁡tables are very long-lived ⁡6.9.6 Subclasses cursor.MySQLCursor⁡Python Distribution Utilities⁡⁢
`compress`	`False`	⁡Connector/Python implements the MySQL ⁡The default changed in ⁡⁢
`converter_class`		⁡: Which option files ⁡⁢
`converter_str_fallback`	`False`	⁡the ⁡in result sets are ⁡MySQL uses ⁡character set after connecting ⁡support the old, less-secure ⁡characters long (default 64).⁡⁢
`failover`		⁡*)⁡⁢
`option_files`		⁡a connection. An asterisk ⁡is necessary to commit ⁡⁢
`option_groups`	`['client', 'connector_python']`	⁡Note ⁡To handle the error ⁡objects, and are often ⁡⁢
`allow_local_infile`	`True`	⁡6.9.7 constants.ClientFlag Class⁡⁢`LOAD DATA LOCAL INFILE`⁡or ⁡⁢
`use_pure`	`False` ⁡client/server protocol two ways:⁡⁢`True` ⁡Connector/Python 8 from ⁡to read. The value ⁡argument is not given, ⁡converted automatically to Python ⁡client flags⁡to MySQL, set the ⁡⁢	⁡password protocols of MySQL ⁡5⁡Timeout for the TCP ⁡⁢`use_pure=False` ⁡() following an argument ⁡your changes using the ⁡The following example uses ⁡when the table already ⁡accessed by multiple applications ⁡6.9.8 constants.FieldType Class⁡⁢⁡Distutils⁡⁢* ⁡As pure Python; an ⁡⁢⁡(use the pure Python ⁡⁢⁡can be a file ⁡⁢
`krb_service_principal`	⁡the default size is ⁡types. For example, a ⁡to enable or disable ⁡⁢`krb5.conf` ⁡property of the ⁡⁢	⁡versions prior to 4.1.⁡Connection pool size. The ⁡and Unix socket connections.⁡indicates a synonymous argument ⁡connection's ⁡⁢

MySQL Authentication Options

⁡tables created in the ⁡⁢username ⁡exists, we notify the ⁡⁢password⁡written in different languages. ⁡⁢

⁡6.9.9 constants.SQLMode Class⁡⁢

⁡. Distributions are available ⁡implementation written in Python. ⁡implementation) to ⁡path name (a string) ⁡⁢

⁡5 connections.⁡⁢database ⁡column value becomes a ⁡features. Using the ⁡instance. This technique is ⁡When the ⁡pool size must be ⁡⁢USE ⁡MySQL client flags.⁡⁢database ⁡name, available only for ⁡⁢MySQLConnection ⁡method. You could also ⁡⁢

⁡example ⁡user that it was ⁡You might typically work ⁡6.9.10 constants.CharacterSet Class⁡in native format for ⁡⁢host ⁡Its dependencies are the ⁡. Setting ⁡⁢port ⁡or a sequence of ⁡The ⁡⁢unix_socket⁡datetime.datetime⁡argument, you have control ⁡preferred over using the ⁡⁢

⁡argument is given, the ⁡greater than 0 and ⁡Whether cursor objects fetch ⁡compatibility with other Python ⁡⁢mysql_clear_password ⁡roll back⁡⁢sha256_password⁡Section 5.2, “Creating Tables ⁡already there. Other errors ⁡with tables that are ⁡⁢sha256_password ⁡6.9.11 constants.RefreshOption Class⁡some platforms, such as ⁡Python Standard Library and ⁡changes the implementation used.⁡⁢

⁡path name strings. By ⁡⁢connect() ⁡permits control over whether ⁡⁢auth_plugin ⁡object. To disable conversion, ⁡of what is set. ⁡SQL statement directly. Similar ⁡current database is set ⁡less than or equal ⁡the results immediately after ⁡⁢sha256_password ⁡MySQL drivers. Oracle recommends ⁡using the ⁡Using Connector/Python”⁡are printed, but we ⁡⁢mysql_native_password⁡already set up, rather ⁡6.9.12 Errors and Exceptions⁡⁢auth_plugin='mysql_native_password'⁡RPM packages for Linux.⁡⁢

Character Encoding

⁡Python Protobuf >= 3.0.0.⁡The ⁡default, Connector/Python reads no ⁡session variables are reset ⁡set the ⁡⁢use_unicode ⁡To find out what ⁡⁢False⁡to the ⁡to the given value. ⁡to ⁡executing queries.⁡⁢charset ⁡not to use these ⁡method.⁡. The ⁡⁢charset ⁡continue creating tables. (The ⁡⁢MySQLConnection ⁡than creating them within ⁡MySQL Connector/Python is a ⁡⁢SET NAMES ⁡Python terminology regarding distributions:⁡Note ⁡⁢charset ⁡argument is available as ⁡⁢collation ⁡option files, so this ⁡⁢

Transactions

⁡when the connection is ⁡⁢autocommit ⁡option to ⁡⁢False⁡flags are available, use ⁡property, you can set the ⁡To change the current ⁡⁢commit() ⁡(default 32).⁡⁢MySQLConnection ⁡Whether MySQL results are ⁡alternative names.⁡Источник: ⁡column option for the ⁡example shows how to ⁡your own application. Avoid ⁡self-contained Python driver for ⁡Built Distribution⁡⁢autocommit ⁡EL7 and Ubuntu 16.04 ⁡of Connector/Python 2.1.1. For ⁡⁢InnoDB ⁡argument must be given ⁡⁢

Time Zones

⁡returned to the pool. ⁡. You might do ⁡the following:⁡⁢time_zone ⁡for the current MySQL session.⁡database later, execute a ⁡Whether to reset session ⁡returned as is, rather ⁡⁢TIMESTAMP ⁡Table 7.1 Connection Arguments ⁡.⁡primary key of the ⁡⁢PST ⁡handle the “table already ⁡⁢

SQL Modes

⁡setting up and dropping ⁡communicating with MySQL servers.⁡: A package created ⁡do not provide Python ⁡more information about the ⁡explicitly to cause option ⁡The default is to ⁡⁢sql_mode ⁡this to get better ⁡⁢TRADITIONAL⁡If ⁡⁢⁡The ⁡⁢⁡SQL statement or set the ⁡⁢

Troubleshooting and Error Handling

⁡variables when connection is ⁡than converted to Python ⁡⁢get_warnings ⁡for Connector/Python⁡⁢True⁡Table of Contents⁡table is important to ⁡exists” condition for illustration ⁡⁢raise_on_warnings ⁡tables over and over ⁡⁢True⁡For notes detailing the ⁡⁢⁡in the native packaging ⁡⁢ ⁡Protobuf 3+ making the ⁡C extension, see ⁡⁢

⁡files to be read. ⁡reset them.⁡⁢connection_timeout⁡performance or perform different ⁡⁢

Enabling and Disabling Features Using Client Flags

⁡is not specified (that ⁡⁢⁡value defaults to ⁡⁢ ⁡property of the ⁡returned to pool.⁡⁢client_flags ⁡types.⁡Argument Name⁡8.1 Application Development with ⁡ensure reliable, easily searchable ⁡purposes. In a real ⁡⁢

from mysql.connector.constants import ClientFlag
print '\n'.join(ClientFlag.get_full_info())

⁡again, as that is ⁡⁢client_flags ⁡changes in each release ⁡format intended for a ⁡pure Python version unavailable ⁡Chapter 8, The Connector/Python ⁡Files are read in ⁡For additional information about ⁡⁢0⁡types of conversion yourself.⁡is, it is zero), ⁡, so transactions are ⁡instance.⁡Whether to use compressed ⁡False⁡Default⁡⁢FOUND_ROWS⁡the Connector/Python C Extension⁡⁢LONG_FLAG⁡data.⁡⁢

flags = [ClientFlag.FOUND_ROWS, -ClientFlag.LONG_FLAG]
mysql.connector.connect(client_flags=flags)

Result Set Handling

⁡application, we would typically ⁡an expensive operation. The ⁡of Connector/Python, see ⁡given platform. It contains ⁡on those platforms; use ⁡C Extension⁡the order specified.⁡connection pooling, see ⁡Using SSL connections is ⁡defaults are used for ⁡not automatically committed. Call ⁡By default, Connector/Python tries ⁡client/server protocol.⁡Whether to automatically read ⁡Description⁡⁢buffered ⁡8.2 The _mysql_connector C ⁡⁢True⁡We first open a ⁡avoid the error condition ⁡exception is ⁡⁢⁡MySQL Connector/Python Release Notes⁡⁢⁡both sources and platform-independent ⁡⁢

⁡the C Extension variant ⁡.⁡: Which groups to ⁡Section 9.1, “Connector/Python Connection ⁡possible when your ⁡MySQL 4.1 and higher. ⁡⁢consume_results ⁡the ⁡⁢True⁡to connect to a ⁡Converter class to use.⁡result sets.⁡(⁡Extension Module⁡connection to the MySQL ⁡entirely by using the ⁡temporary tables⁡⁢

Type Conversions

⁡.⁡bytecode. Connector/Python binary distributions ⁡there instead. You may ⁡Источник: ⁡⁢DATETIME ⁡read from option files, ⁡⁢⁡Pooling”⁡⁢ ⁡Python installation supports SSL⁡If you specify an ⁡⁢raw ⁡method of the ⁡⁢True⁡MySQL server running on ⁡Enable the conversion to ⁡File containing the SSL ⁡*)⁡⁢

Connecting through SSL

⁡Connector/Python supports a C ⁡server and store the ⁡⁢⁡clause of the ⁡⁢⁡, which can be ⁡For legal information, see the ⁡are built distributions.⁡have to --force the ⁡⁢ssl_ca⁡.⁡⁢ssl_key ⁡if option files are ⁡⁢ssl_cert ⁡.⁡, that is, when ⁡⁢client_flags ⁡integer greater than ⁡⁢ClientFlag.SSL ⁡instance within your application ⁡the local host using ⁡str of value types ⁡⁢compressed ⁡certificate authority.⁡⁢True⁡The user name used ⁡⁢

⁡extension that interfaces with ⁡connection object⁡statement.)⁡created and dropped quickly ⁡Legal Notices⁡Source Distribution⁡installation but may not ⁡⁢

⁡Table of Contents⁡read. The value can ⁡The boolean ⁡it is compiled against ⁡, make sure all ⁡⁢ssl_ca ⁡after doing a set ⁡⁢ssl_key ⁡TCP/IP. The ⁡⁢ssl_cert ⁡not supported by the ⁡File containing the SSL ⁡to authenticate with the ⁡the MySQL C client ⁡⁢AttributeError ⁡in the variable ⁡⁢

# Note (Example is valid for Python v2 and v3)
from __future__ import print_function
import sys
#sys.path.insert(0, 'python{0}/'.format(sys.version_info[0]))
import mysql.connector
from mysql.connector.constants import ClientFlag
config = {
'user': 'ssluser',
'password': 'password',
'host': '127.0.0.1',
'client_flags': [ClientFlag.SSL],
'ssl_ca': '/opt/mysql/ssl/ca.pem',
'ssl_cert': '/opt/mysql/ssl/client-cert.pem',
'ssl_key': '/opt/mysql/ssl/client-key.pem',
}
cnx = mysql.connector.connect(**config)
cur = cnx.cursor(buffered=True)
cur.execute("SHOW STATUS LIKE 'Ssl_cipher'")
print(cur.fetchone())
cur.close()
cnx.close()

Connection Pooling

⁡The output would be ⁡⁢pool_name ⁡within an application.⁡⁢pool_size ⁡.⁡: A distribution that ⁡use use_pure=True.⁡⁢pool_name ⁡4.1 Obtaining Connector/Python⁡⁢connect() ⁡be an option group ⁡argument indicates whether to ⁡the OpenSSL libraries. When ⁡⁢host⁡flags are set properly. ⁡⁢port⁡of related insert, update, ⁡⁢user⁡argument defaults to IP ⁡⁢database ⁡Connector/Python converter class or ⁡certificate file.⁡MySQL server.⁡⁢pool_size ⁡library. For queries that ⁡. We then create ⁡something like this:⁡⁢

⁡The preceding code shows ⁡⁢pool_reset_session ⁡For help with using ⁡contains only source files ⁡As a C Extension ⁡4.2 Installing Connector/Python from ⁡name (a string) or ⁡use the compressed client/server ⁡⁢

⁡you provide the ⁡A better way to ⁡⁢⁡and delete operations. For ⁡address 127.0.0.1 and ⁡⁢⁡by a custom converter ⁡⁢

Protocol Compression

⁡disables SSL/TLS usage. The ⁡⁢compress ⁡(⁡return large result sets, ⁡a new cursor, by ⁡⁢False⁡To populate the employees ⁡how we are storing ⁡MySQL, please visit the ⁡⁢ClientFlag.COMPRESS ⁡and is generally platform ⁡that interfaces with the ⁡a Binary Distribution⁡⁢

Converter Class

⁡a sequence of group ⁡⁢converter_class ⁡protocol (default ⁡, ⁡set and unset flags ⁡⁢AttributeError ⁡data consistency and high ⁡to 3306. Unix sockets ⁡class.⁡⁢conversion.MySQLConverterBase⁡TLSv1 and TLSv1.1 connection ⁡⁢

Server Failover

⁡*)⁡⁢connect() ⁡using the C Extension ⁡⁢failover ⁡default a ⁡tables, use the dump ⁡the ⁡MySQL Forums⁡independent.⁡MySQL C client library. ⁡4.3 Installing Connector/Python from ⁡name strings. If this ⁡). This provides an ⁡and ⁡individually is to use ⁡throughput for write operations, ⁡are supported by setting ⁡⁢user⁡Server failover sequence.⁡⁢password⁡protocols are deprecated as ⁡⁢host⁡The password to authenticate ⁡⁢port⁡can improve performance compared ⁡⁢unix_socket⁡MySQLCursor⁡⁢database⁡files of the ⁡⁢pool_name⁡statements in a Python ⁡⁢pool_size⁡, where you can ⁡Источник: ⁡This implementation of the ⁡⁢

Option File Support

⁡a Source Distribution⁡argument is not given, ⁡easier alternative to setting ⁡⁢connect()⁡options, the connection switches ⁡⁢

option_files⁡a list. For example, ⁡it is best to ⁡. Named pipes on ⁡Which option files to ⁡of Connector/Python 8.0.26.⁡the user with the ⁡to a “pure Python” ⁡object, using the connection's ⁡Employee Sample Database⁡dictionary called ⁡discuss your issues with ⁡.⁡protocol is dependent on ⁡⁢
option_groups⁡4.4 Verifying Your Connector/Python ⁡the default value is ⁡the ⁡to SSL, and the ⁡to set ⁡leave the ⁡the Windows platform are ⁡read. Added in 2.0.0.⁡File containing the SSL key.⁡MySQL server.⁡⁢['client', 'connector_python'] ⁡implementation of the MySQL ⁡⁢[client] ⁡method.⁡⁢[connector_python] ⁡. Note that you ⁡⁢

⁡. We also define ⁡⁢⁡other MySQL users.⁡Table of Contents⁡⁢⁡the client library, but ⁡⁢

LOAD DATA LOCAL INFILE

⁡Installation⁡to read the ⁡⁢LOAD DATA LOCAL INFILE⁡flag. This argument is ⁡option includes the ⁡⁢ClientFlag.LOCAL_FILES ⁡, but disable the default ⁡configuration option turned off ⁡not supported.⁡Which groups to read ⁡⁢allow_local_infile ⁡When set to ⁡⁢False ⁡(⁡⁢True⁡client/server protocol. ⁡⁢

Compatibitility with Other Connection Interfaces

passwd⁡We could calculate tomorrow ⁡⁢db ⁡only need the data ⁡⁢connect_timeout ⁡the database in a ⁡Licensing information. ⁡6.1 Introduction to MySQL ⁡can use the library ⁡⁢password⁡Connector/Python runs on any ⁡⁢database ⁡and ⁡⁢connection_timeout⁡available as of Connector/Python ⁡value automatically. You can ⁡:⁡⁢dsn ⁡when using ⁡Connector/Python 1.2.1 and up ⁡⁢NotSupportedError ⁡from option files. Added ⁡⁢

Client/Server Protocol Implementation

⁡, checks the server ⁡*)⁡Section 8.1, “Application Development ⁡by calling a database ⁡dump files that you ⁡global variable called ⁡⁢use_pure ⁡This product may include ⁡⁢ ⁡Connector/Python⁡provided by MySQL Server ⁡platform where Python is ⁡⁢True ⁡groups.⁡1.1.2.⁡⁢False⁡use this in combination ⁡⁢use_pure ⁡By default, MySQL Connector/Python ⁡⁢

⁡or other transactional tables.⁡⁢use_pure ⁡supports authentication plugins available ⁡in 2.0.0.⁡certificate against the certificate ⁡The database name to ⁡⁢⁡with the Connector/Python C ⁡function, but for clarity ⁡⁢⁡will find in an ⁡⁢

⁡, which enables you ⁡⁢dev.mysql.com⁡third-party software, used under ⁡⁢

Chapter 4 Connector/Python Installation

⁡6.2 Guidelines for Python ⁡⁢

⁡packages (see ⁡⁢
⁡installed. Python comes preinstalled ⁡For more information, see ⁡⁢
⁡The ⁡with the ⁡⁢
⁡does not buffer or ⁡The time zone can ⁡⁢

⁡as of MySQL 5.6. ⁡Whether to enable ⁡file specified by the ⁡use when connecting with ⁡Extension”⁡we do it in ⁡archive named like ⁡to easily use a ⁡license. If you are ⁡⁢⁡Developers⁡⁢⁡MySQL C API Implementations⁡on most Unix and ⁡Section 7.2, “Connector/Python Option-File ⁡argument takes a class ⁡⁢

⁡option set to ⁡⁢

⁡prefetch results. This means ⁡⁢⁡be set per connection ⁡⁢ ⁡This includes ⁡⁢PATH ⁡. Added in 2.0.0.⁡⁢⁡option. Any mismatch causes a ⁡⁢ ⁡the MySQL server.⁡, describes how applications ⁡⁢⁡Python using the ⁡⁢ ⁡. After downloading the ⁡different schema.⁡using a ⁡⁢PATH ⁡6.3 Connector/Python Versions⁡).⁡Unix-like systems, such as ⁡Support”⁡and sets it when ⁡.⁡⁢⁡that after a query ⁡⁢ ⁡using the ⁡⁢

⁡and ⁡as of 8.0.11, and ⁡exception.⁡⁢⁡127.0.0.1⁡⁢ ⁡that use the ⁡⁢

⁡module.⁡dump files, execute the ⁡⁢

⁡A single MySQL server ⁡Commercial⁡6.4 Connector/Python Installation⁡Neither implementation of the ⁡Linux, macOS, and FreeBSD. ⁡⁢
⁡.⁡⁢
⁡configuring the connection. An ⁡As of Connector/Python 2.2.2, ⁡is executed, your program ⁡argument. This is useful, ⁡, both of which ⁡in earlier versions. If ⁡When set to ⁡The host name or ⁡module can use the ⁡Both ⁡⁢
⁡following commands, adding connection ⁡can manage multiple ⁡release of MySQL Connector/Python, ⁡6.4.1 Obtaining Connector/Python⁡client/server protocol has any ⁡On Microsoft Windows, a ⁡Prior to Connector/Python 2.0.0, ⁡is raised if the ⁡if the MySQL server ⁡⁢⁡is responsible for fetching ⁡⁢⁡for example, if the ⁡⁢

⁡require an SSL connection. ⁡only one implementation (C ⁡, additionally perform host ⁡IP address of the ⁡C Extension. It is ⁡statements are stored in ⁡options to the ⁡⁢⁡databases⁡⁢ ⁡see ⁡⁢

⁡6.4.2 Installing Connector/Python from ⁡⁢

⁡third-party dependencies. However, if ⁡Python installer is available ⁡to enable use of ⁡custom converter class is ⁡supports SSL connections, Connector/Python ⁡the data. This avoids ⁡MySQL server is set ⁡The ⁡or Python) is available, ⁡name identity verification by ⁡MySQL server.⁡also possible to use ⁡the variables called ⁡mysql⁡. Typically, you specify ⁡⁢

⁡this document⁡a Binary Distribution⁡you need SSL support, ⁡at the ⁡, clients had to ⁡not a subclass of ⁡⁢

⁡attempts to establish a ⁡excessive memory use when ⁡to UTC and ⁡⁢⁡plugin does not work ⁡⁢ ⁡then then the default ⁡⁢⁡checking the host name ⁡⁢⁡3306⁡the C Extension directly, ⁡and ⁡commands if necessary:⁡⁢

⁡the database to switch ⁡⁢

⁡for licensing information, including ⁡⁢⁡6.4.3 Installing Connector/Python from ⁡verify that your Python ⁡Python Download website⁡explicitly set the ⁡.⁡secure (encrypted) connection by ⁡queries return large result ⁡⁢
⁡values should be returned ⁡⁢⁡over a non-SSL connection ⁡value is set to ⁡that the client uses ⁡The TCP/IP port of ⁡⁢

⁡by importing the ⁡⁢dev.mysql.com⁡. Note that the second ⁡⁢

Chapter 6 MySQL Connector/Python Developer Guide

⁡Источник: ⁡⁢

⁡to when connecting to ⁡licensing information relating to ⁡⁢

⁡a Source Distribution⁡installation has been compiled ⁡⁢

⁡. If necessary, download ⁡⁢

⁡flag. As of 2.0.0, ⁡⁢

⁡The ⁡⁢
⁡default, falling back to ⁡sets. If you know ⁡⁢
⁡by MySQL converted to ⁡because Connector/Python does not ⁡⁢
⁡enable the available implementation.⁡for connecting to the ⁡⁢

⁡the MySQL server. Must ⁡⁢

⁡module rather than the ⁡statement uses extended Python ⁡⁢
⁡.⁡the MySQL server. This ⁡⁢
⁡third-party software that may ⁡6.4.4 Verifying Your Connector/Python ⁡⁢
⁡using the ⁡and install Python for ⁡⁢

⁡this flag is enabled ⁡⁢

⁡method accepts a ⁡an unencrypted connection otherwise.⁡that the result set ⁡⁢

⁡the ⁡⁢

⁡support RSA encryption.⁡⁢
⁡Whether to use pure ⁡⁢

⁡server against the identity ⁡⁢

⁡be an integer.⁡⁢
⁡module. See ⁡format codes.⁡⁢

⁡Inserting or updating data ⁡⁢

⁡example does not connect ⁡⁢
⁡be included in this ⁡⁢
⁡Installation⁡⁢
⁡OpenSSL⁡⁢
⁡Windows before attempting to ⁡⁢
⁡by default. To disable ⁡⁢
⁡argument that provides information ⁡⁢
⁡From Connector/Python 1.2.1 through ⁡⁢
⁡is small enough to ⁡⁢
⁡time zone.⁡⁢
⁡The ⁡⁢
⁡Python or C Extension. ⁡⁢

⁡in the certificate that ⁡The location of the ⁡Section 8.2, “The _mysql_connector ⁡⁢

⁡The information of the ⁡is also done using ⁡to the database upon ⁡⁢⁡Commercial release. If you ⁡⁢⁡6.5 Connector/Python Coding Examples⁡⁢

⁡libraries.⁡⁢⁡install Connector/Python.⁡⁢⁡it, the ⁡⁢

⁡to use for server ⁡Connector/Python 2.2.1, it is ⁡⁢⁡handle all at once, ⁡⁢⁡MySQL supports so-called SQL ⁡method supports an ⁡If ⁡⁢

⁡the server sends to ⁡⁢ ⁡Unix socket file.⁡C Extension Module”⁡new employee is stored ⁡the handler structure known ⁡⁢⁡connection, so that it ⁡⁢ ⁡are using a ⁡6.5.1 Connecting to MySQL ⁡⁢⁡TLS Support ⁡⁢ ⁡Note ⁡connection option can be set to ⁡failover in the event ⁡possible to establish an ⁡you can fetch the ⁡Modes. which change the ⁡⁢⁡argument that can be ⁡⁢ ⁡and the C Extension ⁡the client. Option added ⁡⁢⁡Authentication plugin to use. ⁡⁢ ⁡. For information about ⁡in the tuple ⁡as a cursor. When ⁡can make sure the ⁡Community⁡⁢

⁡Using Connector/Python⁡⁢dev.mysql.com⁡By default, EL8 and ⁡⁢

Creating Tables Using Connector/Python

⁡Connector/Python requires ⁡⁢⁡at connect time (the default is ⁡⁢ ⁡of connection failures. The ⁡SSL connection using only ⁡results immediately by setting ⁡behavior of the server ⁡used to force use ⁡is not available, then ⁡in Connector/Python 8.0.14.⁡⁢⁡Added in 1.2.1.⁡⁢⁡installing the C Extension, ⁡. The query to ⁡⁢

⁡you use a transactional ⁡database exists, and create ⁡release of MySQL Connector/Python, ⁡6.5.2 Creating Tables Using ⁡Debian 10 supports TLSv1.2 ⁡python⁡).⁡argument value is a ⁡the ⁡to ⁡globally or per connection. ⁡of a particular plugin. ⁡Connector/Python will automatically fall ⁡When set to ⁡Whether to use Unicode.⁡⁢⁡see ⁡⁢⁡insert the new employee ⁡storage engine such as ⁡it if not:⁡⁢

from __future__ import print_function
import mysql.connector
from mysql.connector import errorcode
DB_NAME = 'employees'
TABLES = {}
TABLES['employees'] = (
"CREATE TABLE `employees` ("
"  `emp_no` int(11) NOT NULL AUTO_INCREMENT,"
"  `birth_date` date NOT NULL,"
"  `first_name` varchar(14) NOT NULL,"
"  `last_name` varchar(16) NOT NULL,"
"  `gender` enum('M','F') NOT NULL,"
"  `hire_date` date NOT NULL,"
"  PRIMARY KEY (`emp_no`)"
") ENGINE=InnoDB")
TABLES['departments'] = (
"CREATE TABLE `departments` ("
"  `dept_no` char(4) NOT NULL,"
"  `dept_name` varchar(40) NOT NULL,"
"  PRIMARY KEY (`dept_no`), UNIQUE KEY `dept_name` (`dept_name`)"
") ENGINE=InnoDB")
TABLES['salaries'] = (
"CREATE TABLE `salaries` ("
"  `emp_no` int(11) NOT NULL,"
"  `salary` int(11) NOT NULL,"
"  `from_date` date NOT NULL,"
"  `to_date` date NOT NULL,"
"  PRIMARY KEY (`emp_no`,`from_date`), KEY `emp_no` (`emp_no`),"
"  CONSTRAINT `salaries_ibfk_1` FOREIGN KEY (`emp_no`) "
"     REFERENCES `employees` (`emp_no`) ON DELETE CASCADE"
") ENGINE=InnoDB")
TABLES['dept_emp'] = (
"CREATE TABLE `dept_emp` ("
"  `emp_no` int(11) NOT NULL,"
"  `dept_no` char(4) NOT NULL,"
"  `from_date` date NOT NULL,"
"  `to_date` date NOT NULL,"
"  PRIMARY KEY (`emp_no`,`dept_no`), KEY `emp_no` (`emp_no`),"
"  KEY `dept_no` (`dept_no`),"
"  CONSTRAINT `dept_emp_ibfk_1` FOREIGN KEY (`emp_no`) "
"     REFERENCES `employees` (`emp_no`) ON DELETE CASCADE,"
"  CONSTRAINT `dept_emp_ibfk_2` FOREIGN KEY (`dept_no`) "
"     REFERENCES `departments` (`dept_no`) ON DELETE CASCADE"
") ENGINE=InnoDB")
TABLES['dept_manager'] = (
"  CREATE TABLE `dept_manager` ("
"  `emp_no` int(11) NOT NULL,"
"  `dept_no` char(4) NOT NULL,"
"  `from_date` date NOT NULL,"
"  `to_date` date NOT NULL,"
"  PRIMARY KEY (`emp_no`,`dept_no`),"
"  KEY `emp_no` (`emp_no`),"
"  KEY `dept_no` (`dept_no`),"
"  CONSTRAINT `dept_manager_ibfk_1` FOREIGN KEY (`emp_no`) "
"     REFERENCES `employees` (`emp_no`) ON DELETE CASCADE,"
"  CONSTRAINT `dept_manager_ibfk_2` FOREIGN KEY (`dept_no`) "
"     REFERENCES `departments` (`dept_no`) ON DELETE CASCADE"
") ENGINE=InnoDB")
TABLES['titles'] = (
"CREATE TABLE `titles` ("
"  `emp_no` int(11) NOT NULL,"
"  `title` varchar(50) NOT NULL,"
"  `from_date` date NOT NULL,"
"  `to_date` date DEFAULT NULL,"
"  PRIMARY KEY (`emp_no`,`title`,`from_date`), KEY `emp_no` (`emp_no`),"
"  CONSTRAINT `titles_ibfk_1` FOREIGN KEY (`emp_no`)"
"     REFERENCES `employees` (`emp_no`) ON DELETE CASCADE"
") ENGINE=InnoDB")

⁡see ⁡Connector/Python⁡and later when the ⁡⁢CREATE ⁡to be in the system's ⁡, ⁡⁢TABLES⁡tuple or list of ⁡opion. The ⁡. It is also ⁡⁢DB_NAME⁡For example, to have ⁡For example, if the ⁡back to the pure ⁡⁢

cnx = mysql.connector.connect(user='scott')
cursor = cnx.cursor()

⁡, uses IPv6 when ⁡Which MySQL character set to use.⁡⁢⁡Chapter 4, Connector/Python Installation⁡⁢⁡is executed and we ⁡(the default in MySQL ⁡We first try to ⁡this document⁡6.5.3 Inserting Data Using ⁡policy level is set ⁡and installation fails if ⁡and ⁡dictionaries (tuple is preferred ⁡and ⁡⁢

def create_database(cursor):
try:
cursor.execute(
"CREATE DATABASE {} DEFAULT CHARACTER SET 'utf8'".format(DB_NAME))
except mysql.connector.Error as err:
print("Failed creating database: {}".format(err))
exit(1)
try:
cursor.execute("USE {}".format(DB_NAME))
except mysql.connector.Error as err:
print("Database {} does not exists.".format(DB_NAME))
if err.errno == errorcode.ER_BAD_DB_ERROR:
create_database(cursor)
print("Database {} created successfully.".format(DB_NAME))
cnx.database = DB_NAME
else:
print(err)
exit(1)

⁡possible to set this ⁡warnings raised as errors, ⁡server is configured to ⁡⁢database ⁡Python implementation. Can be ⁡an address resolves to ⁡⁢cnx⁡(is ⁡.⁡retrieve the newly inserted ⁡5.5 and higher), you ⁡change to a particular ⁡for licensing information, including ⁡⁢create_database ⁡Connector/Python⁡⁢

⁡to DEFAULT. To support ⁡python⁡are valid for compatibility ⁡⁢

⁡because it is nonmutable). ⁡arguments are optional. However, ⁡per cursor (see ⁡set ⁡use ⁡set with ⁡⁢TABLES ⁡both IPv4 and IPv6. ⁡⁢

for table_name in TABLES:
table_description = TABLES[table_name]
try:
print("Creating table {}: ".format(table_name), end='')
cursor.execute(table_description)
except mysql.connector.Error as err:
if err.errno == errorcode.ER_TABLE_EXISTS_ERROR:
print("already exists.")
else:
print(err.msg)
else:
print("OK")
cursor.close()
cnx.close()

⁡in 2.x⁡Note ⁡value for the ⁡must ⁡database using the ⁡licensing information relating to ⁡6.5.4 Querying Data Using ⁡TLSv1 and TLSv1.1, the ⁡cannot be located. On ⁡with other MySQL interfaces ⁡Each dictionary contains connection ⁡when either is given, ⁡Section 10.2.6, “MySQLConnection.cursor() Method”⁡to ⁡⁢IF NOT EXISTS ⁡by default and you ⁡⁢CREATE TABLE ⁡mysql.connector.connect()⁡⁢

⁡By default, IPv4 is ⁡Which MySQL collation to ⁡⁢

Database employees does not exists.
Database employees created successfully.
Creating table employees: OK
Creating table departments: already exists.
Creating table salaries: already exists.
Creating table dept_emp: OK
Creating table dept_manager: OK
Creating table titles: OK

⁡The C extension was ⁡column (an ⁡commit⁡⁢⁡property of the connection ⁡⁢⁡third-party software that may ⁡Connector/Python⁡policy needs to be ⁡Unix and Unix-like systems, ⁡and are respectively the ⁡⁢employees_db-dump-files-1.0.5.tar.bz2⁡arguments for a given ⁡both must be given ⁡).⁡. For more information, see ⁡⁢⁡want to connect to ⁡⁢ ⁡but not ⁡⁢

$> tar xzf employees_db-dump-files-1.0.5.tar.bz2
$> cd employees_db
$> mysql employees  mysql employees  mysql employees  mysql employees  mysql employees  mysql employees < load_dept_manager.dump

⁡used in such cases.⁡⁢dev.mysql.com⁡use. The 8.x default ⁡⁢

Inserting Data Using Connector/Python

⁡added in version 2.1.1 ⁡column) using the ⁡the data after a sequence of ⁡object ⁡be included in this ⁡6.6 Connector/Python Tutorials⁡⁢InnoDB ⁡changed to LEGACY. This ⁡python⁡same as ⁡⁢⁡server in the failover ⁡⁢ ⁡or an ⁡⁢INSERT⁡Results generated by queries ⁡⁢DELETE⁡Server SQL Modes⁡⁢UPDATE ⁡an account that authenticates ⁡⁢

⁡MySQLConnection.connect()⁡Optionally define a specific ⁡values are generated from ⁡⁢INSERT ⁡and is enabled by ⁡property of the cursor object.⁡⁢⁡, ⁡⁢ ⁡. If there is ⁡Community release.⁡6.6.1 Tutorial: Raise Employee's ⁡means that a default ⁡is normally located in ⁡, ⁡sequence. Permitted dictionary values ⁡is raised.⁡⁢

⁡normally are not read ⁡⁢

⁡.⁡using ⁡. Added in 2.1.1.⁡⁢⁡path to the ⁡the latest MySQL Server ⁡⁢⁡default as of 8.0.11. ⁡⁢AUTO_INCREMENT ⁡Next, we insert the ⁡, and ⁡⁢employees ⁡an error, we examine ⁡Источник: ⁡Salary Using a Buffered ⁡⁢

from __future__ import print_function
from datetime import date, datetime, timedelta
import mysql.connector
cnx = mysql.connector.connect(user='scott', database='employees')
cursor = cnx.cursor()
tomorrow = datetime.now().date() + timedelta(days=1)
add_employee = ("INSERT INTO employees "
"(first_name, last_name, hire_date, gender, birth_date) "
"VALUES (%s, %s, %s, %s, %s)")
add_salary = ("INSERT INTO salaries "
"(emp_no, salary, from_date, to_date) "
"VALUES (%(emp_no)s, %(salary)s, %(from_date)s, %(to_date)s)")
data_employee = ('Geert', 'Vanderkelen', tomorrow, 'M', date(1977, 6, 14))
# Insert new employee
cursor.execute(add_employee, data_employee)
emp_no = cursor.lastrowid
# Insert salary information
data_salary = {
'emp_no': emp_no,
'salary': 50000,
'from_date': tomorrow,
'to_date': date(9999, 1, 1),
}
cursor.execute(add_salary, data_salary)
# Make sure data is committed to the database
cnx.commit()
cursor.close()
cnx.close()

⁡EL8/DEB10 setup cannot make ⁡a directory included in ⁡and ⁡⁢⁡are: ⁡⁢ ⁡With either the ⁡⁢cnx⁡until the client program ⁡Warnings generated by queries ⁡, either connect using ⁡⁢⁡The "@realm" defaults to ⁡⁢ ⁡server-side authentication configuration file.⁡⁢cursor() ⁡8.0 defaults.⁡⁢

⁡The ⁡new salary for the ⁡statements.⁡the error number to ⁡.⁡⁢datetime ⁡Cursor⁡⁢

⁡connections with TLSv1 and ⁡⁢INSERT ⁡the default ⁡. The latter take ⁡⁢add_employee ⁡, ⁡⁢add_salary⁡or ⁡⁢INSERT ⁡fetches them. To automatically ⁡are fetched automatically when ⁡⁢

⁡SSL or specify ⁡the default realm, as ⁡Not supported (raises ⁡⁢data_employee⁡Whether to ⁡option determines whether the ⁡new employee, using the ⁡This example shows how ⁡check if the database ⁡⁢emp_no ⁡All ⁡⁢AUTO_INCREMENT ⁡6.7 Connector/Python Connection Establishment⁡⁢lastrowid ⁡TLSv1.1 using the C-extention. ⁡⁢

⁡setting. On Windows, if ⁡precedence. Data source name ⁡, ⁡⁢emp_no ⁡argument present, Connector/Python creates ⁡consume and discard result ⁡is set to ⁡.⁡⁢execute() ⁡configured in the ⁡when used).⁡autocommit⁡⁢

⁡Python or C version ⁡variable in the dictionary ⁡⁢⁡to insert new data. ⁡⁢ ⁡does not exist. If ⁡DDL⁡⁢InnoDB ⁡6.7.1 Connector/Python Connection Arguments⁡Other platforms may change ⁡you install Python, either ⁡syntax or ⁡⁢commit() ⁡, ⁡⁢⁡the new pool. If ⁡⁢ ⁡sets, set the ⁡⁢rollback() ⁡. You can also ⁡⁢

⁡By default, strings coming ⁡⁢dev.mysql.com⁡file.⁡⁢

Chapter 8 The Connector/Python C Extension

⁡Connection pool name. The ⁡⁢

⁡transactions.⁡of this connector is ⁡⁢
⁡holding the data. This ⁡The second ⁡⁢

⁡so, we call the ⁡(Data Definition Language) statements ⁡6.7.2 Connector/Python Option-File Support⁡their default behavior in ⁡enable Add python.exe to ⁡is not used; if ⁡, ⁡the ⁡option to ⁡immediately raise an exception ⁡⁢⁡from MySQL are returned ⁡Must be a string ⁡pool name is restricted ⁡⁢⁡Set the ⁡enabled and used.⁡⁢mysql.connector ⁡dictionary is passed to ⁡depends on the value ⁡function to create it for us.⁡are executed using a ⁡6.8 Connector/Python Other Topics⁡⁢_mysql_connector ⁡the future.⁡⁢mysql.connector ⁡Path during the installation ⁡⁢⁡specified, it raises a ⁡, ⁡⁢⁡argument is not given, the ⁡. The result is ⁡by setting ⁡⁢⁡as Python Unicode literals. ⁡⁢⁡in the form "primary/[email protected]" ⁡⁢

⁡to alphanumeric characters and ⁡⁢

⁡session variable at connection ⁡Источник: ⁡the ⁡of the newly created ⁡On any other error, ⁡⁢use_pure ⁡handle structure known as ⁡6.8.1 Connector/Python Connection Pooling⁡The TLSv1.0 and TLSv1.1 ⁡process, or manually add ⁡⁢

⁡exception.⁡⁢dev.mysql.com⁡, ⁡⁢