FilesExpand file tree

 master

/

utils.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

123 lines (101 loc) · 3.43 KB

 master

/

utils.py

Copy path

Top

File metadata and controls

• Code
• Blame

123 lines (101 loc) · 3.43 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

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

# -*- 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

import itertools

import re

from collections import deque

from contextlib import contextmanager

from sqlparse.compat import text_type

# This regular expression replaces the home-cooked parser that was here before.

# It is much faster, but requires an extra post-processing step to get the

# desired results (that are compatible with what you would expect from the

# str.splitlines() method).

#

# It matches groups of characters: newlines, quoted strings, or unquoted text,

# and splits on that basis. The post-processing step puts those back together

# into the actual lines of SQL.

SPLIT_REGEX = re.compile(r"""

(

(?: # Start of non-capturing group

(?:\r\n|\r|\n) | # Match any single newline, or

[^\r\n'"]+ | # Match any character series without quotes or

# newlines, or

"(?:[^"\\]|\\.)*" | # Match double-quoted strings, or

'(?:[^'\\]|\\.)*' # Match single quoted strings

)

)

""", re.VERBOSE)

LINE_MATCH = re.compile(r'(\r\n|\r|\n)')

def split_unquoted_newlines(stmt):

"""Split a string on all unquoted newlines.

Unlike str.splitlines(), this will ignore CR/LF/CR+LF if the requisite

character is inside of a string."""

text = text_type(stmt)

lines = SPLIT_REGEX.split(text)

outputlines = ['']

for line in lines:

if not line:

continue

elif LINE_MATCH.match(line):

outputlines.append('')

else:

outputlines[-1] += line

return outputlines

def remove_quotes(val):

"""Helper that removes surrounding quotes from strings."""

if val is None:

return

if val[0] in ('"', "'") and val[0] == val[-1]:

val = val[1:-1]

return val

def recurse(*cls):

"""Function decorator to help with recursion

:param cls: Classes to not recurse over

:return: function

"""

def wrap(f):

def wrapped_f(tlist):

for sgroup in tlist.get_sublists():

if not isinstance(sgroup, cls):

wrapped_f(sgroup)

f(tlist)

return wrapped_f

return wrap

def imt(token, i=None, m=None, t=None):

"""Helper function to simplify comparisons Instance, Match and TokenType

:param token:

:param i: Class or Tuple/List of Classes

:param m: Tuple of TokenType & Value. Can be list of Tuple for multiple

:param t: TokenType or Tuple/List of TokenTypes

:return: bool

"""

clss = i

types = [t, ] if t and not isinstance(t, list) else t

mpatterns = [m, ] if m and not isinstance(m, list) else m

if token is None:

return False

elif clss and isinstance(token, clss):

return True

elif mpatterns and any(token.match(*pattern) for pattern in mpatterns):

return True

elif types and any(token.ttype in ttype for ttype in types):

return True

else:

return False

def consume(iterator, n):

"""Advance the iterator n-steps ahead. If n is none, consume entirely."""

deque(itertools.islice(iterator, n), maxlen=0)

@contextmanager

def offset(filter_, n=0):

filter_.offset += n

yield

filter_.offset -= n

@contextmanager

def indent(filter_, n=1):

filter_.indent += n

yield

filter_.indent -= n