Toute aide sur ce problème sera grandement appréciée.

Donc, fondamentalement, je veux exécuter une requête sur ma base de données SQL et stocker les données renvoyées sous forme de structure de données Pandas.

J'ai joint le code pour la requête.

Je lis la documentation sur Pandas, mais j'ai du mal à identifier le type de retour de ma requête.

J'ai essayé d'imprimer le résultat de la requête, mais cela ne donne aucune information utile.

Merci!!!!

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)

Donc je veux en quelque sorte comprendre quel est le format / type de données de ma variable "resoverall" et comment la mettre avec la structure de données PANDAS.

Voici le code le plus court qui fera le travail:

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

Vous pouvez aller plus loin et analyser les types comme dans la réponse de Paul.

Edit: mars 2015

Comme indiqué ci-dessous, pandas utilise maintenant SQLAlchemy pour lire à partir de ( read_sql ) et insérer dans ( to_sql ) une base de données. Ce qui suit devrait fonctionner

import pandas as pd

df = pd.read_sql(sql, cnxn)

Réponse précédente: Via mikebmassey d'une question similaire

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()

Si vous utilisez l'ORM de SQLAlchemy plutôt que le langage d'expression, vous voudrez peut-être convertir un objet de type sqlalchemy.orm.query.Query en bloc de données Pandas.

L'approche la plus propre consiste à obtenir le SQL généré à partir de l'attribut d'instruction de la requête, puis à l'exécuter avec la read_sql()méthode de pandas . Par exemple, en commençant par un objet Query appelé query:

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

Modifier le 30/09/2014:

pandas a maintenant une read_sqlfonction. Vous voulez certainement l'utiliser à la place.

Réponse originale:

Je ne peux pas vous aider avec SQLAlchemy - J'utilise toujours pyodbc, MySQLdb ou psychopg2 selon les besoins. Mais ce faisant, une fonction aussi simple que celle ci-dessous a tendance à répondre à mes besoins:

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

Connecteur MySQL

Pour ceux qui fonctionnent avec le connecteur mysql, vous pouvez utiliser ce code comme point de départ. (Merci à @Daniel Velkov)

Réfs utilisés:

• Interroger des données à l'aide de Connector / Python
• Se connecter à MYSQL avec Python en 3 étapes

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())

Voici le code que j'utilise. J'espère que cela t'aides.

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)

Voici une réponse courte et claire à votre problème:

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)

1. Utilisation de MySQL-connector-python

# pip install mysql-connector-python

import mysql.connector
import pandas as pd

mydb = mysql.connector.connect(
    host = 'host',
    user = 'username',
    passwd = 'pass',
    database = 'db_name'
)
query = 'select * from table_name'
df = pd.read_sql(query, con = mydb)
print(df)

2. Utilisation de SQLAlchemy

# pip install pymysql
# pip install sqlalchemy

import pandas as pd
import sqlalchemy

engine = sqlalchemy.create_engine('mysql+pymysql://username:password@localhost:3306/db_name')

query = '''
select * from table_name
'''
df = pd.read_sql_query(query, engine)
print(df)

Comme Nathan, je souhaite souvent vider les résultats d'une requête sqlalchemy ou sqlsoup dans une trame de données Pandas. Ma propre solution pour cela est:

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

resoverallest un objet sqlalchemy ResultProxy. Vous pouvez en savoir plus à ce sujet dans la documentation sqlalchemy , cette dernière explique l'utilisation de base du travail avec les moteurs et les connexions. L'important ici est queresoverall c'est dict comme.

Les pandas aiment les objets comme des dict pour créer leurs structures de données, voir la documentation en ligne

Bonne chance avec sqlalchemy et pandas.

Utilisez simplement pandaset pyodbcensemble. Vous devrez modifier votre chaîne de connexion ( connstr) en fonction des spécifications de votre base de données.

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))

J'ai utilisé pyodbcavec plusieurs bases de données d'entreprise (par exemple SQL Server, MySQL, MariaDB, IBM).

Cette question est ancienne, mais je voulais ajouter mes deux cents. J'ai lu la question comme "Je veux exécuter une requête sur ma [ma] base de données SQL et stocker les données renvoyées sous forme de structure de données Pandas [DataFrame]".

D'après le code, il semble que vous vouliez dire la base de données mysql et que vous vouliez dire 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)

Par exemple,

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

Cela importera toutes les lignes de testTable dans un DataFrame.

Voici le mien. Juste au cas où vous utilisez "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

pandas.io.sql.write_frame est DEPRECATED. https://pandas.pydata.org/pandas-docs/version/0.15.2/generated/pandas.io.sql.write_frame.html

Devrait changer pour utiliser pandas.DataFrame.to_sql https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_sql.html

Il existe une autre solution. PYODBC vers Pandas - DataFrame ne fonctionne pas - La forme des valeurs transmises est (x, y), les indices impliquent (w, z)

Depuis Pandas 0.12 (je crois), vous pouvez faire:

import pandas
import pyodbc

sql = 'select * from table'
cnn = pyodbc.connect(...)

data = pandas.read_sql(sql, cnn)

Avant la version 0.12, vous pouviez faire:

import pandas
from pandas.io.sql import read_frame
import pyodbc

sql = 'select * from table'
cnn = pyodbc.connect(...)

data = read_frame(sql, cnn)

Longtemps depuis le dernier message, mais peut-être que cela aide quelqu'un ...

Chemin court que Paul H:

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

meilleure façon de faire ça

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

Si le type de résultat est ResultSet , vous devez d'abord le convertir en dictionnaire. Ensuite, les colonnes DataFrame seront collectées automatiquement.

Cela fonctionne sur mon cas:

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