From f791b1bf91b7bc843fb1925ea731745b60617df4 Mon Sep 17 00:00:00 2001 From: Joris Van den Bossche Date: Mon, 8 Feb 2016 10:25:51 -0500 Subject: [PATCH] DEPR: removal of deprecated sql functions Start for removing some of the deprecated functions. Other functions to add: `write_frame`, `tquery`, `uquery` Author: Joris Van den Bossche Closes #12205 from jorisvandenbossche/remove-depr-sql and squashes the following commits: b097dba [Joris Van den Bossche] DEPR: removal of deprecated write_frame function 541e0e7 [Joris Van den Bossche] DEPR: removal of deprecated pd.io.sql.read_frame/frame_query functions --- doc/source/whatsnew/v0.18.0.txt | 4 +- pandas/io/sql.py | 63 ----------------- pandas/io/tests/test_sql.py | 115 ++++++++++++++------------------ 3 files changed, 52 insertions(+), 130 deletions(-) diff --git a/doc/source/whatsnew/v0.18.0.txt b/doc/source/whatsnew/v0.18.0.txt index 9abef19cd8e8f..421822380c2da 100644 --- a/doc/source/whatsnew/v0.18.0.txt +++ b/doc/source/whatsnew/v0.18.0.txt @@ -695,7 +695,9 @@ Removal of prior version deprecations/changes - Removal of ``expanding_corr_pairwise`` in favor of ``.expanding().corr(pairwise=True)`` (:issue:`4950`) - Removal of ``DataMatrix`` module. This was not imported into the pandas namespace in any event (:issue:`12111`) - Removal of ``cols`` keyword in favor of ``subset`` in ``DataFrame.duplicated()`` and ``DataFrame.drop_duplicates()`` (:issue:`6680`) - +- Removal of the ``read_frame`` and ``frame_query`` (both aliases for ``pd.read_sql``) + and ``write_frame`` (alias of ``to_sql``) functions in the ``pd.io.sql`` namespace, + deprecated since 0.14.0 (:issue:`6292`). .. _whatsnew_0180.performance: diff --git a/pandas/io/sql.py b/pandas/io/sql.py index 63725988c8065..072ca86600ea0 100644 --- a/pandas/io/sql.py +++ b/pandas/io/sql.py @@ -1704,66 +1704,3 @@ def get_schema(frame, name, flavor='sqlite', keys=None, con=None, dtype=None): pandas_sql = pandasSQL_builder(con=con, flavor=flavor) return pandas_sql._create_sql_schema(frame, name, keys=keys, dtype=dtype) - - -# legacy names, with depreciation warnings and copied docs - -@Appender(read_sql.__doc__, join='\n') -def read_frame(*args, **kwargs): - """DEPRECATED - use read_sql - """ - warnings.warn("read_frame is deprecated, use read_sql", FutureWarning, - stacklevel=2) - return read_sql(*args, **kwargs) - - -@Appender(read_sql.__doc__, join='\n') -def frame_query(*args, **kwargs): - """DEPRECATED - use read_sql - """ - warnings.warn("frame_query is deprecated, use read_sql", FutureWarning, - stacklevel=2) - return read_sql(*args, **kwargs) - - -def write_frame(frame, name, con, flavor='sqlite', if_exists='fail', **kwargs): - """DEPRECATED - use to_sql - - Write records stored in a DataFrame to a SQL database. - - Parameters - ---------- - frame : DataFrame - name : string - con : DBAPI2 connection - flavor : {'sqlite', 'mysql'}, default 'sqlite' - The flavor of SQL to use. - if_exists : {'fail', 'replace', 'append'}, default 'fail' - - fail: If table exists, do nothing. - - replace: If table exists, drop it, recreate it, and insert data. - - append: If table exists, insert data. Create if does not exist. - index : boolean, default False - Write DataFrame index as a column - - Notes - ----- - This function is deprecated in favor of ``to_sql``. There are however - two differences: - - - With ``to_sql`` the index is written to the sql database by default. To - keep the behaviour this function you need to specify ``index=False``. - - The new ``to_sql`` function supports sqlalchemy connectables to work - with different sql flavors. - - See also - -------- - pandas.DataFrame.to_sql - - """ - warnings.warn("write_frame is deprecated, use to_sql", FutureWarning, - stacklevel=2) - - # for backwards compatibility, set index=False when not specified - index = kwargs.pop('index', False) - return to_sql(frame, name, con, flavor=flavor, if_exists=if_exists, - index=index, **kwargs) diff --git a/pandas/io/tests/test_sql.py b/pandas/io/tests/test_sql.py index 455e27b70055d..a5f6acc113466 100644 --- a/pandas/io/tests/test_sql.py +++ b/pandas/io/tests/test_sql.py @@ -524,12 +524,6 @@ def test_read_sql_view(self): "SELECT * FROM iris_view", self.conn) self._check_iris_loaded_frame(iris_frame) - def test_legacy_read_frame(self): - with tm.assert_produces_warning(FutureWarning): - iris_frame = sql.read_frame( - "SELECT * FROM iris", self.conn) - self._check_iris_loaded_frame(iris_frame) - def test_to_sql(self): sql.to_sql(self.test_frame1, 'test_frame1', self.conn, flavor='sqlite') self.assertTrue( @@ -598,17 +592,6 @@ def test_to_sql_panel(self): self.assertRaises(NotImplementedError, sql.to_sql, panel, 'test_panel', self.conn, flavor='sqlite') - def test_legacy_write_frame(self): - # Assume that functionality is already tested above so just do - # quick check that it basically works - with tm.assert_produces_warning(FutureWarning): - sql.write_frame(self.test_frame1, 'test_frame_legacy', self.conn, - flavor='sqlite') - - self.assertTrue( - sql.has_table('test_frame_legacy', self.conn, flavor='sqlite'), - 'Table not written to DB') - def test_roundtrip(self): sql.to_sql(self.test_frame1, 'test_frame_roundtrip', con=self.conn, flavor='sqlite') @@ -2239,7 +2222,7 @@ def test_write_row_by_row(self): self.conn.commit() - result = sql.read_frame("select * from test", con=self.conn) + result = sql.read_sql("select * from test", con=self.conn) result.index = frame.index tm.assert_frame_equal(result, frame) @@ -2254,7 +2237,7 @@ def test_execute(self): sql.execute(ins, self.conn, params=tuple(row)) self.conn.commit() - result = sql.read_frame("select * from test", self.conn) + result = sql.read_sql("select * from test", self.conn) result.index = frame.index[:1] tm.assert_frame_equal(result, frame[:1]) @@ -2327,8 +2310,8 @@ def test_na_roundtrip(self): pass def _check_roundtrip(self, frame): - sql.write_frame(frame, name='test_table', con=self.conn) - result = sql.read_frame("select * from test_table", self.conn) + sql.to_sql(frame, name='test_table', con=self.conn, index=False) + result = sql.read_sql("select * from test_table", self.conn) # HACK! Change this once indexes are handled properly. result.index = frame.index @@ -2339,8 +2322,8 @@ def _check_roundtrip(self, frame): frame['txt'] = ['a'] * len(frame) frame2 = frame.copy() frame2['Idx'] = Index(lrange(len(frame2))) + 10 - sql.write_frame(frame2, name='test_table2', con=self.conn) - result = sql.read_frame("select * from test_table2", self.conn, + sql.to_sql(frame2, name='test_table2', con=self.conn, index=False) + result = sql.read_sql("select * from test_table2", self.conn, index_col='Idx') expected = frame.copy() expected.index = Index(lrange(len(frame2))) + 10 @@ -2349,7 +2332,7 @@ def _check_roundtrip(self, frame): def test_tquery(self): frame = tm.makeTimeDataFrame() - sql.write_frame(frame, name='test_table', con=self.conn) + sql.to_sql(frame, name='test_table', con=self.conn, index=False) result = sql.tquery("select A from test_table", self.conn) expected = Series(frame.A.values, frame.index) # not to have name result = Series(result, frame.index) @@ -2367,7 +2350,7 @@ def test_tquery(self): def test_uquery(self): frame = tm.makeTimeDataFrame() - sql.write_frame(frame, name='test_table', con=self.conn) + sql.to_sql(frame, name='test_table', con=self.conn, index=False) stmt = 'INSERT INTO test_table VALUES(2.314, -123.1, 1.234, 2.3)' self.assertEqual(sql.uquery(stmt, con=self.conn), 1) @@ -2387,14 +2370,14 @@ def test_keyword_as_column_names(self): ''' ''' df = DataFrame({'From': np.ones(5)}) - sql.write_frame(df, con=self.conn, name='testkeywords') + sql.to_sql(df, con=self.conn, name='testkeywords', index=False) def test_onecolumn_of_integer(self): # GH 3628 # a column_of_integers dataframe should transfer well to sql mono_df = DataFrame([1, 2], columns=['c0']) - sql.write_frame(mono_df, con=self.conn, name='mono_df') + sql.to_sql(mono_df, con=self.conn, name='mono_df', index=False) # computing the sum via sql con_x = self.conn the_sum = sum([my_c0[0] @@ -2402,7 +2385,7 @@ def test_onecolumn_of_integer(self): # it should not fail, and gives 3 ( Issue #3628 ) self.assertEqual(the_sum, 3) - result = sql.read_frame("select * from mono_df", con_x) + result = sql.read_sql("select * from mono_df", con_x) tm.assert_frame_equal(result, mono_df) def test_if_exists(self): @@ -2421,7 +2404,7 @@ def clean_up(test_table_to_drop): # test if invalid value for if_exists raises appropriate error self.assertRaises(ValueError, - sql.write_frame, + sql.to_sql, frame=df_if_exists_1, con=self.conn, name=table_name, @@ -2430,10 +2413,10 @@ def clean_up(test_table_to_drop): clean_up(table_name) # test if_exists='fail' - sql.write_frame(frame=df_if_exists_1, con=self.conn, name=table_name, - flavor='sqlite', if_exists='fail') + sql.to_sql(frame=df_if_exists_1, con=self.conn, name=table_name, + flavor='sqlite', if_exists='fail') self.assertRaises(ValueError, - sql.write_frame, + sql.to_sql, frame=df_if_exists_1, con=self.conn, name=table_name, @@ -2441,23 +2424,23 @@ def clean_up(test_table_to_drop): if_exists='fail') # test if_exists='replace' - sql.write_frame(frame=df_if_exists_1, con=self.conn, name=table_name, - flavor='sqlite', if_exists='replace') + sql.to_sql(frame=df_if_exists_1, con=self.conn, name=table_name, + flavor='sqlite', if_exists='replace', index=False) self.assertEqual(sql.tquery(sql_select, con=self.conn), [(1, 'A'), (2, 'B')]) - sql.write_frame(frame=df_if_exists_2, con=self.conn, name=table_name, - flavor='sqlite', if_exists='replace') + sql.to_sql(frame=df_if_exists_2, con=self.conn, name=table_name, + flavor='sqlite', if_exists='replace', index=False) self.assertEqual(sql.tquery(sql_select, con=self.conn), [(3, 'C'), (4, 'D'), (5, 'E')]) clean_up(table_name) # test if_exists='append' - sql.write_frame(frame=df_if_exists_1, con=self.conn, name=table_name, - flavor='sqlite', if_exists='fail') + sql.to_sql(frame=df_if_exists_1, con=self.conn, name=table_name, + flavor='sqlite', if_exists='fail', index=False) self.assertEqual(sql.tquery(sql_select, con=self.conn), [(1, 'A'), (2, 'B')]) - sql.write_frame(frame=df_if_exists_2, con=self.conn, name=table_name, - flavor='sqlite', if_exists='append') + sql.to_sql(frame=df_if_exists_2, con=self.conn, name=table_name, + flavor='sqlite', if_exists='append', index=False) self.assertEqual(sql.tquery(sql_select, con=self.conn), [(1, 'A'), (2, 'B'), (3, 'C'), (4, 'D'), (5, 'E')]) clean_up(table_name) @@ -2542,7 +2525,7 @@ def test_write_row_by_row(self): self.conn.commit() - result = sql.read_frame("select * from test", con=self.conn) + result = sql.read_sql("select * from test", con=self.conn) result.index = frame.index tm.assert_frame_equal(result, frame) @@ -2577,7 +2560,7 @@ def test_execute(self): sql.execute(ins, self.conn, params=tuple(row)) self.conn.commit() - result = sql.read_frame("select * from test", self.conn) + result = sql.read_sql("select * from test", self.conn) result.index = frame.index[:1] tm.assert_frame_equal(result, frame[:1]) @@ -2666,9 +2649,9 @@ def _check_roundtrip(self, frame): with warnings.catch_warnings(): warnings.filterwarnings("ignore", "Unknown table.*") cur.execute(drop_sql) - sql.write_frame(frame, name='test_table', - con=self.conn, flavor='mysql') - result = sql.read_frame("select * from test_table", self.conn) + sql.to_sql(frame, name='test_table', + con=self.conn, flavor='mysql', index=False) + result = sql.read_sql("select * from test_table", self.conn) # HACK! Change this once indexes are handled properly. result.index = frame.index @@ -2686,9 +2669,9 @@ def _check_roundtrip(self, frame): with warnings.catch_warnings(): warnings.filterwarnings("ignore", "Unknown table.*") cur.execute(drop_sql) - sql.write_frame(frame2, name='test_table2', - con=self.conn, flavor='mysql') - result = sql.read_frame("select * from test_table2", self.conn, + sql.to_sql(frame2, name='test_table2', + con=self.conn, flavor='mysql', index=False) + result = sql.read_sql("select * from test_table2", self.conn, index_col='Idx') expected = frame.copy() @@ -2706,8 +2689,8 @@ def test_tquery(self): drop_sql = "DROP TABLE IF EXISTS test_table" cur = self.conn.cursor() cur.execute(drop_sql) - sql.write_frame(frame, name='test_table', - con=self.conn, flavor='mysql') + sql.to_sql(frame, name='test_table', + con=self.conn, flavor='mysql', index=False) result = sql.tquery("select A from test_table", self.conn) expected = Series(frame.A.values, frame.index) # not to have name result = Series(result, frame.index) @@ -2732,8 +2715,8 @@ def test_uquery(self): drop_sql = "DROP TABLE IF EXISTS test_table" cur = self.conn.cursor() cur.execute(drop_sql) - sql.write_frame(frame, name='test_table', - con=self.conn, flavor='mysql') + sql.to_sql(frame, name='test_table', + con=self.conn, flavor='mysql', index=False) stmt = 'INSERT INTO test_table VALUES(2.314, -123.1, 1.234, 2.3)' self.assertEqual(sql.uquery(stmt, con=self.conn), 1) @@ -2754,8 +2737,8 @@ def test_keyword_as_column_names(self): ''' _skip_if_no_pymysql() df = DataFrame({'From': np.ones(5)}) - sql.write_frame(df, con=self.conn, name='testkeywords', - if_exists='replace', flavor='mysql') + sql.to_sql(df, con=self.conn, name='testkeywords', + if_exists='replace', flavor='mysql', index=False) def test_if_exists(self): _skip_if_no_pymysql() @@ -2774,7 +2757,7 @@ def clean_up(test_table_to_drop): # test if invalid value for if_exists raises appropriate error self.assertRaises(ValueError, - sql.write_frame, + sql.to_sql, frame=df_if_exists_1, con=self.conn, name=table_name, @@ -2783,10 +2766,10 @@ def clean_up(test_table_to_drop): clean_up(table_name) # test if_exists='fail' - sql.write_frame(frame=df_if_exists_1, con=self.conn, name=table_name, - flavor='mysql', if_exists='fail') + sql.to_sql(frame=df_if_exists_1, con=self.conn, name=table_name, + flavor='mysql', if_exists='fail', index=False) self.assertRaises(ValueError, - sql.write_frame, + sql.to_sql, frame=df_if_exists_1, con=self.conn, name=table_name, @@ -2794,23 +2777,23 @@ def clean_up(test_table_to_drop): if_exists='fail') # test if_exists='replace' - sql.write_frame(frame=df_if_exists_1, con=self.conn, name=table_name, - flavor='mysql', if_exists='replace') + sql.to_sql(frame=df_if_exists_1, con=self.conn, name=table_name, + flavor='mysql', if_exists='replace', index=False) self.assertEqual(sql.tquery(sql_select, con=self.conn), [(1, 'A'), (2, 'B')]) - sql.write_frame(frame=df_if_exists_2, con=self.conn, name=table_name, - flavor='mysql', if_exists='replace') + sql.to_sql(frame=df_if_exists_2, con=self.conn, name=table_name, + flavor='mysql', if_exists='replace', index=False) self.assertEqual(sql.tquery(sql_select, con=self.conn), [(3, 'C'), (4, 'D'), (5, 'E')]) clean_up(table_name) # test if_exists='append' - sql.write_frame(frame=df_if_exists_1, con=self.conn, name=table_name, - flavor='mysql', if_exists='fail') + sql.to_sql(frame=df_if_exists_1, con=self.conn, name=table_name, + flavor='mysql', if_exists='fail', index=False) self.assertEqual(sql.tquery(sql_select, con=self.conn), [(1, 'A'), (2, 'B')]) - sql.write_frame(frame=df_if_exists_2, con=self.conn, name=table_name, - flavor='mysql', if_exists='append') + sql.to_sql(frame=df_if_exists_2, con=self.conn, name=table_name, + flavor='mysql', if_exists='append', index=False) self.assertEqual(sql.tquery(sql_select, con=self.conn), [(1, 'A'), (2, 'B'), (3, 'C'), (4, 'D'), (5, 'E')]) clean_up(table_name)