io_sql.py

import sqlalchemy
from .pandas_vb_common import *
import sqlite3
from sqlalchemy import create_engine


#-------------------------------------------------------------------------------
# to_sql

class WriteSQL(object):
    goal_time = 0.2

    def setup(self):
        self.engine = create_engine('sqlite:///:memory:')
        self.con = sqlite3.connect(':memory:')
        self.index = tm.makeStringIndex(10000)
        self.df = DataFrame({'float1': randn(10000), 'float2': randn(10000), 'string1': (['foo'] * 10000), 'bool1': ([True] * 10000), 'int1': np.random.randint(0, 100000, size=10000), }, index=self.index)

    def time_fallback(self):
        self.df.to_sql('test1', self.con, if_exists='replace')

    def time_sqlalchemy(self):
        self.df.to_sql('test1', self.engine, if_exists='replace')


#-------------------------------------------------------------------------------
# read_sql

class ReadSQL(object):
    goal_time = 0.2

    def setup(self):
        self.engine = create_engine('sqlite:///:memory:')
        self.con = sqlite3.connect(':memory:')
        self.index = tm.makeStringIndex(10000)
        self.df = DataFrame({'float1': randn(10000), 'float2': randn(10000), 'string1': (['foo'] * 10000), 'bool1': ([True] * 10000), 'int1': np.random.randint(0, 100000, size=10000), }, index=self.index)
        self.df.to_sql('test2', self.engine, if_exists='replace')
        self.df.to_sql('test2', self.con, if_exists='replace')

    def time_read_query_fallback(self):
        read_sql_query('SELECT * FROM test2', self.con)

    def time_read_query_sqlalchemy(self):
        read_sql_query('SELECT * FROM test2', self.engine)

    def time_read_table_sqlalchemy(self):
        read_sql_table('test2', self.engine)


#-------------------------------------------------------------------------------
# type specific write

class WriteSQLTypes(object):
    goal_time = 0.2

    def setup(self):
        self.engine = create_engine('sqlite:///:memory:')
        self.con = sqlite3.connect(':memory:')
        self.df = DataFrame({'float': randn(10000), 'string': (['foo'] * 10000), 'bool': ([True] * 10000), 'datetime': date_range('2000-01-01', periods=10000, freq='s'), })
        self.df.loc[1000:3000, 'float'] = np.nan

    def time_string_fallback(self):
        self.df[['string']].to_sql('test_string', self.con, if_exists='replace')

    def time_string_sqlalchemy(self):
        self.df[['string']].to_sql('test_string', self.engine, if_exists='replace')

    def time_float_fallback(self):
        self.df[['float']].to_sql('test_float', self.con, if_exists='replace')

    def time_float_sqlalchemy(self):
        self.df[['float']].to_sql('test_float', self.engine, if_exists='replace')

    def time_datetime_sqlalchemy(self):
        self.df[['datetime']].to_sql('test_datetime', self.engine, if_exists='replace')


#-------------------------------------------------------------------------------
# type specific read

class ReadSQLTypes(object):
    goal_time = 0.2

    def setup(self):
        self.engine = create_engine('sqlite:///:memory:')
        self.con = sqlite3.connect(':memory:')
        self.df = DataFrame({'float': randn(10000), 'datetime': date_range('2000-01-01', periods=10000, freq='s'), })
        self.df['datetime_string'] = self.df['datetime'].map(str)
        self.df.to_sql('test_type', self.engine, if_exists='replace')
        self.df[['float', 'datetime_string']].to_sql('test_type', self.con, if_exists='replace')

    def time_datetime_read_and_parse_sqlalchemy(self):
        read_sql_table('test_type', self.engine, columns=['datetime_string'], parse_dates=['datetime_string'])

    def time_datetime_read_as_native_sqlalchemy(self):
        read_sql_table('test_type', self.engine, columns=['datetime'])

    def time_float_read_query_fallback(self):
        read_sql_query('SELECT float FROM test_type', self.con)

    def time_float_read_query_sqlalchemy(self):
        read_sql_query('SELECT float FROM test_type', self.engine)

    def time_float_read_table_sqlalchemy(self):
        read_sql_table('test_type', self.engine, columns=['float'])