def parse(self, sql, encoding): stream = lexer.tokenize(sql, encoding) statements = _split_statements(stream) default_stack = engine.FilterStack() default_stack.enable_grouping() create_table_statement_filter_stack = engine.FilterStack( stmtprocess=[filters.MysqlCreateStatementFilter()], grouping_funcs=[grouping.group_brackets] ) create_table_statement_filter_stack.enable_grouping() for statement in statements: if _is_create_table_statement(statement): yield create_table_statement_filter_stack.run(statement) else: yield default_stack.run(statement)
def parse(self, sql, encoding): stream = lexer.tokenize(sql, encoding) statements = _split_statements(stream) stack = engine.FilterStack() stack.enable_grouping() for statement in statements: yield stack.run(statement)
def split(sql): """Split *sql* into single statements. Returns a list of strings. """ stack = engine.FilterStack() stack.split_statements = True return [unicode(stmt) for stmt in stack.run(sql)]
def parsestream(stream): """Parses sql statements from file-like object. Returns a generator of Statement instances. """ stack = engine.FilterStack() stack.full_analyze() return stack.run(stream)
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)]
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.full_analyze() return stack.run(stream, encoding)
def parse(sql): """Parse sql and return a list of statements. *sql* is a single string containting one or more SQL statements. Returns a tuple of :class:`~sqlparse.sql.Statement` instances. """ stack = engine.FilterStack() stack.full_analyze() return tuple(stack.run(sql))
def sqlparse_format(sql, encoding=None, **options): from sqlparse import engine, formatter, filters, lexer options = formatter.validate_options(options) stack = engine.FilterStack() stack = formatter.build_filter_stack(stack, options) stack.postprocess.append(filters.SerializerUnicode()) stack.preprocess.append(ZColorFilter()) parsed = stack.run(sql, encoding) result = ''.join(parsed) return result
def format(sql, **options): """Format *sql* according to *options*. Available options are documented in :ref:`formatting`. 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 ''.join(stack.run(sql))
def parsestream(stream, encoding=None, **options): """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() options = formatter.validate_options(options) stack = formatter.build_filter_stack(stack, options) return stack.run(stream, encoding)
def parsestream(stream, encoding=None, **options): """Parses sql statements from file-like object. :param stream: A file-like object. :param encoding: The encoding of the stream contents. :param options: The options to parse with. (optional). Available options are documented in :ref:`parsing`. :returns: A generator of :class:`~sqlparse.sql.Statement` instances. """ stack = engine.FilterStack() stack.enable_grouping() return stack.run(stream, encoding, **options)
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 format_sql(statement, prefix_length=0): width, height = getTerminalSize() stack = engine.FilterStack() stack.enable_grouping() stack.stmtprocess.append(filters.StripWhitespaceFilter()) stack.stmtprocess.append(MyReindentFilter(width - 30)) stack.postprocess.append(filters.SerializerUnicode()) statement = ''.join(stack.run(statement)) lines = statement.split('\n') new_lines = [lines[0]] for line in lines[1:]: new_lines.append(' ' * prefix_length + line) statement = '\n'.join(new_lines) return statement
def __init__(self, a_sql_text=""): self.sql_statements = [] self.x_statements = [] self.sql_text = a_sql_text self.func_group_orig = x_grouping.grouping.group x_grouping.grouping.group = x_grouping.group self.engine_parser_sql = engine.FilterStack() self.engine_parser_sql.enable_grouping() self.sql_statements = tuple(self.engine_parser_sql.run(self.sql_text)) # Asigna statements_clas sin Tokens inutiles (newline, space) y clasificados por tipo for stmnt in self.sql_statements: a_new_x_stmnt = xStatementSql(stmnt) if a_new_x_stmnt is not None: self.x_statements.append(a_new_x_stmnt)
def format(sql, **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. """ options = formatter.validate_options(options) encoding = options.pop('encoding', None) stream = lexer.tokenize(sql, encoding) stream = _format_pre_process(stream, options) stack = engine.FilterStack() stack = formatter.build_filter_stack(stack, options) stack.postprocess.append(filters.SerializerUnicode()) statements = split2(stream) return ''.join(stack.run(statement) for statement in statements)
def parse(query): stack = engine.FilterStack() stack.preprocess.append(ValueFilter()) stack.postprocess.append(filters.SerializerUnicode()) return ''.join(stack.run(query))