Clean up imports.

Removed wildcard imports, mainly to keep pyflakes quiet. But this
change lifted some wrong imports and class usage.

1 files changed, 32 insertions, 32 deletions

diff --git a/tests/test_grouping.py b/tests/test_grouping.py
index dcc1309..06692b8 100644
--- a/tests/test_grouping.py
+++ b/tests/test_grouping.py
@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 
 import sqlparse
+from sqlparse import sql
 from sqlparse import tokens as T
-from sqlparse.engine.grouping import *
 
 from tests.utils import TestCaseBase
 
@@ -14,10 +14,10 @@ class TestGrouping(TestCaseBase):
         parsed = sqlparse.parse(s)[0]
         self.ndiffAssertEqual(s, str(parsed))
         self.assertEqual(len(parsed.tokens), 9)
-        self.assert_(isinstance(parsed.tokens[2], Parenthesis))
-        self.assert_(isinstance(parsed.tokens[-3], Parenthesis))
+        self.assert_(isinstance(parsed.tokens[2], sql.Parenthesis))
+        self.assert_(isinstance(parsed.tokens[-3], sql.Parenthesis))
         self.assertEqual(len(parsed.tokens[2].tokens), 7)
-        self.assert_(isinstance(parsed.tokens[2].tokens[3], Parenthesis))
+        self.assert_(isinstance(parsed.tokens[2].tokens[3], sql.Parenthesis))
         self.assertEqual(len(parsed.tokens[2].tokens[3].tokens), 3)
 
     def test_comments(self):
@@ -30,34 +30,34 @@ class TestGrouping(TestCaseBase):
         s = 'foo := 1;'
         parsed = sqlparse.parse(s)[0]
         self.assertEqual(len(parsed.tokens), 1)
-        self.assert_(isinstance(parsed.tokens[0], Assignment))
+        self.assert_(isinstance(parsed.tokens[0], sql.Assignment))
         s = 'foo := 1'
         parsed = sqlparse.parse(s)[0]
         self.assertEqual(len(parsed.tokens), 1)
-        self.assert_(isinstance(parsed.tokens[0], Assignment))
+        self.assert_(isinstance(parsed.tokens[0], sql.Assignment))
 
     def test_identifiers(self):
         s = 'select foo.bar from "myscheme"."table" where fail. order'
         parsed = sqlparse.parse(s)[0]
         self.ndiffAssertEqual(s, parsed.to_unicode())
-        self.assert_(isinstance(parsed.tokens[2], Identifier))
-        self.assert_(isinstance(parsed.tokens[6], Identifier))
-        self.assert_(isinstance(parsed.tokens[8], Where))
+        self.assert_(isinstance(parsed.tokens[2], sql.Identifier))
+        self.assert_(isinstance(parsed.tokens[6], sql.Identifier))
+        self.assert_(isinstance(parsed.tokens[8], sql.Where))
         s = 'select * from foo where foo.id = 1'
         parsed = sqlparse.parse(s)[0]
         self.ndiffAssertEqual(s, parsed.to_unicode())
         self.assert_(isinstance(parsed.tokens[-1].tokens[-1].tokens[0],
-                                Identifier))
+                                sql.Identifier))
         s = 'select * from (select "foo"."id" from foo)'
         parsed = sqlparse.parse(s)[0]
         self.ndiffAssertEqual(s, parsed.to_unicode())
-        self.assert_(isinstance(parsed.tokens[-1].tokens[3], Identifier))
+        self.assert_(isinstance(parsed.tokens[-1].tokens[3], sql.Identifier))
 
     def test_identifier_wildcard(self):
         p = sqlparse.parse('a.*, b.id')[0]
-        self.assert_(isinstance(p.tokens[0], IdentifierList))
-        self.assert_(isinstance(p.tokens[0].tokens[0], Identifier))
-        self.assert_(isinstance(p.tokens[0].tokens[-1], Identifier))
+        self.assert_(isinstance(p.tokens[0], sql.IdentifierList))
+        self.assert_(isinstance(p.tokens[0].tokens[0], sql.Identifier))
+        self.assert_(isinstance(p.tokens[0].tokens[-1], sql.Identifier))
 
     def test_identifier_name_wildcard(self):
         p = sqlparse.parse('a.*')[0]
@@ -67,7 +67,7 @@ class TestGrouping(TestCaseBase):
 
     def test_identifier_invalid(self):
         p = sqlparse.parse('a.')[0]
-        self.assert_(isinstance(p.tokens[0], Identifier))
+        self.assert_(isinstance(p.tokens[0], sql.Identifier))
         self.assertEqual(p.tokens[0].has_alias(), False)
         self.assertEqual(p.tokens[0].get_name(), None)
         self.assertEqual(p.tokens[0].get_real_name(), None)
@@ -76,33 +76,33 @@ class TestGrouping(TestCaseBase):
     def test_identifier_as_invalid(self):  # issue8
         p = sqlparse.parse('foo as select *')[0]
         self.assert_(len(p.tokens), 5)
-        self.assert_(isinstance(p.tokens[0], Identifier))
+        self.assert_(isinstance(p.tokens[0], sql.Identifier))
         self.assertEqual(len(p.tokens[0].tokens), 1)
         self.assertEqual(p.tokens[2].ttype, T.Keyword)
 
     def test_identifier_function(self):
         p = sqlparse.parse('foo() as bar')[0]
-        self.assert_(isinstance(p.tokens[0], Identifier))
-        self.assert_(isinstance(p.tokens[0].tokens[0], Function))
+        self.assert_(isinstance(p.tokens[0], sql.Identifier))
+        self.assert_(isinstance(p.tokens[0].tokens[0], sql.Function))
         p = sqlparse.parse('foo()||col2 bar')[0]
-        self.assert_(isinstance(p.tokens[0], Identifier))
-        self.assert_(isinstance(p.tokens[0].tokens[0], Function))
+        self.assert_(isinstance(p.tokens[0], sql.Identifier))
+        self.assert_(isinstance(p.tokens[0].tokens[0], sql.Function))
 
     def test_identifier_list(self):
         p = sqlparse.parse('a, b, c')[0]
-        self.assert_(isinstance(p.tokens[0], IdentifierList))
+        self.assert_(isinstance(p.tokens[0], sql.IdentifierList))
         p = sqlparse.parse('(a, b, c)')[0]
-        self.assert_(isinstance(p.tokens[0].tokens[1], IdentifierList))
+        self.assert_(isinstance(p.tokens[0].tokens[1], sql.IdentifierList))
 
     def test_identifier_list_case(self):
         p = sqlparse.parse('a, case when 1 then 2 else 3 end as b, c')[0]
-        self.assert_(isinstance(p.tokens[0], IdentifierList))
+        self.assert_(isinstance(p.tokens[0], sql.IdentifierList))
         p = sqlparse.parse('(a, case when 1 then 2 else 3 end as b, c)')[0]
-        self.assert_(isinstance(p.tokens[0].tokens[1], IdentifierList))
+        self.assert_(isinstance(p.tokens[0].tokens[1], sql.IdentifierList))
 
     def test_identifier_list_other(self):  # issue2
         p = sqlparse.parse("select *, null, 1, 'foo', bar from mytable, x")[0]
-        self.assert_(isinstance(p.tokens[2], IdentifierList))
+        self.assert_(isinstance(p.tokens[2], sql.IdentifierList))
         l = p.tokens[2]
         self.assertEqual(len(l.tokens), 13)
 
@@ -114,7 +114,7 @@ class TestGrouping(TestCaseBase):
         s = 'select x from (select y from foo where bar = 1) z'
         p = sqlparse.parse(s)[0]
         self.ndiffAssertEqual(s, p.to_unicode())
-        self.assertTrue(isinstance(p.tokens[-3].tokens[-2], Where))
+        self.assertTrue(isinstance(p.tokens[-3].tokens[-2], sql.Where))
 
     def test_typecast(self):
         s = 'select foo::integer from bar'
@@ -152,18 +152,18 @@ class TestGrouping(TestCaseBase):
     def test_comparsion_exclude(self):
         # make sure operators are not handled too lazy
         p = sqlparse.parse('(=)')[0]
-        self.assert_(isinstance(p.tokens[0], Parenthesis))
-        self.assert_(not isinstance(p.tokens[0].tokens[1], Comparsion))
+        self.assert_(isinstance(p.tokens[0], sql.Parenthesis))
+        self.assert_(not isinstance(p.tokens[0].tokens[1], sql.Comparsion))
         p = sqlparse.parse('(a=1)')[0]
-        self.assert_(isinstance(p.tokens[0].tokens[1], Comparsion))
+        self.assert_(isinstance(p.tokens[0].tokens[1], sql.Comparsion))
         p = sqlparse.parse('(a>=1)')[0]
-        self.assert_(isinstance(p.tokens[0].tokens[1], Comparsion))
+        self.assert_(isinstance(p.tokens[0].tokens[1], sql.Comparsion))
 
     def test_function(self):
         p = sqlparse.parse('foo()')[0]
-        self.assert_(isinstance(p.tokens[0], Function))
+        self.assert_(isinstance(p.tokens[0], sql.Function))
         p = sqlparse.parse('foo(null, bar)')[0]
-        self.assert_(isinstance(p.tokens[0], Function))
+        self.assert_(isinstance(p.tokens[0], sql.Function))
         self.assertEqual(len(p.tokens[0].get_parameters()), 2)