Skip to content

Commit aba844f

Browse files
jorisvandenbosschejorisvandenbossche
committed
Clean-up sql benchmarks
1 parent 48d4a53 commit aba844f

File tree

1 file changed

+46
-156
lines changed

1 file changed

+46
-156
lines changed

‎asv_bench/benchmarks/io_sql.py

+46-156
Original file line numberDiff line numberDiff line change
@@ -4,121 +4,29 @@
44
from sqlalchemy import create_engine
55

66

7-
class sql_datetime_read_and_parse_sqlalchemy(object):
8-
goal_time = 0.2
9-
10-
def setup(self):
11-
self.engine = create_engine('sqlite:///:memory:')
12-
self.con = sqlite3.connect(':memory:')
13-
self.df = DataFrame({'float': randn(10000), 'datetime': date_range('2000-01-01', periods=10000, freq='s'), })
14-
self.df['datetime_string'] = self.df['datetime'].map(str)
15-
self.df.to_sql('test_type', self.engine, if_exists='replace')
16-
self.df[['float', 'datetime_string']].to_sql('test_type', self.con, if_exists='replace')
17-
18-
def time_sql_datetime_read_and_parse_sqlalchemy(self):
19-
read_sql_table('test_type', self.engine, columns=['datetime_string'], parse_dates=['datetime_string'])
20-
21-
22-
class sql_datetime_read_as_native_sqlalchemy(object):
23-
goal_time = 0.2
24-
25-
def setup(self):
26-
self.engine = create_engine('sqlite:///:memory:')
27-
self.con = sqlite3.connect(':memory:')
28-
self.df = DataFrame({'float': randn(10000), 'datetime': date_range('2000-01-01', periods=10000, freq='s'), })
29-
self.df['datetime_string'] = self.df['datetime'].map(str)
30-
self.df.to_sql('test_type', self.engine, if_exists='replace')
31-
self.df[['float', 'datetime_string']].to_sql('test_type', self.con, if_exists='replace')
32-
33-
def time_sql_datetime_read_as_native_sqlalchemy(self):
34-
read_sql_table('test_type', self.engine, columns=['datetime'])
35-
36-
37-
class sql_datetime_write_sqlalchemy(object):
38-
goal_time = 0.2
39-
40-
def setup(self):
41-
self.engine = create_engine('sqlite:///:memory:')
42-
self.con = sqlite3.connect(':memory:')
43-
self.df = DataFrame({'float': randn(10000), 'string': (['foo'] * 10000), 'bool': ([True] * 10000), 'datetime': date_range('2000-01-01', periods=10000, freq='s'), })
44-
self.df.loc[1000:3000, 'float'] = np.nan
45-
46-
def time_sql_datetime_write_sqlalchemy(self):
47-
self.df[['datetime']].to_sql('test_datetime', self.engine, if_exists='replace')
48-
7+
#-------------------------------------------------------------------------------
8+
# to_sql
499

50-
class sql_float_read_query_fallback(object):
10+
class WriteSQL(object):
5111
goal_time = 0.2
5212

5313
def setup(self):
5414
self.engine = create_engine('sqlite:///:memory:')
5515
self.con = sqlite3.connect(':memory:')
56-
self.df = DataFrame({'float': randn(10000), 'datetime': date_range('2000-01-01', periods=10000, freq='s'), })
57-
self.df['datetime_string'] = self.df['datetime'].map(str)
58-
self.df.to_sql('test_type', self.engine, if_exists='replace')
59-
self.df[['float', 'datetime_string']].to_sql('test_type', self.con, if_exists='replace')
60-
61-
def time_sql_float_read_query_fallback(self):
62-
read_sql_query('SELECT float FROM test_type', self.con)
63-
64-
65-
class sql_float_read_query_sqlalchemy(object):
66-
goal_time = 0.2
67-
68-
def setup(self):
69-
self.engine = create_engine('sqlite:///:memory:')
70-
self.con = sqlite3.connect(':memory:')
71-
self.df = DataFrame({'float': randn(10000), 'datetime': date_range('2000-01-01', periods=10000, freq='s'), })
72-
self.df['datetime_string'] = self.df['datetime'].map(str)
73-
self.df.to_sql('test_type', self.engine, if_exists='replace')
74-
self.df[['float', 'datetime_string']].to_sql('test_type', self.con, if_exists='replace')
75-
76-
def time_sql_float_read_query_sqlalchemy(self):
77-
read_sql_query('SELECT float FROM test_type', self.engine)
78-
79-
80-
class sql_float_read_table_sqlalchemy(object):
81-
goal_time = 0.2
82-
83-
def setup(self):
84-
self.engine = create_engine('sqlite:///:memory:')
85-
self.con = sqlite3.connect(':memory:')
86-
self.df = DataFrame({'float': randn(10000), 'datetime': date_range('2000-01-01', periods=10000, freq='s'), })
87-
self.df['datetime_string'] = self.df['datetime'].map(str)
88-
self.df.to_sql('test_type', self.engine, if_exists='replace')
89-
self.df[['float', 'datetime_string']].to_sql('test_type', self.con, if_exists='replace')
90-
91-
def time_sql_float_read_table_sqlalchemy(self):
92-
read_sql_table('test_type', self.engine, columns=['float'])
93-
94-
95-
class sql_float_write_fallback(object):
96-
goal_time = 0.2
97-
98-
def setup(self):
99-
self.engine = create_engine('sqlite:///:memory:')
100-
self.con = sqlite3.connect(':memory:')
101-
self.df = DataFrame({'float': randn(10000), 'string': (['foo'] * 10000), 'bool': ([True] * 10000), 'datetime': date_range('2000-01-01', periods=10000, freq='s'), })
102-
self.df.loc[1000:3000, 'float'] = np.nan
103-
104-
def time_sql_float_write_fallback(self):
105-
self.df[['float']].to_sql('test_float', self.con, if_exists='replace')
106-
16+
self.index = tm.makeStringIndex(10000)
17+
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)
10718

108-
class sql_float_write_sqlalchemy(object):
109-
goal_time = 0.2
19+
def time_fallback(self):
20+
self.df.to_sql('test1', self.con, if_exists='replace')
11021

111-
def setup(self):
112-
self.engine = create_engine('sqlite:///:memory:')
113-
self.con = sqlite3.connect(':memory:')
114-
self.df = DataFrame({'float': randn(10000), 'string': (['foo'] * 10000), 'bool': ([True] * 10000), 'datetime': date_range('2000-01-01', periods=10000, freq='s'), })
115-
self.df.loc[1000:3000, 'float'] = np.nan
22+
def time_sqlalchemy(self):
23+
self.df.to_sql('test1', self.engine, if_exists='replace')
11624

117-
def time_sql_float_write_sqlalchemy(self):
118-
self.df[['float']].to_sql('test_float', self.engine, if_exists='replace')
11925

26+
#-------------------------------------------------------------------------------
27+
# read_sql
12028

121-
class sql_read_query_fallback(object):
29+
class ReadSQL(object):
12230
goal_time = 0.2
12331

12432
def setup(self):
@@ -129,41 +37,20 @@ def setup(self):
12937
self.df.to_sql('test2', self.engine, if_exists='replace')
13038
self.df.to_sql('test2', self.con, if_exists='replace')
13139

132-
def time_sql_read_query_fallback(self):
40+
def time_read_query_fallback(self):
13341
read_sql_query('SELECT * FROM test2', self.con)
13442

135-
136-
class sql_read_query_sqlalchemy(object):
137-
goal_time = 0.2
138-
139-
def setup(self):
140-
self.engine = create_engine('sqlite:///:memory:')
141-
self.con = sqlite3.connect(':memory:')
142-
self.index = tm.makeStringIndex(10000)
143-
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)
144-
self.df.to_sql('test2', self.engine, if_exists='replace')
145-
self.df.to_sql('test2', self.con, if_exists='replace')
146-
147-
def time_sql_read_query_sqlalchemy(self):
43+
def time_read_query_sqlalchemy(self):
14844
read_sql_query('SELECT * FROM test2', self.engine)
14945

150-
151-
class sql_read_table_sqlalchemy(object):
152-
goal_time = 0.2
153-
154-
def setup(self):
155-
self.engine = create_engine('sqlite:///:memory:')
156-
self.con = sqlite3.connect(':memory:')
157-
self.index = tm.makeStringIndex(10000)
158-
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)
159-
self.df.to_sql('test2', self.engine, if_exists='replace')
160-
self.df.to_sql('test2', self.con, if_exists='replace')
161-
162-
def time_sql_read_table_sqlalchemy(self):
46+
def time_read_table_sqlalchemy(self):
16347
read_sql_table('test2', self.engine)
16448

16549

166-
class sql_string_write_fallback(object):
50+
#-------------------------------------------------------------------------------
51+
# type specific write
52+
53+
class WriteSQLTypes(object):
16754
goal_time = 0.2
16855

16956
def setup(self):
@@ -172,44 +59,47 @@ def setup(self):
17259
self.df = DataFrame({'float': randn(10000), 'string': (['foo'] * 10000), 'bool': ([True] * 10000), 'datetime': date_range('2000-01-01', periods=10000, freq='s'), })
17360
self.df.loc[1000:3000, 'float'] = np.nan
17461

175-
def time_sql_string_write_fallback(self):
62+
def time_string_fallback(self):
17663
self.df[['string']].to_sql('test_string', self.con, if_exists='replace')
17764

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

179-
class sql_string_write_sqlalchemy(object):
180-
goal_time = 0.2
68+
def time_float_fallback(self):
69+
self.df[['float']].to_sql('test_float', self.con, if_exists='replace')
18170

182-
def setup(self):
183-
self.engine = create_engine('sqlite:///:memory:')
184-
self.con = sqlite3.connect(':memory:')
185-
self.df = DataFrame({'float': randn(10000), 'string': (['foo'] * 10000), 'bool': ([True] * 10000), 'datetime': date_range('2000-01-01', periods=10000, freq='s'), })
186-
self.df.loc[1000:3000, 'float'] = np.nan
71+
def time_float_sqlalchemy(self):
72+
self.df[['float']].to_sql('test_float', self.engine, if_exists='replace')
18773

188-
def time_sql_string_write_sqlalchemy(self):
189-
self.df[['string']].to_sql('test_string', self.engine, if_exists='replace')
74+
def time_datetime_sqlalchemy(self):
75+
self.df[['datetime']].to_sql('test_datetime', self.engine, if_exists='replace')
19076

19177

192-
class sql_write_fallback(object):
78+
#-------------------------------------------------------------------------------
79+
# type specific read
80+
81+
class ReadSQLTypes(object):
19382
goal_time = 0.2
19483

19584
def setup(self):
19685
self.engine = create_engine('sqlite:///:memory:')
19786
self.con = sqlite3.connect(':memory:')
198-
self.index = tm.makeStringIndex(10000)
199-
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)
87+
self.df = DataFrame({'float': randn(10000), 'datetime': date_range('2000-01-01', periods=10000, freq='s'), })
88+
self.df['datetime_string'] = self.df['datetime'].map(str)
89+
self.df.to_sql('test_type', self.engine, if_exists='replace')
90+
self.df[['float', 'datetime_string']].to_sql('test_type', self.con, if_exists='replace')
20091

201-
def time_sql_write_fallback(self):
202-
self.df.to_sql('test1', self.con, if_exists='replace')
92+
def time_datetime_read_and_parse_sqlalchemy(self):
93+
read_sql_table('test_type', self.engine, columns=['datetime_string'], parse_dates=['datetime_string'])
20394

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

205-
class sql_write_sqlalchemy(object):
206-
goal_time = 0.2
98+
def time_float_read_query_fallback(self):
99+
read_sql_query('SELECT float FROM test_type', self.con)
207100

208-
def setup(self):
209-
self.engine = create_engine('sqlite:///:memory:')
210-
self.con = sqlite3.connect(':memory:')
211-
self.index = tm.makeStringIndex(10000)
212-
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)
101+
def time_float_read_query_sqlalchemy(self):
102+
read_sql_query('SELECT float FROM test_type', self.engine)
213103

214-
def time_sql_write_sqlalchemy(self):
215-
self.df.to_sql('test1', self.engine, if_exists='replace')
104+
def time_float_read_table_sqlalchemy(self):
105+
read_sql_table('test_type', self.engine, columns=['float'])

0 commit comments

Comments
 (0)