Методы объекта Cursor модуля MySQLdb в Python.

Синтаксис:
import MySQLdb
db=MySQLdb.connect(...)
# создание объекта курсора
cursor = db.cursor([cursorclass])
Параметры:
  • cursorclass — необязательный аргумент, класс используемого курсора. По умолчанию используется стандартный класс cursors.Cursor (результат запроса будет возвращаться в виде списка кортежей). Может принимать встроенный класс cursors.DictCursor (результат запроса будет возвращаться в виде словаря, значения ключей — названия столбцов таблицы).
Возвращаемое значение:
  • объект Cursor.
Описание:

Объект Cursor представляет собой курсор базы данных, который создается для объекта соединения и используется для управления контекстом операции выборки. Курсоры, созданные из одного и того же соединения, не изолированы, т. е. любые изменения, внесенные в базу данных курсором, немедленно видны другим курсорам. Курсоры, созданные из разных соединений, могут или не могут быть изолированы, в зависимости от того, как реализована поддержка транзакций.

Атрибуты и методы объекта

Cursor.
  • Cursor.arraysize количество строк, которые нужно извлечь за один раз,
  • Cursor.lastrowid возвращает id последней измененной строки в таблице,
  • Cursor.rowcount возвращает количество строк, созданных последним запросом,
  • Cursor.rownumber должен возвращать текущий индекс курсора в результирующем наборе,
  • Cursor.callproc() вызывает хранимую процедуру,
  • Cursor.close() немедленно закрывает курсор,
  • Cursor.info() возвращает некоторую информацию о последнем запросе,
  • Cursor.execute() подготавливает и выполняет запрос к базе данных,
  • Cursor.executemany() выполняет множественные запросы к базе данных,
  • Cursor. fetchone() получает одну (первую) строку из результатов запроса,
  • Cursor.fetchmany() получает следующий набор строк размером size,
  • Cursor.fetchall() получает все или оставшиеся строки результата запроса,
  • Cursor.nextset() перемещает курсор к следующему набору результатов,
  • Cursor.next() возвращает следующую строку результата запроса,
  • Cursor.__iter__() обеспечивает совместимость с протоколом итерации,
  • Cursor.scroll() прокручивает курсор в наборе результатов до новой позиции,
  • Пример работы с курсором.
Cursor.arraysize:

Свойство Cursor.arraysize для чтения/записи указывает количество строк, которые нужно извлечь за один раз с помощью Cursor.fetchmany(). По умолчанию равен 1, что означает извлечение одной строки за раз.

Cursor.lastrowid:

Свойство Cursor. lastrowid только для чтения, возвращает id последней измененной строки в таблице (некоторые версии MySQL возвращают идентификатор строки только при выполнении одной операции INSERT). Если операция не может установить идентификатор строки id или если таблица базы данных не имеет столбца id, то этот атрибут возвращает значение None.

Семантика Cursor.lastrowid не определена, если последний выполненный запрос изменил более одной строки, например, при использовании INSERT с Cursor.executemany().

query = "INSERT INTO table (field1, field2, field3) VALUES (%s, %s, %s)"
cursor.execute(query, (param1, param2, param3,))
# получаем `id` вставленной записи
last_id = cursor.lastrowid)
Cursor.rowcount:

Свойство Cursor.rowcount только для чтения, возвращает количество строк, созданных последним Cursor.execute() (для операторов SQL, таких как SELECT), или затронутых (для операторов SQL, таких как UPDATE или INSERT).

Свойство Cursor.rowcount равен -1, если над курсором не было выполнено Cursor.execute() или интерфейс не может определить количество строк последней операции.

Примечание. Будущие версии спецификации Python DB API могут переопределить последний случай, чтобы объект возвращал

None вместо -1.

cursor.execute("SELECT spam, eggs, sausage FROM breakfast")
if cursor.rowcount > 0: # если есть результаты
    # то проходимся по списку кортежей с результатами запроса
    for row in cursor.fetchall():
        # извлекаем данные из кортежа с результатами
        spam = row[0]
        eggs = row[1]
        sausage = row[2]
Cursor.rownumber:

Свойство Cursor.rownumber только для чтения, должен возвращать текущий индекс курсора в результирующем наборе, отсчитываемый от 0, или None, если индекс не может быть определен.

Индекс можно рассматривать как индекс курсора в последовательности (результирующем наборе). Следующая операция выборки извлечет строку с индексом Cursor.rownumber в этой последовательности.

Cursor.callproc(procname [, parameters]):

Метод Cursor.callproc() вызывает хранимую процедуру procname с последовательностью аргументов parameters. Возвращает исходные аргументы. Поддержка хранимых процедур работает только с MySQL версии 5.0 и новее.

Примечание о совместимости: PEP-249 указывает, что при наличии параметров OUT или INOUT должны быть возвращены измененные значения. Это не всегда возможно с MySQL. Аргументы хранимой процедуры должны передаваться как переменные сервера и могут быть возвращены только с помощью оператора SELECT. Так как хранимая процедура может возвращать ноль или более наборов результатов, модуль MySQLdb не может определить, есть ли наборы результатов для выборки, прежде чем будут доступны измененные параметры.

Параметры хранятся на сервере как @_*procname*_*n*, где n — позиция аргумента. То есть, если используется cursor.callproc("foo", (a, b, c)), то параметры будут доступны с помощью запроса SELECT @_foo_0 as foo_0, @_foo_1 as foo_1 и @_foo_2 as foo_2.

Примечание о совместимости: Похоже, что выполнение инструкции SQL CALL создает пустой результирующий набор, который появляется после любых результирующих наборов, которые могут быть сгенерированы хранимой процедурой. Таким образом, всегда нужно будет использовать метод Cursor.nextset() для перебора результатов.

Cursor.close():

Метод Cursor.close() немедленно закрывает курсор. Будущие операции будут вызывать исключение `MySQLdb.ProgrammingError’. Если используются курсоры на стороне сервера, то очень важно закрыть курсор, когда он больше не нужен, и особенно перед созданием нового.

Модуль не представляет менеджер контекста для закрытия открытого курсора. Для этих целей можно использовать функцию стандартной библиотеки contextlib.closing().

from MySQLdb import connect
from contextlib import closing
# поднимаем соединение с базой данных
db = connect('user': 'user', 'password': 'password', 'db': 'test_db')
# открываем db.cursor() в менеджере контекста
with closing(db.cursor()) as cursor:
    cursor.execute("SELECT spam, eggs, sausage FROM breakfast")
    ...
    ...
Cursor.info():

Метод Cursor.info() возвращает некоторую информацию о последнем запросе. Обычно этот метод не используется. Если есть какие-либо предупреждения MySQL, то это должно привести к выдаче предупреждения через MySQLdb.Warning и/или предупреждения Python. Также, по умолчанию предупреждение приводит к появлению сообщения на консоли. Можно отфильтровать их или вызвать предупреждение, которое будет выдано как исключение.

Cursor.execute(operation [, parameters]):

Метод Cursor. execute() подготавливает и выполняет operation к базе данных (запрос или SQL-команду). Аргумент parameters могут быть предоставлены в виде кортежа или сопоставления и будут привязаны к переменным в operation. Переменные указываются в нотации, специфичной для базы данных (подробности смотрите в описании аргумента paramstyle функции MySQLdb.connect()).

Ссылка на операцию operation останется за курсором. Если снова передается тот же объект операции, то курсор может оптимизировать свое поведение. Это наиболее эффективно для алгоритмов, в которых используется одна и та же операция, но к ней привязаны разные

parameters (много раз).

Возвращает список объектов, представляющие выборку строк таблицы базы данных в зависимости от используемого класса курсора или None, если запрос вернул пустую выборку.

max_price=5
cursor.execute("""SELECT spam, eggs, sausage FROM breakfast
          WHERE price < %s""", (max_price,))
Cursor. executemany(operation, seq_of_parameters):

Метод Cursor.executemany() подготавливает operation (множественный запрос) к базы данных (запрос или SQL-команду), а затем выполняет его для всех значений последовательности параметров или сопоставлений, найденных в последовательности

seq_of_parameters.

Использование этого метода для операции, которая создает один или несколько результирующих наборов, представляет собой неопределенное поведение.

К этому методу применимы те же комментарии, что и для Cursor.execute().

cursor.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 )
      ] )
Cursor.fetchone():

Метод Cursor.fetchone() получает одну (первую) строку набора результатов запроса, возвращая одну последовательность, или

None, если больше нет доступных данных.

Если предыдущий вызов Cursor.execute() не привел к набору результатов или вызов еще не был выполнен, то возникает исключение MySQLdb.Error (или его подкласс).

max_price=5
cursor.execute("""SELECT spam, eggs, sausage FROM breakfast
          WHERE price < %s""", (max_price,))
# получаем первый кортеж из списка 
# кортежей с результатами запроса
row = cursor.fetchone()
# извлекаем результаты из кортежа
spam = row[0]
eggs = row[1]
sausage = row[2]
Cursor.fetchmany([size=cursor.arraysize]):

Метод Cursor.fetchmany() получает следующий набор строк результата запроса, возвращая список кортежей. Когда больше нет доступных строк, то возвращается пустая последовательность.

Количество строк для выборки за вызов определяется аргументом size. Если он не указан, то размер массива курсора определяет количество извлекаемых строк. Метод попытаться получить столько строк, сколько указано аргументом size. Если это невозможно из-за того, что указанное количество строк недоступно, то может быть возвращено меньшее количество строк.

Если предыдущий вызов Cursor.execute() не привел к набору результатов или вызов еще не был выполнен, то возникает исключение MySQLdb.Error (или его подкласс).

Обратите внимание, что с аргументом size связаны соображения производительности. Для оптимальной производительности, лучше всего использовать свойство Cursor.arraysize. Если используется аргумент size, то для него лучше сохранять одно и то же значение от одного вызова Cursor.fetchmany() до следующего.

Cursor.fetchall():

Метод Cursor.fetchall()

получает все (оставшиеся) строки результата запроса, возвращая их в виде список кортежей.

Обратите внимание, что свойство Cursor.arraysize может повлиять на производительность этой операции.

Если предыдущий вызов Cursor. execute() не привел к набору результатов или вызов еще не был выполнен, то возникает исключение MySQLdb.Error (или его подкласс).

cursor.execute("SELECT spam, eggs, sausage FROM breakfast")
# проходимся по списку кортежей с результатами запроса
for row in cursor.fetchall():
    # извлекаем данные из кортежа с результатами
    spam = row[0]
    eggs = row[1]
    sausage = row[2]
Cursor.nextset():

Метод Cursor.nextset() перемещает курсор к следующему набору результатов, отбрасывая оставшиеся строки в текущем наборе результатов. Если дополнительных наборов результатов нет, то возвращается None, в противном случае он возвращает истинное значение.

Обратите внимание, что MySQL не поддерживает несколько наборов результатов до версии 4.1.

Если предыдущий вызов Cursor.execute() не привел к набору результатов или вызов еще не был выполнен, то возникает исключение MySQLdb. Error (или его подкласс).

Cursor.next():

Метод Cursor.next() возвращает следующую строку из выполняемого в данный момент оператора SQL, используя ту же семантику, что и Cursor.fetchone().

Когда набор результатов исчерпан, появляется исключение StopIteration.

Cursor.__iter__():

Метод Cursor.__iter__() возвращает self, чтобы сделать курсоры совместимыми с протоколом итерации.

Cursor.scroll(value [, mode=’relative’ ]):

Метод Cursor.scroll() прокручивает курсор в наборе результатов до новой позиции value в соответствии с режимом mode.Если режим mode='relative' (по умолчанию), то значение берется как смещение к текущей позиции в результирующем наборе, если установлено mode='absolute', то значение указывает абсолютную целевую позицию.

Если операция прокрутки выходит за пределы набора результатов, то возникает исключение IndexError. В этом случае позиция курсора остается неопределенной.

Пример работы с курсором.

Модуль MySQLdb не имеет встроенных менеджеров контекста для закрытия курсора. Для удобной очистки оперативной памяти от результатов объекта курсора лучше использовать функцию стандартной библиотеки contextlib.closing.

from MySQLdb import connect, cursors, Error
from contextlib import closing
# конфигурация соединения с базой данных
MYSQLCONF = {
    'host': 'localhost', # хост базы данных
    'user': '******', # имя пользователя базы данных
    'password': '******', # пароль пользователя базы данных
    'db': 'test_db', # имя базы данных
    'charset': 'utf8', # используемая кодировка базы данных
    'autocommit': True, # автоматический cursor.commit()
    # извлекаемые строки из БД принимают вид словаря
    'cursorclass': cursors.DictCursor
}
# поднимаем соединение с базой данных
db = connect(**MYSQLCONF)
# открываем курсор при помощи `contextlib.closing` 
with closing(db.
 
 cursor()) as cursor:
    # создаем строку с запросом с использованием подстановок
    query = """INSERT INTO table (field1, field2, field3) 
               VALUES (%s, %s, %s)"""
    try:
        # выполняем запрос с необходимыми параметрами
        cursor.execute(query, (param1, param2, param3,))
        # здесь должна быть строка с командой `cursor.commit()`
        # но ее нет, т.к. соединение настроено с 'autocommit': True
    except Error as err:
        # Класс `Error` выводит ошибки, связанные с работой базы данных  
        # и не обязательно находящихся под контролем программиста
        print(err)
    # если нужно, то можно получить `id` вставленной записи
    print('lastrowid =>', cursor.lastrowid)
# далее какой-то код программы
...

получение доступа с использованием модуля mysql.connector на примерах

В этом разделе руководства мы обсудим действия по подключению приложения Python к базе данных MySQL.

Чтобы подключить приложение Python к нашей базе данных, нужно выполните следующие шаги:

  1. Импортируйте модуль mysql. connector.
  2. Создайте объект подключения.
  3. Создайте объект cursor.
  4. Выполните запрос.

Создание соединения

Для создания соединения между базой данных MySQL и приложением Python используется метод connect() модуля mysql.connector.

Передайте данные базы данных, такие как HostName, имя пользователя и пароль базы данных, в вызове метода. Метод возвращает объект подключения.

Синтаксис использования connect() приведен ниже.

 
Connection-Object= mysql.connector.connect(host =  , user =  , passwd =  )

Рассмотрим следующий пример:

 
import mysql.connector 
 
#Create the connection object  
myconn = mysql.connector.connect(host = "localhost", user = "root",passwd = "google") 
 
#printing the connection object  
print(myconn)

Выход:

Здесь мы должны заметить, что можно указать имя базы данных в методе connect(), если мы хотим подключиться к определенной базе данных.

Пример:

 
import mysql.connector 
 
#Create the connection object  
myconn = mysql.connector.connect(host = "localhost", user = "root",passwd = "google", database = "mydb") 
 
#printing the connection object  
print(myconn)

Выход:

Объект cursor

Объект cursor можно определить как обусловленную абстракцию в Python DB-API 2.0. Это позволяет нам иметь несколько отдельных рабочих сред через одно и то же соединение с базой данных. Мы можем создать объект cursor, вызвав функцию-курсор для объекта соединения. Объект cursor – важный аспект выполнения запросов к базам данных.

Синтаксис для создания данного объекта приведен ниже:

 
  = conn.cursor()

Пример:

 
import mysql.connector 
#Create the connection object  
myconn = mysql. connector.connect(host = "localhost", user = "root",passwd = "google", database = "mydb") 
 
#printing the connection object  
print(myconn)  
 
#creating the cursor object 
cur = myconn.cursor() 
 
print(cur)

Выход:

  
MySQLCursor:(Nothing executed yet)

Михаил Русаков

Изучаю Python вместе с вами, читаю, собираю и записываю информацию опытных программистов.

Еще для изучения:

Пагинация курсора — MySQL для разработчиков — PlanetScale

Когда дело доходит до нумерации страниц, разработчики часто обращаются либо к ограничению смещения, либо к нумерации страниц на основе курсора. Хотя ограничение смещения может быть простым в реализации, у него есть несколько недостатков, которые делают его менее чем идеальным для определенных ситуаций. Пагинация на основе курсора направлена ​​на устранение некоторых из этих недостатков, но имеет свой собственный набор проблем.

Прежде чем углубляться в разбиение на страницы на основе курсоров, важно отметить, что мы не говорим о курсорах базы данных. Хотя курсоры базы данных интересны, мы здесь их не обсуждаем. Разбиение на страницы на основе курсора ссылается на метод разбиения на страницы, который отличается от предела смещения.

В этом посте мы рассмотрим преимущества и недостатки разбиения на страницы с помощью курсора и предоставим обзор его реализации.

Разбиение на страницы с помощью курсора позволяет эффективно извлекать большие наборы данных из базы данных, разбивая их на более мелкие страницы. Этот метод особенно полезен при работе с большими наборами данных, когда загрузка всех данных сразу была бы нецелесообразной или медленной.

При реализации разбиения на страницы с помощью курсора разработчикам необходимо отслеживать последнюю запись, которую видел пользователь. Для этого во внешний интерфейс отправляется «курсор» с каждой страницей результатов. Затем курсор возвращается в базу данных в виде маркера, указывающего, где должна начинаться следующая страница результатов.

Преимущества

Одним из преимуществ разбиения на страницы с помощью курсора является его устойчивость к смещению строк. Например, если запись удалена, следующая запись, которая последовала бы за ней, по-прежнему будет отображаться, поскольку запрос обрабатывается от курсора, а не от определенного смещения.

Еще одно преимущество разбиения на страницы с помощью курсора заключается в том, что оно может хорошо работать с бесконечной прокруткой — тенденцией дизайна, которая загружает содержимое по мере прокрутки пользователем.

Недостатки

Одним из основных недостатков разбивки на страницы с помощью курсора является невозможность прямого обращения к конкретной странице. Например, если требуется перейти непосредственно на пятую страницу, это невозможно сделать, поскольку сами страницы явно не пронумерованы.

Кроме того, нумерацию страниц на основе курсора может быть сложнее реализовать, чем нумерацию страниц с ограничением смещения. Необходимо больше подумать о структуре курсора и о том, какие критерии следует использовать для его определения.

Разбиение на страницы на основе курсора требует сохранения состояния и интеллектуальной реконструкции этого состояния по требованию. Для этого разработчикам необходимо:

  1. Упорядочить результаты запроса для текущей страницы, используя уникальный идентификатор, такой как идентификатор или комбинацию нескольких полей.
  2. Вычислить «курсор» на основе последней записи.
  3. Отправить результаты и курсор обратно пользователю.
  4. При следующем запросе извлеките курсор, деконструируйте его состояние и создайте запрос.

Хотя разбивка на страницы с помощью курсора не может быть идеальным решением для всех ситуаций, это мощный инструмент для управления большими наборами данных, который может решить многие проблемы, с которыми не может справиться разбивка на страницы с ограничением. При сравнении ограничения смещения и разбивки на страницы на основе курсора учитывайте конкретные требования вашего проекта и ожидания пользователей. Вдумчиво вы можете выбрать метод разбиения на страницы, который лучше всего соответствует вашим конкретным потребностям.

Python MySQL Select From Table [Полное руководство]

В этой статье показано, как выбирать строки таблицы MySQL в Python .

Вы изучите следующие операции MySQL SELECT из Python, используя модуль «MySQL Connector Python».

  • Выполните запрос SELECT и обработайте набор результатов, возвращенный запросом в Python.
  • Используйте переменные Python в предложении where запроса SELECT для передачи динамических значений.
  • Использовать fetchall() , fetchmany() и fetchone() методы класса курсора для выборки всех или ограниченных строк из таблицы.

Оглавление

  • Предварительные требования
  • Шаги для выборки строк из таблицы базы данных MySQL
  • Использование переменных Python в качестве параметров в MySQL Select Query
  • Выбор ограниченного количества строк из таблицы MySQL с помощью fetchmany и fetchone
    • Пример получения меньшего количества строки из таблицы MySQL с использованием курсора fetchmany
    • Извлечь одну строку из таблицы MySQL, используя fetchone курсора
  • Python Извлечь строку MySQL, используя имена столбцов
  • Выбрать значение столбца MySQL в переменную Python
  • Следующие шаги:

Предварительные условия 900 63

Прежде чем двигаться дальше, сделайте убедитесь, что у вас есть следующее: –

  • Имя пользователя и пароль для подключения к MySQL
  • Имя таблицы MySQL, из которой вы хотите выбрать данные.

Для этого урока я использую таблицу «Ноутбук», присутствующую на моем сервере MySQL.

Если на вашем сервере MySQL нет таблицы, вы можете обратиться к нашей статье, чтобы создать таблицу MySQL из Python.

Вы также можете загрузить файл запроса SQL, который содержит запросы SQL для создания таблицы и данные, чтобы вы могли использовать эту таблицу для операций INSERT.

Таблица MySQL для ноутбука с данными

Действия по извлечению строк из таблицы базы данных MySQL

Выполните следующие действия: –

Как выбрать из таблицы MySQL с помощью Python

  1. Подключиться к MySQL из Python

    См. Соединение с базой данных Python MySQL для подключения к базе данных MySQL из Python с помощью модуля MySQL Connector

  2. Определение запроса SQL SELECT

    Затем подготовьте запрос SQL SELECT для выборки строк из таблицы. Вы можете выбрать все или ограниченные строки в зависимости от ваших требований. Если используется условие where, то оно определяет количество извлекаемых строк.
    Например, SELECT col1, col2,… colnN FROM MySQL_table WHERE id = 10; . Это вернет строку номер 10.

  3. Получить объект курсора из Connection

    Затем используйте метод connection.cursor() для создания объекта курсора. Этот метод создает новый объект MySQLCursor .

  4. Выполнить запрос SELECT, используя метод execute()

    Выполнить запрос select, используя метод cursor.execute() .

  5. Извлечь все строки из результата

    После успешного выполнения операции Select используйте fetchall() метод объекта курсора для получения всех строк из результата запроса. он возвращает список строк.

  6. Итерация каждой строки

    Итерация списка строк с использованием цикла for и доступ к каждой строке по отдельности (Доступ к данным столбца каждой строки с использованием имени столбца или номера индекса. )

  7. Закрыть объект курсора и объект подключения к базе данных

    используйте метод cursor.clsoe() и connection.clsoe() для закрытия открытых соединений после завершения вашей работы.

Выбор Python из таблицы MySQL

Пример

В этом примере мы извлекаем все строки из таблицы Laptop и копируем их в переменные Python, чтобы использовать их в нашей программе.

 импорт mysql.connector
пытаться:
    соединение = mysql.connector.connect(host='localhost',
                                         база данных = 'электроника',
                                         пользователь = 'пинатив',
                                         пароль='pynative@#29')
    sql_select_Query = "выбрать * с ноутбука"
    курсор = соединение.курсор()
    курсор.execute(sql_select_Query)
    # получить все записи
    записи = курсор.fetchall()
    print("Общее количество строк в таблице: ", cursor.rowcount)
    print("\nПечать каждой строки")
    для строки в записях:
        печать ("Идентификатор = ", строка [0], )
        печать("Имя = ", строка[1])
        print("Цена = ", строка[2])
        print("Дата покупки = ", строка[3], "\n")
кроме mysql. connector.Error как e:
    print("Ошибка чтения данных из таблицы MySQL", e)
окончательно:
    если соединение.is_connected():
        соединение.закрыть()
        курсор.закрыть()
        print("Соединение с MySQL закрыто")

Выход : –

 Общее количество строк в ноутбуке: 7
Печать каждой записи ноутбука
Идентификатор = 1
Имя = Lenovo ThinkPad P71
Цена = 6459,0
Дата покупки = 2019-08-14
идентификатор = 2
Имя = Зона 51M
Цена = 6999,0
Дата покупки = 2019-04-14
Идентификатор = 3
Имя = Макбук Про
Цена = 2499,0
Дата покупки = 20.06.2019
Идентификатор = 4
Название = HP Pavilion Power
Цена = 1999,0
Дата покупки = 2019-01-11
Идентификатор = 5
Имя = MSI WS75 9TL-496
Цена = 5799,0
Дата покупки = 2019-02-27
Идентификатор = 6
Имя = Microsoft Поверхность
Цена = 2330,0
Дата покупки = 2019 г.-07-23
Идентификатор = 7
Имя = Acer Хищник Тритон
Цена = 2435,0
Дата покупки = 2019-08-15
Соединение с MySQL закрыто

Примечание : используйте следующие методы для получения данных, возвращаемых cursor. execute()

  • cursor.fetchall() для получения всех строк
  • cursor.fetchone() , чтобы получить один row
  • cursor.fetchmany(SIZE) для выборки ограниченных строк

Использовать переменные Python в качестве параметров в MySQL Select Query

Нам часто нужно передать переменные в запрос выбора SQL в предложении where, чтобы проверить некоторые условия. Допустим, приложение хочет получить цену ноутбука, предоставляя любой идентификатор ноутбука во время выполнения. Чтобы справиться с таким требованием, нам нужно использовать параметризованный запрос.

Параметризованный запрос — это запрос, в котором заполнители ( %s ) используются для параметров и значений параметров, предоставляемых во время выполнения.

 cursor.execute("ВЫБЕРИТЕ цену ИЗ ноутбука, ГДЕ id = "ID из приложения")

Пример 

 импорт mysql. connector
защита get_laptop_detail (идентификатор):
    пытаться:
        соединение = mysql.connector.connect(host='localhost',
                                             база данных = 'электроника',
                                             пользователь = 'пинатив',
                                             пароль='pynative@#29')
        курсор = соединение.курсор()
        sql_select_query = """выберите * с ноутбука, где id = %s"""
        # установить переменную в запросе
        курсор.execute (sql_select_query, (идентификатор,))
        # получить результат
        запись = курсор.fetchall()
        для строки в записи:
            печать ("Идентификатор = ", строка [0], )
            печать("Имя = ", строка[1])
            print("Дата присоединения = ", строка[2])
            print("Зарплата = ", строка[3], "\n")
    кроме mysql.connector.Error как ошибка:
        print("Не удалось получить запись из таблицы MySQL: {}".format(ошибка))
    окончательно:
        если соединение. is_connected():
            курсор.закрыть()
            соединение.закрыть()
            print("Соединение с MySQL закрыто")
get_laptop_detail(1)
get_laptop_detail(2)

Выход:

 Идентификатор = 1
Имя = Lenovo ThinkPad P71
Дата присоединения = 6459,0
Зарплата = 2019-08-14
соединение закрыто
идентификатор = 2
Имя = Зона 51M
Дата присоединения = 6999,0
Зарплата = 2019-04-14
Соединение с MySQL закрыто

Выберите ограниченное количество строк из таблицы MySQL с помощью fetchmany и fetchone

В некоторых случаях выбор всех строк из таблицы занимает много времени, если таблица содержит тысячи строк.

Если мы выбираем все строки, нам нужно больше места и времени обработки. Поэтому важно использовать fetchmany() метод класса курсора для выборки меньшего количества строк .

Синтаксис методов курсора fetchmany() 

 rows = cursor.fetchmany(size=row_size)

Методы fetchmany() курсора возвращают количество строк, указанное аргументом size , по умолчанию значение аргумента size равно один. Например, если указанный размер равен 5, возвращается пять строк.

Примечание : Если таблица содержит строку меньше указанного размера, возвращается меньше строк.

Синтаксис fetchone() 

 row = cursor.fetchone()

Этот метод выбирает следующий набор строк результата запроса и возвращает список кортежей. Если больше нет доступных строк, он возвращает пустой список.

Этот метод возвращает одну запись или None, если больше нет доступных строк.

Метод fetchone() внутренне используется fetchall() и fetchmany() для выборки строк.

Пример выборки меньшего количества строк из таблицы MySQL с помощью fetchmany курсора 

 import mysql.connector
из mysql.connector Ошибка импорта
пытаться:
    соединение = mysql.connector.connect(host='localhost',
                                         база данных = 'электроника',
                                         пользователь = 'пинатив',
                                         пароль='pynative@#29')
    mySql_select_Query = "выберите * с ноутбука"
    курсор = соединение. курсор()
    курсор.execute(mySql_select_Query)
    количество строк = 2
    записи = cursor.fetchmany(row_count)
    print("Общее количество строк: ", cursor.rowcount)
    print("Печать ", row_count, " Запись ноутбука с использованием cursor.fetchmany")
    для строки в записях:
        печать (строка)
кроме ошибки как e:
    print("Ошибка при подключении к MySQL", e)
окончательно:
    если соединение.is_connected():
        курсор.закрыть()
        соединение.закрыть()
        печатать("соединение закрыто")

Вывод: 

 Общее количество строк: 2
Печать 2 записи ноутбука с использованием cursor.fetchmany
(1, «Lenovo ThinkPad P71», 6459.0, datetime.date(2019, 8, 14))
(2, 'Area 51M', 6999.0, datetime.date(2019, 4, 14))

Примечание : если вы получаете ошибку непрочитанного результата MySQL, установите буферизованный = True в соединении, например connection.cursor (buffered = True ) .

Извлечь одну строку из таблицы MySQL с помощью fetchone курсора 

 import mysql. connector
пытаться:
    соединение = mysql.connector.connect(host='localhost',
                                         база данных = 'электроника',
                                         пользователь = 'пинатив',
                                         пароль='pynative@#29')
    mySql_select_Query = "выберите * с ноутбука"
    курсор = соединение.курсор (буферизованный = Истина)
    курсор.execute(mySql_select_Query)
    запись = курсор.fetchone()
    печать (запись)
кроме mysql.connector.Error как ошибка:
    print("Ошибка при подключении к MySQL", ошибка)
окончательно:
    если соединение.is_connected():
        курсор.закрыть()
        соединение.закрыть()
        print("Соединение с MySQL закрыто")

Вывод: – 

 Печать первой записи (1, 'Lenovo ThinkPad P71', 6459.0, datetime.date(2019, 8, 14))
Соединение с MySQL закрыто

Python Получить строку MySQL, используя имена столбцов

Вы также можете получить результат , используя имена столбцов вместо идентификатора. Например, вы хотели бы сделать что-то подобное.

 записи = cursor.fetchall()
для строки в записях:
    знач1 = строка["имястолбца1"], )
    val2 = строка["имя_столбца2"])
    val3 = row["columnName3"])

Если вы попытаетесь получить данные, используя имя столбца напрямую, вы получите TypeError: индексы кортежей должны быть целыми числами или срезами, а не str .

Чтобы выбрать записи из моей таблицы MySQL, используя имя столбца, нам нужно только изменить создание курсора. Замените стандартное создание курсора следующим кодом, и вы готовы получать записи из моей таблицы MySQL, используя имя столбца.

 курсор = соединение.курсор(словарь=Истина)

Зачем устанавливать словарь=Истина ? потому что MySQLCursorDict создает курсор, который возвращает строки как словари, поэтому мы можем получить доступ, используя имя столбца (здесь имя столбца является ключом словаря)

В следующем примере я выбрал все записи из моей таблицы MySQL, используя имя столбца вместо целочисленного индекса столбца.

 импорт mysql.connector
из mysql.connector Ошибка импорта
пытаться:
    соединение = mysql.connector.connect(host='localhost',
                                         база данных = «Электроника»,
                                         пользователь = 'пинатив',
                                         пароль='pynative@#29')
    sql_select_Query = "выбрать * с ноутбука"
    # MySQLCursorDict создает курсор, который возвращает строки в виде словарей
    курсор = соединение.курсор (словарь = Истина)
    курсор.execute(sql_select_Query)
    записи = курсор.fetchall()
    
    print("Выборка каждой строки по имени столбца")
    для строки в записях:
        идентификатор = строка["Идентификатор"]
        имя = строка["Имя"]
        цена = строка["Цена"]
        Дата_покупки = строка["Дата_покупки"]
        print(id, имя, цена, Purchase_date)
кроме ошибки как e:
    print("Ошибка чтения данных из таблицы MySQL", e)
окончательно:
    если соединение.is_connected():
        соединение. закрыть()
        курсор.закрыть()
        print("Соединение с MySQL закрыто")

Вывод :

 Извлечение каждой строки по имени столбца
1 Lenovo ThinkPad P71 6459.0 14 августа 2019 г.
2 Зона 51M 6999.0 2019-04-14
3 Макбук Про 2499.0 20.06.2019
4 л.с. павильон мощность 1999.0 2019-01-11
5 MSI WS75 9TL-496 5799.0 27 февраля 2019 г.
6 Microsoft Surface 2330.0 23 июля 2019 г.
7 Acer Хищник Тритон 2435.0 2019-08-17
10 Lenovo ThinkPad P71 6459.0 2019-08-14
11 Lenovo ThinkPad P71 6459.0 2019-08-14
Соединение с MySQL закрыто

Выберите значение столбца MySQL в переменной Python

Давайте посмотрим, как выполнить следующий запрос SELECT SQL и сохранить значение столбца таблицы в переменной Python для дальнейшей обработки.

Если вы выполните приведенный ниже код, вы получите {u’Price’: u’7000′}.

 cursor.execute("ВЫБЕРИТЕ цену ИЗ ноутбука, ГДЕ id = 21")
print (cursor.fetchone() )

Вы можете получить вывод, например,

 {u'Price': u'7000'}

Давайте посмотрим, как извлечь только значение столбца (7000) и сохранить его в переменной для сделать некоторые расчеты, чтобы вы могли дать 10% скидку на него.

 импорт mysql.connector
пытаться:
    соединение = mysql.connector.connect(host='localhost',
                                         база данных = 'электроника',
                                         пользователь = 'пинатив',
                                         пароль='pynative@#29')
    sql_Query = "выберите цену с ноутбука, где id =%s"
    идентификатор = (1,)
    курсор = соединение.курсор()
    курсор.execute(sql_Query, идентификатор)
    запись = курсор.fetchone()
    # выбор значения столбца в переменную
    цена = плавающая (запись [0])
    print("Цена ноутбука: ", цена)
кроме mysql.connector.Error как ошибка:
    print("Не удалось получить запись из базы данных: {}".format(ошибка))
окончательно:
    если соединение.is_connected():
        курсор.закрыть()
        соединение.закрыть()
        print("Соединение с MySQL закрыто")

Выход:

 Цена ноутбука: 6459.0
Соединение MySQL закрыто

Давайте разберемся в этом примере :

  • Вы можете видеть в приведенном выше примере после выборки строки с помощью cursor.

    No related posts.