FilesExpand file tree

 master

/

__init__.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

72 lines (54 loc) · 2.2 KB

 master

/

__init__.py

Copy path

Top

File metadata and controls

• Code
• Blame

72 lines (54 loc) · 2.2 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

# -*- coding: utf-8 -*-

#

# Copyright (C) 2009-2018 the sqlparse authors and contributors

# <see AUTHORS file>

#

# This module is part of python-sqlparse and is released under

# the BSD License: https://opensource.org/licenses/BSD-3-Clause

"""Parse SQL statements."""

# Setup namespace

from sqlparse import sql

from sqlparse import cli

from sqlparse import engine

from sqlparse import tokens

from sqlparse import filters

from sqlparse import formatter

from sqlparse.compat import text_type

__version__ = '0.3.1.dev0'

__all__ = ['engine', 'filters', 'formatter', 'sql', 'tokens', 'cli']

def parse(sql, encoding=None):

"""Parse sql and return a list of statements.

:param sql: A string containing one or more SQL statements.

:param encoding: The encoding of the statement (optional).

:returns: A tuple of :class:`~sqlparse.sql.Statement` instances.

"""

return tuple(parsestream(sql, encoding))

def parsestream(stream, encoding=None):

"""Parses sql statements from file-like object.

:param stream: A file-like object.

:param encoding: The encoding of the stream contents (optional).

:returns: A generator of :class:`~sqlparse.sql.Statement` instances.

"""

stack = engine.FilterStack()

stack.enable_grouping()

return stack.run(stream, encoding)

def format(sql, encoding=None, **options):

"""Format *sql* according to *options*.

Available options are documented in :ref:`formatting`.

In addition to the formatting options this function accepts the

keyword "encoding" which determines the encoding of the statement.

:returns: The formatted SQL statement as string.

"""

stack = engine.FilterStack()

options = formatter.validate_options(options)

stack = formatter.build_filter_stack(stack, options)

stack.postprocess.append(filters.SerializerUnicode())

return u''.join(stack.run(sql, encoding))

def split(sql, encoding=None):

"""Split *sql* into single statements.

:param sql: A string containing one or more SQL statements.

:param encoding: The encoding of the statement (optional).

:returns: A list of strings.

"""

stack = engine.FilterStack()

return [text_type(stmt).strip() for stmt in stack.run(sql, encoding)]