
lX[Tc           @   sM  d  Z  d d l Z d d l m Z m Z m Z m Z m Z d d l m	 Z	 m
 Z
 m Z m Z m Z m Z m Z m Z m Z d d l m Z m Z d d l m Z d d l m Z m Z m Z m Z d d	 d
 d d d d g Z e j d  Z e j d e j  Z  d   Z! d e" f d     YZ# d e# e f d     YZ$ d	 e# e f d     YZ% d e# e f d     YZ& e j d  Z' e j d  Z( e j d  Z) e j d  Z( e j d  Z* e j d  Z+ d e" f d     YZ, d
 e f d      YZ- d e f d!     YZ. d e f d"     YZ/ d e f d#     YZ0 d e f d$     YZ1 d S(%   s  
    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-2014 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
iN(   t   Lexert
   RegexLexert   do_insertionst   bygroupst   words(	   t   Punctuationt   Textt   Commentt   Operatort   Keywordt   Namet   Stringt   Numbert   Generic(   t   get_lexer_by_namet   ClassNotFound(   t	   iteritems(   t   KEYWORDSt	   DATATYPESt   PSEUDO_TYPESt   PLPGSQL_KEYWORDSt   PostgresLexert   PlPgsqlLexert   PostgresConsoleLexert   SqlLexert
   MySqlLexert   SqliteConsoleLexert   RqlLexers   .*?
s   \s+LANGUAGE\s+'?(\w+)'?c         c   sB  d } t j |  j | j   | j   d ! } | d k	 rV |  j | j d   } n] t t j |  j t	 d | j
   d  | j
   !  } | r |  j | d j d   } n  | r$| j
 d  t | j d  f Vx% | j | j d   D] } | Vq W| j
 d  t | j d  f Vn | j
   t | j   f Vd S(   sj   Parse the content of a $-string using a lexer

    The lexer is chosen looking for a nearby LANGUAGE.
    id   i   i    ii   i   N(   t   Nonet   language_ret   matcht   textt   endt
   _get_lexert   groupt   listt   finditert   maxt   startR   t   get_tokens_unprocessed(   t   lexerR   t   lt   mt   x(    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyt   language_callback=   s    )	/ 	#t   PostgresBasec           B   s    e  Z d  Z d   Z d   Z RS(   s  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.
    c         g   s8   | |  _  x( t t |   j | |  D] } | Vq% Wd  S(   N(   R   t   superR-   R'   (   t   selfR   t   argsR+   (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyR'   _   s    	c         C   s   | j    d k r" t d |  j  S| g } | j d  rN | j | d  n  | j d  rq | j | d   n  | j d  r | j d  r | j | d d ! n  x: | D]. } y t | |  j  SWq t k
 r q Xq Wd  Sd  S(   Nt   sqlt
   postgresqlt   pli   t   ui(   t   lowerR   t   optionst
   startswitht   appendt   endswithR   R   (   R/   t   langt   triesR)   (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyR!   f   s    	(   t   __name__t
   __module__t   __doc__R'   R!   (    (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyR-   V   s   	c           B   sU  e  Z d  Z d Z d d g Z d g Z e j Z i d e	 f d e
 j f d e
 j d f d	 d
 j d   e e D  d e j f e e d d e f d e f d e f d e j f d e j f d e j f d e j f d e j f d e f d e f d e j f d e f g d 6d e
 j d f d e
 j d f d e
 j f d e
 j f g d 6Z RS(   sM   
    Lexer for the PostgreSQL dialect of SQL.

    .. versionadded:: 1.5
    s   PostgreSQL SQL dialectR2   t   postgress   text/x-postgresqls   \s+s   --.*?\ns   /\*s   multiline-commentst   (t   |c         c   s!   |  ] } | j  d  d  Vq d S(   t    s   \s+N(   t   replace(   t   .0t   s(    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pys	   <genexpr>   s   s   )\bt   suffixs   \bs   [+*/<>=~!@#%^&|`?-]+s   ::s   \$\d+s&   ([0-9]*\.[0-9]*|[0-9]+)(e[+-]?[0-9]+)?s   [0-9]+s   (E|U&)?'(''|[^'])*'s   (U&)?"(""|[^"])*"s   (?s)(\$[^$]*\$)(.*?)(\1)s	   [a-z_]\w*s   :(['"]?)[a-z]\w*\b\1s   [;:()\[\]{},.]t   roots   \*/s   #pops   [^/*]+s   [/*](   R<   R=   R>   t   namet   aliasest	   mimetypest   ret
   IGNORECASEt   flagsR   R   t   Singlet	   Multilinet   joinR   R   R
   t   BuiltinR   R   R	   R   t   VariableR   t   Floatt   IntegerR   R,   R   t   tokens(    (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyR   }   s4   			+				c           B   s   e  Z d  Z d Z d g Z d g Z e j Z e	 d   e
 e j  D  Z xk e e d  D]G \ Z Z e d e k r] e e e d d e f e d e <[ Pq] q] Wd	 s t d
   d e j f d e f d e j f d e j f g e d d	 *RS(   sR   
    Handle the extra syntax in Pl/pgSQL language.

    .. versionadded:: 1.5
    s   PL/pgSQLt   plpgsqls   text/x-plpgsqlc         c   s"   |  ] \ } } | | f Vq d  S(   N(    (   RD   t   kR)   (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pys	   <genexpr>   s    RG   i   RF   s   \bi    s   SQL keywords not founds   \%[a-z]\w*\bs   :=s   \<\<[a-z]\w*\>\>s   \#[a-z]\w*\b(   R<   R=   R>   RH   RI   RJ   RK   RL   RM   t   dictR   R   RU   t	   enumeratet   it   patternR	   R   R   R   t   AssertionErrorR
   RQ   R   t   Labelt   Pseudo(    (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyR      s"   				t   PsqlRegexLexerc           B   s   e  Z d  Z d Z g  Z e j Z e d   e	 e
 j  D  Z e d j d e j d f  d e d f d e f d e j f d e j f d	 e j f d
 e j f d e j f g e d <RS(   s   
    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.
    s'   PostgreSQL console - regexp based lexerc         c   s"   |  ] \ } } | | f Vq d  S(   N(    (   RD   RW   R)   (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pys	   <genexpr>   s    RG   s   \\[^\s]+s   psql-commands   \ns   \s+s   :(['"]?)[a-z]\w*\b\1s   '(''|[^'])*'s	   `([^`])*`s   [^\s]+(   R<   R=   R>   RH   RI   RK   RL   RM   RX   R   R   RU   R8   R	   R^   R   R
   RR   R   RN   t   Backtickt   Symbol(    (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyR_      s   	
	s   ^(\S.*?)??[=\-\(\$\'\"][#>]s   \s*\\s   ;\s*(--.*?)?$s   (\s*)(\\.+?)(\s+)$s   (ERROR|FATAL):sS   ((?:DEBUG|INFO|NOTICE|WARNING|ERROR|FATAL|HINT|DETAIL|CONTEXT|LINE [0-9]+):)(.*?\n)t	   lookaheadc           B   s8   e  Z d  Z d   Z d   Z d   Z d   Z e Z RS(   s0   Wrap an iterator and allow pushing back an item.c         C   s   t  |  |  _  d  |  _ d  S(   N(   t   iterR   t	   _nextitem(   R/   R+   (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyt   __init__   s    c         C   s   |  S(   N(    (   R/   (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyt   __iter__   s    c         C   s   | |  _  | S(   N(   Rd   (   R/   RZ   (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyt   send   s    	c         C   s2   |  j  d  k	 r% |  j  } d  |  _  | St |  j  S(   N(   Rd   R   t   nextRc   (   R/   t   ni(    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyt   __next__   s
    		(   R<   R=   R>   Re   Rf   Rg   Rj   Rh   (    (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyRb      s   				c           B   s5   e  Z d  Z d Z d d d g Z d g Z d   Z RS(   s=   
    Lexer for psql sessions.

    .. versionadded:: 1.5
    s   PostgreSQL console (psql)t   psqls   postgresql-consoles   postgres-consoles   text/x-postgresql-psqlc         c   s\  t  |  j   } t t j |   } x1d } g  } xy t |  } Wn t k
 rZ Pn X| j d  r | r t d |  j  } x | j	 |  D] } | Vq WPn  t
 j |  }	 |	 d  k	 r| j t |  d t j |	 j   f g f  | | t |	 j    7} n
 | | 7} t j |  s4t j |  r6 Pq6 q6 x% t | | j	 |   D] }
 |
 VqTWt j } x t |  } t
 j |  }	 |	 d  k	 r| j |  Pn  t j |  } | d  k	 rD| j d  j d  s| j d  j d  rt j } n  | j d  t j | j d  f V| j d  | | j d  f Vqod | | f Vqoq' d  S(	   Nt    t   $t   consolei    i   t   ERRORt   FATALi   (   R_   R6   Rb   t   line_ret   findallRh   t   StopIterationR7   R   R'   t	   re_promptR   R   R8   t   lenR   t   PromptR"   t   re_psql_commandt   re_end_commandt   searchR   t   OutputRg   t
   re_messaget   ErrorR&   t   Strong(   R/   t   dataR1   t   linest   curcodet
   insertionst   lineR(   R+   t   mpromptt   itemt	   out_tokent   mmsg(    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyR'     sT    	
			##(   R<   R=   R>   RH   RI   RJ   R'   (    (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyR     s
   	c          B   s  e  Z d  Z d Z d g Z d g Z d g Z e j Z	 i d e
 f d e j f d e j d f e ddde f e ddde j f de f de j f de j f de j f de f de f g d6d e j d f de j df de j f de j f g d 6Z RS(   s   
    Lexer for Structured Query Language. Currently, this lexer does
    not recognize any special syntax except ANSI SQL.
    t   SQLR1   s   *.sqls
   text/x-sqls   \s+s   --.*?\ns   /\*s   multiline-commentst   ABORTt   ABSt   ABSOLUTEt   ACCESSt   ADAt   ADDt   ADMINt   AFTERt	   AGGREGATEt   ALIASt   ALLt   ALLOCATEt   ALTERt   ANALYSEt   ANALYZEt   ANDt   ANYt   AREt   ASt   ASCt
   ASENSITIVEt	   ASSERTIONt
   ASSIGNMENTt
   ASYMMETRICt   ATt   ATOMICt   AUTHORIZATIONt   AVGt   BACKWARDt   BEFOREt   BEGINt   BETWEENt   BITVARt
   BIT_LENGTHt   BOTHt   BREADTHt   BYt   Ct   CACHEt   CALLt   CALLEDt   CARDINALITYt   CASCADEt   CASCADEDt   CASEt   CASTt   CATALOGt   CATALOG_NAMEt   CHAINt   CHARACTERISTICSt   CHARACTER_LENGTHt   CHARACTER_SET_CATALOGt   CHARACTER_SET_NAMEt   CHARACTER_SET_SCHEMAt   CHAR_LENGTHt   CHECKt   CHECKEDt
   CHECKPOINTt   CLASSt   CLASS_ORIGINt   CLOBt   CLOSEt   CLUSTERt   COALSECEt   COBOLt   COLLATEt	   COLLATIONt   COLLATION_CATALOGt   COLLATION_NAMEt   COLLATION_SCHEMAt   COLUMNt   COLUMN_NAMEt   COMMAND_FUNCTIONt   COMMAND_FUNCTION_CODEt   COMMENTt   COMMITt	   COMMITTEDt
   COMPLETIONt   CONDITION_NUMBERt   CONNECTt
   CONNECTIONt   CONNECTION_NAMEt
   CONSTRAINTt   CONSTRAINTSt   CONSTRAINT_CATALOGt   CONSTRAINT_NAMEt   CONSTRAINT_SCHEMAt   CONSTRUCTORt   CONTAINSt   CONTINUEt
   CONVERSIONt   CONVERTt   COPYt   CORRESPONTINGt   COUNTt   CREATEt   CREATEDBt
   CREATEUSERt   CROSSt   CUBEt   CURRENTt   CURRENT_DATEt   CURRENT_PATHt   CURRENT_ROLEt   CURRENT_TIMEt   CURRENT_TIMESTAMPt   CURRENT_USERt   CURSORt   CURSOR_NAMEt   CYCLEt   DATAt   DATABASEt   DATETIME_INTERVAL_CODEt   DATETIME_INTERVAL_PRECISIONt   DAYt
   DEALLOCATEt   DECLAREt   DEFAULTt   DEFAULTSt
   DEFERRABLEt   DEFERREDt   DEFINEDt   DEFINERt   DELETEt	   DELIMITERt
   DELIMITERSt   DEREFt   DESCt   DESCRIBEt
   DESCRIPTORt   DESTROYt
   DESTRUCTORt   DETERMINISTICt   DIAGNOSTICSt
   DICTIONARYt
   DISCONNECTt   DISPATCHt   DISTINCTt   DOt   DOMAINt   DROPt   DYNAMICt   DYNAMIC_FUNCTIONt   DYNAMIC_FUNCTION_CODEt   EACHt   ELSEt   ENCODINGt	   ENCRYPTEDt   ENDs   END-EXECt   EQUALSt   ESCAPEt   EVERYt	   EXCEPTIONt   EXCEPTt	   EXCLUDINGt	   EXCLUSIVEt   EXECt   EXECUTEt   EXISTINGt   EXISTSt   EXPLAINt   EXTERNALt   EXTRACTt   FALSEt   FETCHt   FINALt   FIRSTt   FORt   FORCEt   FOREIGNt   FORTRANt   FORWARDt   FOUNDt   FREEt   FREEZEt   FROMt   FULLt   FUNCTIONt   Gt   GENERALt	   GENERATEDt   GETt   GLOBALt   GOt   GOTOt   GRANTt   GRANTEDt   GROUPt   GROUPINGt   HANDLERt   HAVINGt	   HIERARCHYt   HOLDt   HOSTt   IDENTITYt   IGNOREt   ILIKEt	   IMMEDIATEt	   IMMUTABLEt   IMPLEMENTATIONt   IMPLICITt   INt	   INCLUDINGt	   INCREMENTt   INDEXt
   INDITCATORt   INFIXt   INHERITSt
   INITIALIZEt	   INITIALLYt   INNERt   INOUTt   INPUTt   INSENSITIVEt   INSERTt   INSTANTIABLEt   INSTEADt	   INTERSECTt   INTOt   INVOKERt   ISt   ISNULLt	   ISOLATIONt   ITERATEt   JOINt   KEYt
   KEY_MEMBERt   KEY_TYPEt   LANCOMPILERt   LANGUAGEt   LARGEt   LASTt   LATERALt   LEADINGt   LEFTt   LENGTHt   LESSt   LEVELt   LIKEt   LIMITt   LISTENt   LOADt   LOCALt	   LOCALTIMEt   LOCALTIMESTAMPt   LOCATIONt   LOCATORt   LOCKt   LOWERt   MAPt   MATCHt   MAXt   MAXVALUEt   MESSAGE_LENGTHt   MESSAGE_OCTET_LENGTHt   MESSAGE_TEXTt   METHODt   MINt   MINUTEt   MINVALUEt   MODt   MODEt   MODIFIESt   MODIFYt   MONTHt   MOREt   MOVEt   MUMPSt   NAMESt   NATIONALt   NATURALt   NCHARt   NCLOBt   NEWt   NEXTt   NOt
   NOCREATEDBt   NOCREATEUSERt   NONEt   NOTt   NOTHINGt   NOTIFYt   NOTNULLt   NULLt   NULLABLEt   NULLIFt   OBJECTt   OCTET_LENGTHt   OFt   OFFt   OFFSETt   OIDSt   OLDt   ONt   ONLYt   OPENt	   OPERATIONt   OPERATORt   OPTIONt   OPTIONSt   ORt   ORDERt
   ORDINALITYt   OUTt   OUTERt   OUTPUTt   OVERLAPSt   OVERLAYt
   OVERRIDINGt   OWNERt   PADt	   PARAMETERt
   PARAMETERSt   PARAMETER_MODEt   PARAMATER_NAMEt   PARAMATER_ORDINAL_POSITIONt   PARAMETER_SPECIFIC_CATALOGt   PARAMETER_SPECIFIC_NAMEt   PARAMATER_SPECIFIC_SCHEMAt   PARTIALt   PASCALt   PENDANTt   PLACINGt   PLIt   POSITIONt   POSTFIXt	   PRECISIONt   PREFIXt   PREORDERt   PREPAREt   PRESERVEt   PRIMARYt   PRIORt
   PRIVILEGESt
   PROCEDURALt	   PROCEDUREt   PUBLICt   READt   READSt   RECHECKt	   RECURSIVEt   REFt
   REFERENCESt   REFERENCINGt   REINDEXt   RELATIVEt   RENAMEt
   REPEATABLEt   REPLACEt   RESETt   RESTARTt   RESTRICTt   RESULTt   RETURNt   RETURNED_LENGTHt   RETURNED_OCTET_LENGTHt   RETURNED_SQLSTATEt   RETURNSt   REVOKEt   RIGHTt   ROLEt   ROLLBACKt   ROLLUPt   ROUTINEt   ROUTINE_CATALOGt   ROUTINE_NAMEt   ROUTINE_SCHEMAt   ROWt   ROWSt	   ROW_COUNTt   RULEt
   SAVE_POINTt   SCALEt   SCHEMAt   SCHEMA_NAMEt   SCOPEt   SCROLLt   SEARCHt   SECONDt   SECURITYt   SELECTt   SELFt	   SENSITIVEt   SERIALIZABLEt   SERVER_NAMEt   SESSIONt   SESSION_USERt   SETt   SETOFt   SETSt   SHAREt   SHOWt   SIMILARt   SIMPLEt   SIZEt   SOMEt   SOURCEt   SPACEt   SPECIFICt   SPECIFICTYPEt   SPECIFIC_NAMEt   SQLCODEt   SQLERRORt   SQLEXCEPTIONt   SQLSTATEt   SQLWARNINIGt   STABLEt   STARTt   STATEt	   STATEMENTt   STATICt
   STATISTICSt   STDINt   STDOUTt   STORAGEt   STRICTt	   STRUCTUREt   STYPEt   SUBCLASS_ORIGINt   SUBLISTt	   SUBSTRINGt   SUMt	   SYMMETRICt   SYSIDt   SYSTEMt   SYSTEM_USERt   TABLEt
   TABLE_NAMEs    TEMPt   TEMPLATEt	   TEMPORARYt	   TERMINATEt   THANt   THENt	   TIMESTAMPt   TIMEZONE_HOURt   TIMEZONE_MINUTEt   TOt   TOASTt   TRAILINGt
   TRANSATIONt   TRANSACTIONS_COMMITTEDt   TRANSACTIONS_ROLLED_BACKt   TRANSATION_ACTIVEt	   TRANSFORMt
   TRANSFORMSt	   TRANSLATEt   TRANSLATIONt   TREATt   TRIGGERt   TRIGGER_CATALOGt   TRIGGER_NAMEt   TRIGGER_SCHEMAt   TRIMt   TRUEt   TRUNCATEt   TRUSTEDt   TYPEt   UNCOMMITTEDt   UNDERt   UNENCRYPTEDt   UNIONt   UNIQUEt   UNKNOWNt   UNLISTENt   UNNAMEDt   UNNESTt   UNTILt   UPDATEt   UPPERt   USAGEt   USERt   USER_DEFINED_TYPE_CATALOGt   USER_DEFINED_TYPE_NAMEt   USER_DEFINED_TYPE_SCHEMAt   USINGt   VACUUMt   VALIDt	   VALIDATORt   VALUESt   VARIABLEt   VERBOSEt   VERSIONt   VIEWt   VOLATILEt   WHENt   WHENEVERt   WHEREt   WITHt   WITHOUTt   WORKt   WRITEt   YEARt   ZONERF   s   \bt   ARRAYt   BIGINTt   BINARYt   BITt   BLOBt   BOOLEANt   CHARt	   CHARACTERt   DATEt   DECt   DECIMALt   FLOATt   INTt   INTEGERt   INTERVALt   NUMBERt   NUMERICt   REALt   SERIALt   SMALLINTt   VARCHARt   VARYINGt   INT8t   SERIAL8t   TEXTs   [+*/<>=~!@#%^&|`?-]s   [0-9]+s   '(''|[^'])*'s   "(""|[^"])*"s   [a-z_][\w$]*s   [;:()\[\],.]RG   s   \*/s   #pops   [^/*]+s   [/*](  R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   s   ANYR   R   R   R   R   R   R   s   ATR   R   R   R   R   R   R   R   R   R   R   R   R   R   s   CALLR   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R  R  R  R  R  R  R  R  R	  R
  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  s   END-EXECR  R  R  R   R!  R"  R#  R$  R%  R&  R'  R(  R)  R*  R+  R,  R-  R.  R/  R0  R1  R2  R3  R4  R5  R6  R7  R8  R9  R:  R;  R<  R=  R>  R?  R@  RA  RB  RC  RD  RE  RF  RG  RH  RI  RJ  RK  RL  RM  RN  RO  RP  s   INRR  RS  RT  RU  RV  RW  RX  RY  RZ  R[  R\  R]  R^  R_  R`  Ra  Rb  Rc  Rd  Re  Rf  Rg  Rh  Ri  Rj  Rk  Rl  Rm  Rn  Ro  Rp  Rq  Rr  Rs  Rt  Ru  Rv  Rw  Rx  Ry  Rz  R{  R|  R}  R~  R  R  R  R  s   MAXR  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R   R  R  R  R  R  R  R  R  R	  R
  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R   R  R  R  R  R  R  R  R   R!  R"  R#  R$  s   STDOUTR&  R'  R(  R)  R*  R+  R,  R-  R.  R/  R0  R1  R2  R3  s    TEMPs   TEMPLATER5  R6  R7  R8  R9  R:  R;  R<  R=  R>  R?  R@  RA  RB  RC  RD  RE  RF  RG  RH  RI  RJ  RK  RL  RM  RN  RO  RP  RQ  RR  RS  RT  RU  RV  RW  RX  RY  RZ  R[  R\  R]  R^  R_  R`  Ra  Rb  Rc  Rd  Re  Rf  Rg  s   VERBOSEs   VERSIONRj  Rk  Rl  Rm  Rn  Ro  Rp  Rq  Rr  Rs  Rt  (   Ru  Rv  Rw  Rx  Ry  Rz  R{  R|  R}  R~  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  (   R<   R=   R>   RH   RI   t	   filenamesRJ   RK   RL   RM   R   R   RN   RO   R   R	   R
   RQ   R   R   RT   R   Ra   R   RU   (    (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyR   U  s   					                                                                            			c           B   sQ  e  Z d  Z d Z d g Z d g Z e j Z i d e	 f d e
 j f d e
 j d f d e j f d	 e j f d
 e j f d e j f d e j f d e f d e e j e	 e  f d e f d e j f d e j f d e e j e	 e  f d e f d e j f d e f g d 6d e
 j d f d e
 j d f d e
 j f d e
 j f g d 6Z RS(   s"   
    Special lexer for MySQL.
    t   MySQLt   mysqls   text/x-mysqls   \s+s   (#|--\s+).*?\ns   /\*s   multiline-commentss   [0-9]+s   [0-9]*\.[0-9]+(e[+-][0-9]+)s   '(\\\\|\\'|''|[^'])*'s   "(\\\\|\\"|""|[^"])*"s   `(\\\\|\\`|``|[^`])*`s   [+*/<>=~!@#%^&|`?-]s  \b(tinyint|smallint|mediumint|int|integer|bigint|date|datetime|time|bit|bool|tinytext|mediumtext|longtext|text|tinyblob|mediumblob|longblob|blob|float|double|double\s+precision|real|numeric|dec|decimal|timestamp|year|char|varchar|varbinary|varcharacter|enum|set)(\b\s*)(\()?s-  \b(add|all|alter|analyze|and|as|asc|asensitive|before|between|bigint|binary|blob|both|by|call|cascade|case|change|char|character|check|collate|column|condition|constraint|continue|convert|create|cross|current_date|current_time|current_timestamp|current_user|cursor|database|databases|day_hour|day_microsecond|day_minute|day_second|dec|decimal|declare|default|delayed|delete|desc|describe|deterministic|distinct|distinctrow|div|double|drop|dual|each|else|elseif|enclosed|escaped|exists|exit|explain|fetch|float|float4|float8|for|force|foreign|from|fulltext|grant|group|having|high_priority|hour_microsecond|hour_minute|hour_second|if|ignore|in|index|infile|inner|inout|insensitive|insert|int|int1|int2|int3|int4|int8|integer|interval|into|is|iterate|join|key|keys|kill|leading|leave|left|like|limit|lines|load|localtime|localtimestamp|lock|long|loop|low_priority|match|minute_microsecond|minute_second|mod|modifies|natural|no_write_to_binlog|not|numeric|on|optimize|option|optionally|or|order|out|outer|outfile|precision|primary|procedure|purge|raid0|read|reads|real|references|regexp|release|rename|repeat|replace|require|restrict|return|revoke|right|rlike|schema|schemas|second_microsecond|select|sensitive|separator|set|show|smallint|soname|spatial|specific|sql|sql_big_result|sql_calc_found_rows|sql_small_result|sqlexception|sqlstate|sqlwarning|ssl|starting|straight_join|table|terminated|then|to|trailing|trigger|undo|union|unique|unlock|unsigned|update|usage|use|using|utc_date|utc_time|utc_timestamp|values|varying|when|where|while|with|write|x509|xor|year_month|zerofill)\bs*   \b(auto_increment|engine|charset|tables)\bs   (true|false|null)s   ([a-z_]\w*)(\s*)(\()s	   [a-z_]\w*s   @[a-z0-9]*[._]*[a-z0-9]*s   [;:()\[\],.]RG   s   \*/s   #pops   [^/*]+s   [/*](   R<   R=   R>   RH   RI   RJ   RK   RL   RM   R   R   RN   RO   R   RT   RS   R   t   DoubleRa   R   R   R	   t   TypeR   R^   R
   t   Constantt   FunctionRR   RU   (    (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyR     s<   						c           B   s8   e  Z d  Z d Z d g Z d g Z d g Z d   Z RS(   sO   
    Lexer for example sessions using sqlite3.

    .. versionadded:: 0.11
    t
   sqlite3cont   sqlite3s   *.sqlite3-consoles   text/x-sqlite3-consolec         c   sN  t  |  j   } d } g  } x t j |  D] } | j   } | j d  s[ | j d  r | j t |  d t j	 | d  f g f  | | d 7} q+ | r x% t
 | | j |   D] } | Vq Wd } g  } n  | j d  r | j   t j | f Vq+ | j   t j | f Vq+ W| rJx( t
 | | j |   D] } | Vq8Wn  d  S(   NRl   s   sqlite> s      ...> i    i   s   SQL error: (   R   R6   Rq   R$   R"   R7   R8   Ru   R   Rv   R   R'   R&   t	   TracebackRz   (   R/   R~   R1   R   R   R   R   R   (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyR'     s,    				(   R<   R=   R>   RH   RI   R  RJ   R'   (    (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyR     s   			c           B   s   e  Z d  Z d Z d g Z d g Z d g Z e j Z	 i d e
 f d e f d e f d e j f d	 e j f d
 e f d e j f d e j f d e f g	 d 6Z RS(   sx   
    Lexer for Relation Query Language.

    `RQL <http://www.logilab.org/project/rql>`_

    .. versionadded:: 2.0
    t   RQLt   rqls   *.rqls
   text/x-rqls   \s+s   (DELETE|SET|INSERT|UNION|DISTINCT|WITH|WHERE|BEING|OR|AND|NOT|GROUPBY|HAVING|ORDERBY|ASC|DESC|LIMIT|OFFSET|TODAY|NOW|TRUE|FALSE|NULL|EXISTS)\bs
   [+*/<>=%-]s)   (Any|is|instance_of|CWEType|CWRelation)\bs   [0-9]+s   [A-Z_]\w*\??s   '(''|[^'])*'s   "(""|[^"])*"s   [;:()\[\],.]RG   (   R<   R=   R>   RH   RI   R  RJ   RK   RL   RM   R   R	   R   R
   RQ   R   RT   R   RN   R   RU   (    (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyR   :  s"   							(2   R>   RK   t   pygments.lexerR    R   R   R   R   t   pygments.tokenR   R   R   R   R	   R
   R   R   R   t   pygments.lexersR   R   t   pygments.utilR   t"   pygments.lexers._postgres_builtinsR   R   R   R   t   __all__t   compileRq   RL   R   R,   t   objectR-   R   R   R_   Rt   Rw   Rx   t   re_errorR{   Rb   R   R   R   R   R   (    (    (    s7   /usr/lib/python2.7/dist-packages/pygments/lexers/sql.pyt   <module>'   s8   (@"		'-!	PtI(