def test_identifiers(self):
        s = 'select foo.bar from "myscheme"."table" where fail. order'
        parsed = sqlparse.parse(s)[0]
        self.ndiffAssertEqual(s, unicode(parsed))
        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, unicode(parsed))
        self.assert_(isinstance(parsed.tokens[-1].tokens[-1].tokens[0],
                                sql.Identifier))
        s = 'select * from (select "foo"."id" from foo)'
        parsed = sqlparse.parse(s)[0]
        self.ndiffAssertEqual(s, unicode(parsed))
        self.assert_(isinstance(parsed.tokens[-1].tokens[3], sql.Identifier))

        s = "INSERT INTO `test` VALUES('foo', 'bar');"
        parsed = sqlparse.parse(s)[0]
        types = [l.ttype for l in parsed.tokens if not l.is_whitespace()]
        self.assertEquals(types, [T.DML, T.Keyword, None,
                                  T.Keyword, None, T.Punctuation])

        s = "select 1.0*(a+b) as col, sum(c)/sum(d) from myschema.mytable"
        parsed = sqlparse.parse(s)[0]
        self.assertEqual(len(parsed.tokens), 7)
        self.assert_(isinstance(parsed.tokens[2], sql.IdentifierList))
        self.assertEqual(len(parsed.tokens[2].tokens), 4)
        identifiers = list(parsed.tokens[2].get_identifiers())
        self.assertEqual(len(identifiers), 2)
        self.assertEquals(identifiers[0].get_alias(), u"col")

def test_parse_join():
    p = sqlparse.parse('LEFT JOIN foo')[0]
    assert len(p.tokens) == 3
    assert p.tokens[0].ttype is Keyword
    p = sqlparse.parse('LEFT  OUTER  JOIN foo')[0]
    assert len(p.tokens) == 3
    assert p.tokens[0].ttype is Keyword

    def get_completions(self, document):

        word_before_cursor = document.get_word_before_cursor(WORD=True)

        if not self.smart_completion:
            return self.find_matches(word_before_cursor, self.all_completions)

        # If we've partially typed a word then word_before_cursor won't be an
        # empty string. In that case we want to remove the partially typed
        # string before sending it to the sqlparser. Otherwise the last token
        # will always be the partially typed string which renders the smart
        # completion useless because it will always return the list of keywords
        # as completion.

        if word_before_cursor:
            parsed = sqlparse.parse(document.text[:-len(word_before_cursor)])
        else:
            parsed = sqlparse.parse(document.text)

        last_token = ''
        if parsed:
            last_token = parsed[0].token_prev(len(parsed[0].tokens))
            last_token = last_token.value if last_token else ''

        if last_token.lower() in ('select', 'where', 'having', 'set',
                'order by', 'group by'):
            return self.find_matches(word_before_cursor, self.column_names)
        elif last_token.lower() in ('from', 'update', 'into'):
            return self.find_matches(word_before_cursor, self.table_names)
        else:
            return self.find_matches(word_before_cursor,
                    self.keywords + self.special_commands)

 def test_identifier_function(self):
     p = sqlparse.parse('foo() as bar')[0]
     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], sql.Identifier))
     self.assert_(isinstance(p.tokens[0].tokens[0], sql.Function))

 def test_identifier_extended(self):  # issue 15
     p = sqlparse.parse('foo+100')[0]
     self.assert_(isinstance(p.tokens[0], sql.Identifier))
     p = sqlparse.parse('foo + 100')[0]
     self.assert_(isinstance(p.tokens[0], sql.Identifier))
     p = sqlparse.parse('foo*100')[0]
     self.assert_(isinstance(p.tokens[0], sql.Identifier))

    def __init__(self, full_text, text_before_cursor):
        self.identifier = None
        self.word_before_cursor = word_before_cursor = last_word(
            text_before_cursor, include='many_punctuations')
        full_text = _strip_named_query(full_text)
        text_before_cursor = _strip_named_query(text_before_cursor)
        self.text_before_cursor_including_last_word = text_before_cursor

        # If we've partially typed a word then word_before_cursor won't be an
        # empty string. In that case we want to remove the partially typed
        # string before sending it to the sqlparser. Otherwise the last token
        # will always be the partially typed string which renders the smart
        # completion useless because it will always return the list of
        # keywords as completion.
        if self.word_before_cursor:
            if word_before_cursor[-1] == '(' or word_before_cursor[0] == '\\':
                parsed = sqlparse.parse(text_before_cursor)
            else:
                text_before_cursor = text_before_cursor[:-len(word_before_cursor)]
                parsed = sqlparse.parse(text_before_cursor)
                self.identifier = parse_partial_identifier(word_before_cursor)
        else:
            parsed = sqlparse.parse(text_before_cursor)

        full_text, text_before_cursor, parsed = \
            _split_multiple_statements(full_text, text_before_cursor, parsed)

        self.full_text = full_text
        self.text_before_cursor = text_before_cursor
        self.parsed = parsed

        self.last_token = parsed and parsed.token_prev(len(parsed.tokens)) or ''

def test_parse_child_of():
    s = "(col1, col2)"
    p = sqlparse.parse(s)[0]
    assert p.tokens[0].tokens[1].is_child_of(p.tokens[0])
    s = "select foo"
    p = sqlparse.parse(s)[0]
    assert not p.tokens[2].is_child_of(p.tokens[0])
    assert p.tokens[2].is_child_of(p)

def test_qualified_function():
    p = sqlparse.parse('foo()')[0].tokens[0]
    assert p.get_parent_name() is None
    assert p.get_real_name() == 'foo'

    p = sqlparse.parse('foo.bar()')[0].tokens[0]
    assert p.get_parent_name() == 'foo'
    assert p.get_real_name() == 'bar'

 def test_child_of(self):
     sql = '(col1, col2)'
     p = sqlparse.parse(sql)[0]
     self.assert_(p.tokens[0].tokens[1].is_child_of(p.tokens[0]))
     sql = 'select foo'
     p = sqlparse.parse(sql)[0]
     self.assert_(not p.tokens[2].is_child_of(p.tokens[0]))
     self.assert_(p.tokens[2].is_child_of(p))

def test_identifier_with_operators():  # issue 53
    p = sqlparse.parse('foo||bar')[0]
    assert len(p.tokens) == 1
    assert isinstance(p.tokens[0], sql.Identifier)
    # again with whitespaces
    p = sqlparse.parse('foo || bar')[0]
    assert len(p.tokens) == 1
    assert isinstance(p.tokens[0], sql.Identifier)

 def test_dashcomments_eol(self):
     stmts = sqlparse.parse('select foo; -- comment\n')
     self.assertEqual(len(stmts), 1)
     stmts = sqlparse.parse('select foo; -- comment\r')
     self.assertEqual(len(stmts), 1)
     stmts = sqlparse.parse('select foo; -- comment\r\n')
     self.assertEqual(len(stmts), 1)
     stmts = sqlparse.parse('select foo; -- comment')
     self.assertEqual(len(stmts), 1)

 def test_assignment(self):
     s = 'foo := 1;'
     parsed = sqlparse.parse(s)[0]
     self.assertEqual(len(parsed.tokens), 1)
     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], sql.Assignment))

 def test_comparison_exclude(self):
     # make sure operators are not handled too lazy
     p = sqlparse.parse('(=)')[0]
     self.assert_(isinstance(p.tokens[0], sql.Parenthesis))
     self.assert_(not isinstance(p.tokens[0].tokens[1], sql.Comparison))
     p = sqlparse.parse('(a=1)')[0]
     self.assert_(isinstance(p.tokens[0].tokens[1], sql.Comparison))
     p = sqlparse.parse('(a>=1)')[0]
     self.assert_(isinstance(p.tokens[0].tokens[1], sql.Comparison))

 def test_where(self):
     s = 'select * from foo where bar = 1 order by id desc'
     p = sqlparse.parse(s)[0]
     self.ndiffAssertEqual(s, unicode(p))
     self.assertTrue(len(p.tokens), 16)
     s = 'select x from (select y from foo where bar = 1) z'
     p = sqlparse.parse(s)[0]
     self.ndiffAssertEqual(s, unicode(p))
     self.assertTrue(isinstance(p.tokens[-1].tokens[0].tokens[-2], sql.Where))

 def test_contains_subquery(self):
     query = ("select * from (select * from repo.table where "
              "repo.table.test = 'True')")
     subquery_token = sqlparse.parse(query)[0].tokens[6]
     no_subquery_token = sqlparse.parse(query)[0].tokens[0]
     self.assertEqual(
         self.query_rewriter.contains_subquery(subquery_token), True)
     self.assertEqual(
         self.query_rewriter.contains_subquery(no_subquery_token), False)

    def test_ok_not_count(self):
        with self.patch_schema({}):
            sql = "SELECT * FROM a ORDER BY id DESC"
            stmt = sqlparse.parse(sql)[0]
            assert False == self.has_order_by_count(stmt)

            sql = "SELECT a, b, count FROM a ORDER BY id DESC"
            stmt = sqlparse.parse(sql)[0]
            assert False == self.has_order_by_count(stmt)

def test_wildcard_multiplication():
    p = sqlparse.parse("select * from dual")[0]
    assert p.tokens[2].ttype == T.Wildcard

    p = sqlparse.parse("select a0.* from dual a0")[0]
    assert p.tokens[2][2].ttype == T.Wildcard

    p = sqlparse.parse("select 1 * 2 from dual")[0]
    assert p.tokens[2][2].ttype == T.Operator

def test_aliased_column_without_as():
    p = sqlparse.parse('foo bar')[0].tokens
    assert len(p) == 1
    assert p[0].get_real_name() == 'foo'
    assert p[0].get_alias() == 'bar'

    p = sqlparse.parse('foo.bar baz')[0].tokens[0]
    assert p.get_parent_name() == 'foo'
    assert p.get_real_name() == 'bar'
    assert p.get_alias() == 'baz'

def test_token_str_pos():
    sql = 'SELECT * FROM xxx'
    p = parse(sql)[0]
    idx = p.token_index(p.tokens[-1])
    assert token_start_pos(p.tokens, idx) == len('SELECT * FROM ')

    sql = 'SELECT * FROM \nxxx'
    p = parse(sql)[0]
    idx = p.token_index(p.tokens[-1])
    assert token_start_pos(p.tokens, idx) == len('SELECT * FROM \n')

def test_grouping_typecast():
    s = 'select foo::integer from bar'
    p = sqlparse.parse(s)[0]
    assert str(p) == s
    assert p.tokens[2].get_typecast() == 'integer'
    assert p.tokens[2].get_name() == 'foo'
    s = 'select (current_database())::information_schema.sql_identifier'
    p = sqlparse.parse(s)[0]
    assert str(p) == s
    assert (p.tokens[2].get_typecast() == 'information_schema.sql_identifier')