559 lines
23 KiB
Python
559 lines
23 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
pygments.lexers.sql
|
|
~~~~~~~~~~~~~~~~~~~
|
|
|
|
Lexers for various SQL dialects and related interactive sessions.
|
|
|
|
Postgres specific lexers:
|
|
|
|
`PostgresLexer`
|
|
A SQL lexer for the PostgreSQL dialect. Differences w.r.t. the SQL
|
|
lexer are:
|
|
|
|
- keywords and data types list parsed from the PG docs (run the
|
|
`_postgres_builtins` module to update them);
|
|
- Content of $-strings parsed using a specific lexer, e.g. the content
|
|
of a PL/Python function is parsed using the Python lexer;
|
|
- parse PG specific constructs: E-strings, $-strings, U&-strings,
|
|
different operators and punctuation.
|
|
|
|
`PlPgsqlLexer`
|
|
A lexer for the PL/pgSQL language. Adds a few specific construct on
|
|
top of the PG SQL lexer (such as <<label>>).
|
|
|
|
`PostgresConsoleLexer`
|
|
A lexer to highlight an interactive psql session:
|
|
|
|
- identifies the prompt and does its best to detect the end of command
|
|
in multiline statement where not all the lines are prefixed by a
|
|
prompt, telling them apart from the output;
|
|
- highlights errors in the output and notification levels;
|
|
- handles psql backslash commands.
|
|
|
|
The ``tests/examplefiles`` contains a few test files with data to be
|
|
parsed by these lexers.
|
|
|
|
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
|
|
:license: BSD, see LICENSE for details.
|
|
"""
|
|
|
|
import re
|
|
|
|
from pygments.lexer import Lexer, RegexLexer, do_insertions, bygroups
|
|
from pygments.token import Punctuation, \
|
|
Text, Comment, Operator, Keyword, Name, String, Number, Generic
|
|
from pygments.lexers import get_lexer_by_name, ClassNotFound
|
|
|
|
from pygments.lexers._postgres_builtins import KEYWORDS, DATATYPES, \
|
|
PSEUDO_TYPES, PLPGSQL_KEYWORDS
|
|
|
|
|
|
__all__ = ['PostgresLexer', 'PlPgsqlLexer', 'PostgresConsoleLexer',
|
|
'SqlLexer', 'MySqlLexer', 'SqliteConsoleLexer']
|
|
|
|
line_re = re.compile('.*?\n')
|
|
|
|
language_re = re.compile(r"\s+LANGUAGE\s+'?(\w+)'?", re.IGNORECASE)
|
|
|
|
def language_callback(lexer, match):
|
|
"""Parse the content of a $-string using a lexer
|
|
|
|
The lexer is chosen looking for a nearby LANGUAGE.
|
|
"""
|
|
l = None
|
|
m = language_re.match(lexer.text[match.end():match.end()+100])
|
|
if m is not None:
|
|
l = lexer._get_lexer(m.group(1))
|
|
else:
|
|
m = list(language_re.finditer(
|
|
lexer.text[max(0, match.start()-100):match.start()]))
|
|
if m:
|
|
l = lexer._get_lexer(m[-1].group(1))
|
|
|
|
if l:
|
|
yield (match.start(1), String, match.group(1))
|
|
for x in l.get_tokens_unprocessed(match.group(2)):
|
|
yield x
|
|
yield (match.start(3), String, match.group(3))
|
|
|
|
else:
|
|
yield (match.start(), String, match.group())
|
|
|
|
|
|
class PostgresBase(object):
|
|
"""Base class for Postgres-related lexers.
|
|
|
|
This is implemented as a mixin to avoid the Lexer metaclass kicking in.
|
|
this way the different lexer don't have a common Lexer ancestor. If they
|
|
had, _tokens could be created on this ancestor and not updated for the
|
|
other classes, resulting e.g. in PL/pgSQL parsed as SQL. This shortcoming
|
|
seem to suggest that regexp lexers are not really subclassable.
|
|
"""
|
|
def get_tokens_unprocessed(self, text, *args):
|
|
# Have a copy of the entire text to be used by `language_callback`.
|
|
self.text = text
|
|
for x in super(PostgresBase, self).get_tokens_unprocessed(
|
|
text, *args):
|
|
yield x
|
|
|
|
def _get_lexer(self, lang):
|
|
if lang.lower() == 'sql':
|
|
return get_lexer_by_name('postgresql', **self.options)
|
|
|
|
tries = [ lang ]
|
|
if lang.startswith('pl'):
|
|
tries.append(lang[2:])
|
|
if lang.endswith('u'):
|
|
tries.append(lang[:-1])
|
|
if lang.startswith('pl') and lang.endswith('u'):
|
|
tries.append(lang[2:-1])
|
|
|
|
for l in tries:
|
|
try:
|
|
return get_lexer_by_name(l, **self.options)
|
|
except ClassNotFound:
|
|
pass
|
|
else:
|
|
# TODO: better logging
|
|
# print >>sys.stderr, "language not found:", lang
|
|
return None
|
|
|
|
|
|
class PostgresLexer(PostgresBase, RegexLexer):
|
|
"""
|
|
Lexer for the PostgreSQL dialect of SQL.
|
|
|
|
*New in Pygments 1.5.*
|
|
"""
|
|
|
|
name = 'PostgreSQL SQL dialect'
|
|
aliases = ['postgresql', 'postgres']
|
|
mimetypes = ['text/x-postgresql']
|
|
|
|
flags = re.IGNORECASE
|
|
tokens = {
|
|
'root': [
|
|
(r'\s+', Text),
|
|
(r'--.*?\n', Comment.Single),
|
|
(r'/\*', Comment.Multiline, 'multiline-comments'),
|
|
(r'(' + '|'.join([s.replace(" ", "\s+")
|
|
for s in DATATYPES + PSEUDO_TYPES])
|
|
+ r')\b', Name.Builtin),
|
|
(r'(' + '|'.join(KEYWORDS) + r')\b', Keyword),
|
|
(r'[+*/<>=~!@#%^&|`?-]+', Operator),
|
|
(r'::', Operator), # cast
|
|
(r'\$\d+', Name.Variable),
|
|
(r'([0-9]*\.[0-9]*|[0-9]+)(e[+-]?[0-9]+)?', Number.Float),
|
|
(r'[0-9]+', Number.Integer),
|
|
(r"(E|U&)?'(''|[^'])*'", String.Single),
|
|
(r'(U&)?"(""|[^"])*"', String.Name), # quoted identifier
|
|
(r'(?s)(\$[^\$]*\$)(.*?)(\1)', language_callback),
|
|
(r'[a-zA-Z_][a-zA-Z0-9_]*', Name),
|
|
|
|
# psql variable in SQL
|
|
(r""":(['"]?)[a-z][a-z0-9_]*\b\1""", Name.Variable),
|
|
|
|
(r'[;:()\[\]\{\},\.]', Punctuation),
|
|
],
|
|
'multiline-comments': [
|
|
(r'/\*', Comment.Multiline, 'multiline-comments'),
|
|
(r'\*/', Comment.Multiline, '#pop'),
|
|
(r'[^/\*]+', Comment.Multiline),
|
|
(r'[/*]', Comment.Multiline)
|
|
],
|
|
}
|
|
|
|
|
|
class PlPgsqlLexer(PostgresBase, RegexLexer):
|
|
"""
|
|
Handle the extra syntax in Pl/pgSQL language.
|
|
|
|
*New in Pygments 1.5.*
|
|
"""
|
|
name = 'PL/pgSQL'
|
|
aliases = ['plpgsql']
|
|
mimetypes = ['text/x-plpgsql']
|
|
|
|
flags = re.IGNORECASE
|
|
tokens = dict((k, l[:]) for (k, l) in PostgresLexer.tokens.iteritems())
|
|
|
|
# extend the keywords list
|
|
for i, pattern in enumerate(tokens['root']):
|
|
if pattern[1] == Keyword:
|
|
tokens['root'][i] = (
|
|
r'(' + '|'.join(KEYWORDS + PLPGSQL_KEYWORDS) + r')\b',
|
|
Keyword)
|
|
del i
|
|
break
|
|
else:
|
|
assert 0, "SQL keywords not found"
|
|
|
|
# Add specific PL/pgSQL rules (before the SQL ones)
|
|
tokens['root'][:0] = [
|
|
(r'\%[a-z][a-z0-9_]*\b', Name.Builtin), # actually, a datatype
|
|
(r':=', Operator),
|
|
(r'\<\<[a-z][a-z0-9_]*\>\>', Name.Label),
|
|
(r'\#[a-z][a-z0-9_]*\b', Keyword.Pseudo), # #variable_conflict
|
|
]
|
|
|
|
|
|
class PsqlRegexLexer(PostgresBase, RegexLexer):
|
|
"""
|
|
Extend the PostgresLexer adding support specific for psql commands.
|
|
|
|
This is not a complete psql lexer yet as it lacks prompt support
|
|
and output rendering.
|
|
"""
|
|
|
|
name = 'PostgreSQL console - regexp based lexer'
|
|
aliases = [] # not public
|
|
|
|
flags = re.IGNORECASE
|
|
tokens = dict((k, l[:]) for (k, l) in PostgresLexer.tokens.iteritems())
|
|
|
|
tokens['root'].append(
|
|
(r'\\[^\s]+', Keyword.Pseudo, 'psql-command'))
|
|
tokens['psql-command'] = [
|
|
(r'\n', Text, 'root'),
|
|
(r'\s+', Text),
|
|
(r'\\[^\s]+', Keyword.Pseudo),
|
|
(r""":(['"]?)[a-z][a-z0-9_]*\b\1""", Name.Variable),
|
|
(r"'(''|[^'])*'", String.Single),
|
|
(r"`([^`])*`", String.Backtick),
|
|
(r"[^\s]+", String.Symbol),
|
|
]
|
|
|
|
re_prompt = re.compile(r'^(\S.*?)??[=\-\(\$\'\"][#>]')
|
|
re_psql_command = re.compile(r'\s*\\')
|
|
re_end_command = re.compile(r';\s*(--.*?)?$')
|
|
re_psql_command = re.compile(r'(\s*)(\\.+?)(\s+)$')
|
|
re_error = re.compile(r'(ERROR|FATAL):')
|
|
re_message = re.compile(
|
|
r'((?:DEBUG|INFO|NOTICE|WARNING|ERROR|'
|
|
r'FATAL|HINT|DETAIL|CONTEXT|LINE [0-9]+):)(.*?\n)')
|
|
|
|
|
|
class lookahead(object):
|
|
"""Wrap an iterator and allow pushing back an item."""
|
|
def __init__(self, x):
|
|
self.iter = iter(x)
|
|
self._nextitem = None
|
|
def __iter__(self):
|
|
return self
|
|
def send(self, i):
|
|
self._nextitem = i
|
|
return i
|
|
def next(self):
|
|
if self._nextitem is not None:
|
|
ni = self._nextitem
|
|
self._nextitem = None
|
|
return ni
|
|
return self.iter.next()
|
|
|
|
|
|
class PostgresConsoleLexer(Lexer):
|
|
"""
|
|
Lexer for psql sessions.
|
|
|
|
*New in Pygments 1.5.*
|
|
"""
|
|
|
|
name = 'PostgreSQL console (psql)'
|
|
aliases = ['psql', 'postgresql-console', 'postgres-console']
|
|
mimetypes = ['text/x-postgresql-psql']
|
|
|
|
def get_tokens_unprocessed(self, data):
|
|
sql = PsqlRegexLexer(**self.options)
|
|
|
|
lines = lookahead(line_re.findall(data))
|
|
|
|
# prompt-output cycle
|
|
while 1:
|
|
|
|
# consume the lines of the command: start with an optional prompt
|
|
# and continue until the end of command is detected
|
|
curcode = ''
|
|
insertions = []
|
|
while 1:
|
|
try:
|
|
line = lines.next()
|
|
except StopIteration:
|
|
# allow the emission of partially collected items
|
|
# the repl loop will be broken below
|
|
break
|
|
|
|
# Identify a shell prompt in case of psql commandline example
|
|
if line.startswith('$') and not curcode:
|
|
lexer = get_lexer_by_name('console', **self.options)
|
|
for x in lexer.get_tokens_unprocessed(line):
|
|
yield x
|
|
break
|
|
|
|
# Identify a psql prompt
|
|
mprompt = re_prompt.match(line)
|
|
if mprompt is not None:
|
|
insertions.append((len(curcode),
|
|
[(0, Generic.Prompt, mprompt.group())]))
|
|
curcode += line[len(mprompt.group()):]
|
|
else:
|
|
curcode += line
|
|
|
|
# Check if this is the end of the command
|
|
# TODO: better handle multiline comments at the end with
|
|
# a lexer with an external state?
|
|
if re_psql_command.match(curcode) \
|
|
or re_end_command.search(curcode):
|
|
break
|
|
|
|
# Emit the combined stream of command and prompt(s)
|
|
for item in do_insertions(insertions,
|
|
sql.get_tokens_unprocessed(curcode)):
|
|
yield item
|
|
|
|
# Emit the output lines
|
|
out_token = Generic.Output
|
|
while 1:
|
|
line = lines.next()
|
|
mprompt = re_prompt.match(line)
|
|
if mprompt is not None:
|
|
# push the line back to have it processed by the prompt
|
|
lines.send(line)
|
|
break
|
|
|
|
mmsg = re_message.match(line)
|
|
if mmsg is not None:
|
|
if mmsg.group(1).startswith("ERROR") \
|
|
or mmsg.group(1).startswith("FATAL"):
|
|
out_token = Generic.Error
|
|
yield (mmsg.start(1), Generic.Strong, mmsg.group(1))
|
|
yield (mmsg.start(2), out_token, mmsg.group(2))
|
|
else:
|
|
yield (0, out_token, line)
|
|
|
|
|
|
class SqlLexer(RegexLexer):
|
|
"""
|
|
Lexer for Structured Query Language. Currently, this lexer does
|
|
not recognize any special syntax except ANSI SQL.
|
|
"""
|
|
|
|
name = 'SQL'
|
|
aliases = ['sql']
|
|
filenames = ['*.sql']
|
|
mimetypes = ['text/x-sql']
|
|
|
|
flags = re.IGNORECASE
|
|
tokens = {
|
|
'root': [
|
|
(r'\s+', Text),
|
|
(r'--.*?\n', Comment.Single),
|
|
(r'/\*', Comment.Multiline, 'multiline-comments'),
|
|
(r'(ABORT|ABS|ABSOLUTE|ACCESS|ADA|ADD|ADMIN|AFTER|AGGREGATE|'
|
|
r'ALIAS|ALL|ALLOCATE|ALTER|ANALYSE|ANALYZE|AND|ANY|ARE|AS|'
|
|
r'ASC|ASENSITIVE|ASSERTION|ASSIGNMENT|ASYMMETRIC|AT|ATOMIC|'
|
|
r'AUTHORIZATION|AVG|BACKWARD|BEFORE|BEGIN|BETWEEN|BITVAR|'
|
|
r'BIT_LENGTH|BOTH|BREADTH|BY|C|CACHE|CALL|CALLED|CARDINALITY|'
|
|
r'CASCADE|CASCADED|CASE|CAST|CATALOG|CATALOG_NAME|CHAIN|'
|
|
r'CHARACTERISTICS|CHARACTER_LENGTH|CHARACTER_SET_CATALOG|'
|
|
r'CHARACTER_SET_NAME|CHARACTER_SET_SCHEMA|CHAR_LENGTH|CHECK|'
|
|
r'CHECKED|CHECKPOINT|CLASS|CLASS_ORIGIN|CLOB|CLOSE|CLUSTER|'
|
|
r'COALSECE|COBOL|COLLATE|COLLATION|COLLATION_CATALOG|'
|
|
r'COLLATION_NAME|COLLATION_SCHEMA|COLUMN|COLUMN_NAME|'
|
|
r'COMMAND_FUNCTION|COMMAND_FUNCTION_CODE|COMMENT|COMMIT|'
|
|
r'COMMITTED|COMPLETION|CONDITION_NUMBER|CONNECT|CONNECTION|'
|
|
r'CONNECTION_NAME|CONSTRAINT|CONSTRAINTS|CONSTRAINT_CATALOG|'
|
|
r'CONSTRAINT_NAME|CONSTRAINT_SCHEMA|CONSTRUCTOR|CONTAINS|'
|
|
r'CONTINUE|CONVERSION|CONVERT|COPY|CORRESPONTING|COUNT|'
|
|
r'CREATE|CREATEDB|CREATEUSER|CROSS|CUBE|CURRENT|CURRENT_DATE|'
|
|
r'CURRENT_PATH|CURRENT_ROLE|CURRENT_TIME|CURRENT_TIMESTAMP|'
|
|
r'CURRENT_USER|CURSOR|CURSOR_NAME|CYCLE|DATA|DATABASE|'
|
|
r'DATETIME_INTERVAL_CODE|DATETIME_INTERVAL_PRECISION|DAY|'
|
|
r'DEALLOCATE|DECLARE|DEFAULT|DEFAULTS|DEFERRABLE|DEFERRED|'
|
|
r'DEFINED|DEFINER|DELETE|DELIMITER|DELIMITERS|DEREF|DESC|'
|
|
r'DESCRIBE|DESCRIPTOR|DESTROY|DESTRUCTOR|DETERMINISTIC|'
|
|
r'DIAGNOSTICS|DICTIONARY|DISCONNECT|DISPATCH|DISTINCT|DO|'
|
|
r'DOMAIN|DROP|DYNAMIC|DYNAMIC_FUNCTION|DYNAMIC_FUNCTION_CODE|'
|
|
r'EACH|ELSE|ENCODING|ENCRYPTED|END|END-EXEC|EQUALS|ESCAPE|EVERY|'
|
|
r'EXCEPTION|EXCEPT|EXCLUDING|EXCLUSIVE|EXEC|EXECUTE|EXISTING|'
|
|
r'EXISTS|EXPLAIN|EXTERNAL|EXTRACT|FALSE|FETCH|FINAL|FIRST|FOR|'
|
|
r'FORCE|FOREIGN|FORTRAN|FORWARD|FOUND|FREE|FREEZE|FROM|FULL|'
|
|
r'FUNCTION|G|GENERAL|GENERATED|GET|GLOBAL|GO|GOTO|GRANT|GRANTED|'
|
|
r'GROUP|GROUPING|HANDLER|HAVING|HIERARCHY|HOLD|HOST|IDENTITY|'
|
|
r'IGNORE|ILIKE|IMMEDIATE|IMMUTABLE|IMPLEMENTATION|IMPLICIT|IN|'
|
|
r'INCLUDING|INCREMENT|INDEX|INDITCATOR|INFIX|INHERITS|INITIALIZE|'
|
|
r'INITIALLY|INNER|INOUT|INPUT|INSENSITIVE|INSERT|INSTANTIABLE|'
|
|
r'INSTEAD|INTERSECT|INTO|INVOKER|IS|ISNULL|ISOLATION|ITERATE|JOIN|'
|
|
r'KEY|KEY_MEMBER|KEY_TYPE|LANCOMPILER|LANGUAGE|LARGE|LAST|'
|
|
r'LATERAL|LEADING|LEFT|LENGTH|LESS|LEVEL|LIKE|LIMIT|LISTEN|LOAD|'
|
|
r'LOCAL|LOCALTIME|LOCALTIMESTAMP|LOCATION|LOCATOR|LOCK|LOWER|'
|
|
r'MAP|MATCH|MAX|MAXVALUE|MESSAGE_LENGTH|MESSAGE_OCTET_LENGTH|'
|
|
r'MESSAGE_TEXT|METHOD|MIN|MINUTE|MINVALUE|MOD|MODE|MODIFIES|'
|
|
r'MODIFY|MONTH|MORE|MOVE|MUMPS|NAMES|NATIONAL|NATURAL|NCHAR|'
|
|
r'NCLOB|NEW|NEXT|NO|NOCREATEDB|NOCREATEUSER|NONE|NOT|NOTHING|'
|
|
r'NOTIFY|NOTNULL|NULL|NULLABLE|NULLIF|OBJECT|OCTET_LENGTH|OF|OFF|'
|
|
r'OFFSET|OIDS|OLD|ON|ONLY|OPEN|OPERATION|OPERATOR|OPTION|OPTIONS|'
|
|
r'OR|ORDER|ORDINALITY|OUT|OUTER|OUTPUT|OVERLAPS|OVERLAY|OVERRIDING|'
|
|
r'OWNER|PAD|PARAMETER|PARAMETERS|PARAMETER_MODE|PARAMATER_NAME|'
|
|
r'PARAMATER_ORDINAL_POSITION|PARAMETER_SPECIFIC_CATALOG|'
|
|
r'PARAMETER_SPECIFIC_NAME|PARAMATER_SPECIFIC_SCHEMA|PARTIAL|'
|
|
r'PASCAL|PENDANT|PLACING|PLI|POSITION|POSTFIX|PRECISION|PREFIX|'
|
|
r'PREORDER|PREPARE|PRESERVE|PRIMARY|PRIOR|PRIVILEGES|PROCEDURAL|'
|
|
r'PROCEDURE|PUBLIC|READ|READS|RECHECK|RECURSIVE|REF|REFERENCES|'
|
|
r'REFERENCING|REINDEX|RELATIVE|RENAME|REPEATABLE|REPLACE|RESET|'
|
|
r'RESTART|RESTRICT|RESULT|RETURN|RETURNED_LENGTH|'
|
|
r'RETURNED_OCTET_LENGTH|RETURNED_SQLSTATE|RETURNS|REVOKE|RIGHT|'
|
|
r'ROLE|ROLLBACK|ROLLUP|ROUTINE|ROUTINE_CATALOG|ROUTINE_NAME|'
|
|
r'ROUTINE_SCHEMA|ROW|ROWS|ROW_COUNT|RULE|SAVE_POINT|SCALE|SCHEMA|'
|
|
r'SCHEMA_NAME|SCOPE|SCROLL|SEARCH|SECOND|SECURITY|SELECT|SELF|'
|
|
r'SENSITIVE|SERIALIZABLE|SERVER_NAME|SESSION|SESSION_USER|SET|'
|
|
r'SETOF|SETS|SHARE|SHOW|SIMILAR|SIMPLE|SIZE|SOME|SOURCE|SPACE|'
|
|
r'SPECIFIC|SPECIFICTYPE|SPECIFIC_NAME|SQL|SQLCODE|SQLERROR|'
|
|
r'SQLEXCEPTION|SQLSTATE|SQLWARNINIG|STABLE|START|STATE|STATEMENT|'
|
|
r'STATIC|STATISTICS|STDIN|STDOUT|STORAGE|STRICT|STRUCTURE|STYPE|'
|
|
r'SUBCLASS_ORIGIN|SUBLIST|SUBSTRING|SUM|SYMMETRIC|SYSID|SYSTEM|'
|
|
r'SYSTEM_USER|TABLE|TABLE_NAME| TEMP|TEMPLATE|TEMPORARY|TERMINATE|'
|
|
r'THAN|THEN|TIMESTAMP|TIMEZONE_HOUR|TIMEZONE_MINUTE|TO|TOAST|'
|
|
r'TRAILING|TRANSATION|TRANSACTIONS_COMMITTED|'
|
|
r'TRANSACTIONS_ROLLED_BACK|TRANSATION_ACTIVE|TRANSFORM|'
|
|
r'TRANSFORMS|TRANSLATE|TRANSLATION|TREAT|TRIGGER|TRIGGER_CATALOG|'
|
|
r'TRIGGER_NAME|TRIGGER_SCHEMA|TRIM|TRUE|TRUNCATE|TRUSTED|TYPE|'
|
|
r'UNCOMMITTED|UNDER|UNENCRYPTED|UNION|UNIQUE|UNKNOWN|UNLISTEN|'
|
|
r'UNNAMED|UNNEST|UNTIL|UPDATE|UPPER|USAGE|USER|'
|
|
r'USER_DEFINED_TYPE_CATALOG|USER_DEFINED_TYPE_NAME|'
|
|
r'USER_DEFINED_TYPE_SCHEMA|USING|VACUUM|VALID|VALIDATOR|VALUES|'
|
|
r'VARIABLE|VERBOSE|VERSION|VIEW|VOLATILE|WHEN|WHENEVER|WHERE|'
|
|
r'WITH|WITHOUT|WORK|WRITE|YEAR|ZONE)\b', Keyword),
|
|
(r'(ARRAY|BIGINT|BINARY|BIT|BLOB|BOOLEAN|CHAR|CHARACTER|DATE|'
|
|
r'DEC|DECIMAL|FLOAT|INT|INTEGER|INTERVAL|NUMBER|NUMERIC|REAL|'
|
|
r'SERIAL|SMALLINT|VARCHAR|VARYING|INT8|SERIAL8|TEXT)\b',
|
|
Name.Builtin),
|
|
(r'[+*/<>=~!@#%^&|`?-]', Operator),
|
|
(r'[0-9]+', Number.Integer),
|
|
# TODO: Backslash escapes?
|
|
(r"'(''|[^'])*'", String.Single),
|
|
(r'"(""|[^"])*"', String.Symbol), # not a real string literal in ANSI SQL
|
|
(r'[a-zA-Z_][a-zA-Z0-9_]*', Name),
|
|
(r'[;:()\[\],\.]', Punctuation)
|
|
],
|
|
'multiline-comments': [
|
|
(r'/\*', Comment.Multiline, 'multiline-comments'),
|
|
(r'\*/', Comment.Multiline, '#pop'),
|
|
(r'[^/\*]+', Comment.Multiline),
|
|
(r'[/*]', Comment.Multiline)
|
|
]
|
|
}
|
|
|
|
|
|
class MySqlLexer(RegexLexer):
|
|
"""
|
|
Special lexer for MySQL.
|
|
"""
|
|
|
|
name = 'MySQL'
|
|
aliases = ['mysql']
|
|
mimetypes = ['text/x-mysql']
|
|
|
|
flags = re.IGNORECASE
|
|
tokens = {
|
|
'root': [
|
|
(r'\s+', Text),
|
|
(r'(#|--\s+).*?\n', Comment.Single),
|
|
(r'/\*', Comment.Multiline, 'multiline-comments'),
|
|
(r'[0-9]+', Number.Integer),
|
|
(r'[0-9]*\.[0-9]+(e[+-][0-9]+)', Number.Float),
|
|
# TODO: add backslash escapes
|
|
(r"'(''|[^'])*'", String.Single),
|
|
(r'"(""|[^"])*"', String.Double),
|
|
(r"`(``|[^`])*`", String.Symbol),
|
|
(r'[+*/<>=~!@#%^&|`?-]', Operator),
|
|
(r'\b(tinyint|smallint|mediumint|int|integer|bigint|date|'
|
|
r'datetime|time|bit|bool|tinytext|mediumtext|longtext|text|'
|
|
r'tinyblob|mediumblob|longblob|blob|float|double|double\s+'
|
|
r'precision|real|numeric|dec|decimal|timestamp|year|char|'
|
|
r'varchar|varbinary|varcharacter|enum|set)(\b\s*)(\()?',
|
|
bygroups(Keyword.Type, Text, Punctuation)),
|
|
(r'\b(add|all|alter|analyze|and|as|asc|asensitive|before|between|'
|
|
r'bigint|binary|blob|both|by|call|cascade|case|change|char|'
|
|
r'character|check|collate|column|condition|constraint|continue|'
|
|
r'convert|create|cross|current_date|current_time|'
|
|
r'current_timestamp|current_user|cursor|database|databases|'
|
|
r'day_hour|day_microsecond|day_minute|day_second|dec|decimal|'
|
|
r'declare|default|delayed|delete|desc|describe|deterministic|'
|
|
r'distinct|distinctrow|div|double|drop|dual|each|else|elseif|'
|
|
r'enclosed|escaped|exists|exit|explain|fetch|float|float4|float8'
|
|
r'|for|force|foreign|from|fulltext|grant|group|having|'
|
|
r'high_priority|hour_microsecond|hour_minute|hour_second|if|'
|
|
r'ignore|in|index|infile|inner|inout|insensitive|insert|int|'
|
|
r'int1|int2|int3|int4|int8|integer|interval|into|is|iterate|'
|
|
r'join|key|keys|kill|leading|leave|left|like|limit|lines|load|'
|
|
r'localtime|localtimestamp|lock|long|loop|low_priority|match|'
|
|
r'minute_microsecond|minute_second|mod|modifies|natural|'
|
|
r'no_write_to_binlog|not|numeric|on|optimize|option|optionally|'
|
|
r'or|order|out|outer|outfile|precision|primary|procedure|purge|'
|
|
r'raid0|read|reads|real|references|regexp|release|rename|repeat|'
|
|
r'replace|require|restrict|return|revoke|right|rlike|schema|'
|
|
r'schemas|second_microsecond|select|sensitive|separator|set|'
|
|
r'show|smallint|soname|spatial|specific|sql|sql_big_result|'
|
|
r'sql_calc_found_rows|sql_small_result|sqlexception|sqlstate|'
|
|
r'sqlwarning|ssl|starting|straight_join|table|terminated|then|'
|
|
r'to|trailing|trigger|undo|union|unique|unlock|unsigned|update|'
|
|
r'usage|use|using|utc_date|utc_time|utc_timestamp|values|'
|
|
r'varying|when|where|while|with|write|x509|xor|year_month|'
|
|
r'zerofill)\b', Keyword),
|
|
# TODO: this list is not complete
|
|
(r'\b(auto_increment|engine|charset|tables)\b', Keyword.Pseudo),
|
|
(r'(true|false|null)', Name.Constant),
|
|
(r'([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\()',
|
|
bygroups(Name.Function, Text, Punctuation)),
|
|
(r'[a-zA-Z_][a-zA-Z0-9_]*', Name),
|
|
(r'@[A-Za-z0-9]*[._]*[A-Za-z0-9]*', Name.Variable),
|
|
(r'[;:()\[\],\.]', Punctuation)
|
|
],
|
|
'multiline-comments': [
|
|
(r'/\*', Comment.Multiline, 'multiline-comments'),
|
|
(r'\*/', Comment.Multiline, '#pop'),
|
|
(r'[^/\*]+', Comment.Multiline),
|
|
(r'[/*]', Comment.Multiline)
|
|
]
|
|
}
|
|
|
|
|
|
class SqliteConsoleLexer(Lexer):
|
|
"""
|
|
Lexer for example sessions using sqlite3.
|
|
|
|
*New in Pygments 0.11.*
|
|
"""
|
|
|
|
name = 'sqlite3con'
|
|
aliases = ['sqlite3']
|
|
filenames = ['*.sqlite3-console']
|
|
mimetypes = ['text/x-sqlite3-console']
|
|
|
|
def get_tokens_unprocessed(self, data):
|
|
sql = SqlLexer(**self.options)
|
|
|
|
curcode = ''
|
|
insertions = []
|
|
for match in line_re.finditer(data):
|
|
line = match.group()
|
|
if line.startswith('sqlite> ') or line.startswith(' ...> '):
|
|
insertions.append((len(curcode),
|
|
[(0, Generic.Prompt, line[:8])]))
|
|
curcode += line[8:]
|
|
else:
|
|
if curcode:
|
|
for item in do_insertions(insertions,
|
|
sql.get_tokens_unprocessed(curcode)):
|
|
yield item
|
|
curcode = ''
|
|
insertions = []
|
|
if line.startswith('SQL error: '):
|
|
yield (match.start(), Generic.Traceback, line)
|
|
else:
|
|
yield (match.start(), Generic.Output, line)
|
|
if curcode:
|
|
for item in do_insertions(insertions,
|
|
sql.get_tokens_unprocessed(curcode)):
|
|
yield item
|