python - seleccionar - ¿Cómo convertir el resultado de la consulta SQL a la estructura de datos de PANDAS?

nueva columna pandas

Question

Cualquier ayuda sobre este problema será muy apreciada.

Entonces, básicamente, quiero ejecutar una consulta en mi base de datos SQL y almacenar los datos devueltos como estructura de datos de Pandas.

He adjuntado el código para consulta.

Estoy leyendo la documentación sobre pandas, pero tengo problemas para identificar el tipo de devolución de mi consulta.

Traté de imprimir el resultado de la consulta, pero no proporciona ninguna información útil.

¡¡¡¡Gracias!!!!

from sqlalchemy import create_engine

engine2 = create_engine(''mysql://THE DATABASE I AM ACCESSING'')
connection2 = engine2.connect()
dataid = 1022
resoverall = connection2.execute("
  SELECT 
      sum(BLABLA) AS BLA,
      sum(BLABLABLA2) AS BLABLABLA2,
      sum(SOME_INT) AS SOME_INT,
      sum(SOME_INT2) AS SOME_INT2,
      100*sum(SOME_INT2)/sum(SOME_INT) AS ctr,
      sum(SOME_INT2)/sum(SOME_INT) AS cpc
   FROM daily_report_cooked
   WHERE campaign_id = ''%s''", %dataid)

Así que quiero entender cuál es el formato / tipo de datos de mi variable "resoverall" y cómo ponerlo con la estructura de datos de PANDAS.

Answer 1

Conector MySQL

Para aquellos que trabajan con el conector mysql, puedes usar este código como inicio. (Gracias a @ Daniel Velkov)

Refs usados:

• Consultar datos usando el conector / Python
• Conectando a MYSQL con Python en 3 pasos

import pandas as pd
import mysql.connector

# Setup MySQL connection
db = mysql.connector.connect(
    host="<IP>",              # your host, usually localhost
    user="<USER>",            # your username
    password="<PASS>",        # your password
    database="<DATABASE>"     # name of the data base
)   

# You must create a Cursor object. It will let you execute all the queries you need
cur = db.cursor()

# Use all the SQL you like
cur.execute("SELECT * FROM <TABLE>")

# Put it all to a data frame
sql_data = pd.DataFrame(cur.fetchall())
sql_data.columns = cur.column_names

# Close the session
db.close()

# Show the data
print(sql_data.head())

Answer 2

Editar 2014-09-30:

pandas ahora tiene una función read_sql . Definitivamente quieres usar eso en su lugar.

Respuesta original:

No puedo ayudarte con SQLAlchemy. Siempre uso pyodbc, MySQLdb o psychopg2, según sea necesario. Pero al hacerlo, una función tan simple como la siguiente tiende a satisfacer mis necesidades:

import decimal

import pydobc
import numpy as np
import pandas

cnn, cur = myConnectToDBfunction()
cmd = "SELECT * FROM myTable"
cur.execute(cmd)
dataframe = __processCursor(cur, dataframe=True)

def __processCursor(cur, dataframe=False, index=None):
    ''''''
    Processes a database cursor with data on it into either
    a structured numpy array or a pandas dataframe.

    input:
    cur - a pyodbc cursor that has just received data
    dataframe - bool. if false, a numpy record array is returned
                if true, return a pandas dataframe
    index - list of column(s) to use as index in a pandas dataframe
    ''''''
    datatypes = []
    colinfo = cur.description
    for col in colinfo:
        if col[1] == unicode:
            datatypes.append((col[0], ''U%d'' % col[3]))
        elif col[1] == str:
            datatypes.append((col[0], ''S%d'' % col[3]))
        elif col[1] in [float, decimal.Decimal]:
            datatypes.append((col[0], ''f4''))
        elif col[1] == datetime.datetime:
            datatypes.append((col[0], ''O4''))
        elif col[1] == int:
            datatypes.append((col[0], ''i4''))

    data = []
    for row in cur:
        data.append(tuple(row))

    array = np.array(data, dtype=datatypes)
    if dataframe:
        output = pandas.DataFrame.from_records(array)

        if index is not None:
            output = output.set_index(index)

    else:
        output = array

    return output

Answer 3

Al igual que Nathan, a menudo quiero volcar los resultados de una consulta sqlalchemy o sqlsoup en un marco de datos de Pandas. Mi propia solución para esto es:

query = session.query(tbl.Field1, tbl.Field2)
DataFrame(query.all(), columns=[column[''name''] for column in query.column_descriptions])

Answer 4

Aquí está el código más corto que hará el trabajo:

from pandas import DataFrame
df = DataFrame(resoverall.fetchall())
df.columns = resoverall.keys()

Puede ir más elegante y analizar los tipos como en la respuesta de Paul.

Answer 5

Aquí está el código que uso. Espero que esto ayude.

import pandas as pd
from sqlalchemy import create_engine

def getData():
  # Parameters
  ServerName = "my_server"
  Database = "my_db"
  UserPwd = "user:pwd"
  Driver = "driver=SQL Server Native Client 11.0"

  # Create the connection
  engine = create_engine(''mssql+pyodbc://'' + UserPwd + ''@'' + ServerName + ''/'' + Database + "?" + Driver)

  sql = "select * from mytable"
  df = pd.read_sql(sql, engine)
  return df

df2 = getData()
print(df2)

Answer 6

Aquí esta el mio. En caso de que esté utilizando "pymysql":

import pymysql
from pandas import DataFrame

host   = ''localhost''
port   = 3306
user   = ''yourUserName''
passwd = ''yourPassword''
db     = ''yourDatabase''

cnx    = pymysql.connect(host=host, port=port, user=user, passwd=passwd, db=db)
cur    = cnx.cursor()

query  = """ SELECT * FROM yourTable LIMIT 10"""
cur.execute(query)

field_names = [i[0] for i in cur.description]
get_data = [xx for xx in cur]

cur.close()
cnx.close()

df = DataFrame(get_data)
df.columns = field_names

Answer 7

Esta es una respuesta breve y nítida a su problema:

from __future__ import print_function
import MySQLdb
import numpy as np
import pandas as pd
import xlrd

# Connecting to MySQL Database
connection = MySQLdb.connect(
             host="hostname",
             port=0000,
             user="userID",
             passwd="password",
             db="table_documents",
             charset=''utf8''
           )
print(connection)
#getting data from database into a dataframe
sql_for_df = ''select * from tabledata''
df_from_database = pd.read_sql(sql_for_df , connection)

Answer 8

Esta pregunta es antigua, pero quería agregar mis dos centavos. Leí la pregunta como "Quiero ejecutar una consulta a mi [mi] base de datos SQL y almacenar los datos devueltos como estructura de datos Pandas [DataFrame]".

Desde el código parece que te refieres a la base de datos mysql y asumes que te refieres a pandas DataFrame.

import MySQLdb as mdb
import pandas.io.sql as sql
from pandas import *

conn = mdb.connect(''<server>'',''<user>'',''<pass>'',''<db>'');
df = sql.read_frame(''<query>'', conn)

Por ejemplo,

conn = mdb.connect(''localhost'',''myname'',''mypass'',''testdb'');
df = sql.read_frame(''select * from testTable'', conn)

Esto importará todas las filas de testTable en un DataFrame.

Answer 9

La mejor forma en que hago esto

db.execute(query) where db=db_class() #database class
    mydata=[x for x in db.fetchall()]
    df=pd.DataFrame(data=mydata)

Answer 10

Mucho tiempo desde la última publicación, pero tal vez ayuda a alguien ...

En corto camino que Paul H:

my_dic = session.query(query.all())
my_df = pandas.DataFrame.from_dict(my_dic)

Answer 11

Si el tipo de resultado es ResultSet , primero conviértalo en diccionario. Luego, las columnas de DataFrame se recopilarán automáticamente.

Esto funciona en mi caso:

df = pd.DataFrame([dict(r) for r in resoverall])

Answer 12

Si está utilizando el ORM de SQLAlchemy en lugar del lenguaje de expresión, es posible que desee convertir un objeto de tipo sqlalchemy.orm.query.Query en un marco de datos de Pandas.

El enfoque más limpio es obtener el SQL generado a partir del atributo de declaración de la consulta y luego ejecutarlo con el método read_sql() pandas. Por ejemplo, comenzando con un objeto de query llamado query :

df = pd.read_sql(query.statement, query.session.bind)

Answer 13

Simplemente usa pandas y pyodbc juntos. Tendrá que modificar su cadena de conexión ( connstr ) de acuerdo con las especificaciones de su base de datos.

import pyodbc
import pandas as pd

# MSSQL Connection String Example
connstr = "Server=myServerAddress;Database=myDB;User Id=myUsername;Password=myPass;"

# Query Database and Create DataFrame Using Results
df = pd.read_sql("select * from myTable", pyodbc.connect(connstr))

He utilizado pyodbc con varias bases de datos empresariales (por ejemplo, SQL Server, MySQL, MariaDB, IBM).

Answer 14

resoverall es un objeto sqlalchemy ResultProxy. Puede leer más sobre esto en los documentos sqlalchemy , este último explica el uso básico de trabajar con motores y conexiones. Importante aquí es que resoverall es como dict.

A Pandas le gusta dict como objetos para crear sus estructuras de datos, mira los documentos en línea

Buena suerte con sqlalchemy y pandas.

Answer 15

Edición: marzo de 2015

Como se observa a continuación, pandas ahora usa SQLAlchemy para leer desde ( read_sql ) e insertar en ( to_sql ) una base de datos. Lo siguiente debería funcionar

import pandas as pd

df = pd.read_sql(sql, cnxn)

Respuesta anterior: Via mikebmassey de una pregunta similar

import pyodbc
import pandas.io.sql as psql

cnxn = pyodbc.connect(connection_info) 
cursor = cnxn.cursor()
sql = "SELECT * FROM TABLE"

df = psql.frame_query(sql, cnxn)
cnxn.close()