cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From brandonwilli...@apache.org
Subject svn commit: r1152233 [6/9] - in /cassandra/trunk: conf/ src/gen-java/ src/gen-java/org/ src/gen-java/org/apache/ src/gen-java/org/apache/cassandra/ src/gen-java/org/apache/cassandra/cli/ src/gen-java/org/apache/cassandra/cql/ src/java/org/apache/cassan...
Date Fri, 29 Jul 2011 14:21:09 GMT
Added: cassandra/trunk/src/gen-java/org/apache/cassandra/cql/CqlLexer.java
URL: http://svn.apache.org/viewvc/cassandra/trunk/src/gen-java/org/apache/cassandra/cql/CqlLexer.java?rev=1152233&view=auto
==============================================================================
--- cassandra/trunk/src/gen-java/org/apache/cassandra/cql/CqlLexer.java (added)
+++ cassandra/trunk/src/gen-java/org/apache/cassandra/cql/CqlLexer.java Fri Jul 29 14:21:06 2011
@@ -0,0 +1,4305 @@
+// $ANTLR 3.2 Sep 23, 2009 12:02:23 /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g 2011-07-28 15:11:06
+
+    package org.apache.cassandra.cql;
+    import org.apache.cassandra.thrift.InvalidRequestException;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+public class CqlLexer extends Lexer {
+    public static final int LETTER=75;
+    public static final int K_CREATE=32;
+    public static final int EOF=-1;
+    public static final int K_PRIMARY=37;
+    public static final int T__93=93;
+    public static final int T__94=94;
+    public static final int T__91=91;
+    public static final int K_USE=4;
+    public static final int T__92=92;
+    public static final int K_VALUES=23;
+    public static final int STRING_LITERAL=9;
+    public static final int T__90=90;
+    public static final int K_ON=41;
+    public static final int K_USING=11;
+    public static final int K_ADD=45;
+    public static final int K_KEY=38;
+    public static final int K_TRUNCATE=47;
+    public static final int COMMENT=78;
+    public static final int T__99=99;
+    public static final int T__98=98;
+    public static final int T__97=97;
+    public static final int T__96=96;
+    public static final int T__95=95;
+    public static final int D=61;
+    public static final int E=49;
+    public static final int F=53;
+    public static final int G=67;
+    public static final int K_TYPE=44;
+    public static final int K_KEYSPACE=33;
+    public static final int T__80=80;
+    public static final int K_COUNT=7;
+    public static final int A=59;
+    public static final int T__81=81;
+    public static final int T__82=82;
+    public static final int B=70;
+    public static final int C=51;
+    public static final int T__83=83;
+    public static final int L=50;
+    public static final int M=56;
+    public static final int N=60;
+    public static final int O=55;
+    public static final int H=58;
+    public static final int I=64;
+    public static final int J=72;
+    public static final int K_UPDATE=29;
+    public static final int K=62;
+    public static final int U=65;
+    public static final int T=52;
+    public static final int W=57;
+    public static final int V=69;
+    public static final int Q=68;
+    public static final int P=66;
+    public static final int S=48;
+    public static final int R=54;
+    public static final int T__85=85;
+    public static final int T__84=84;
+    public static final int T__87=87;
+    public static final int T__86=86;
+    public static final int K_TTL=25;
+    public static final int T__89=89;
+    public static final int Y=63;
+    public static final int X=71;
+    public static final int T__88=88;
+    public static final int Z=73;
+    public static final int K_INDEX=40;
+    public static final int K_REVERSED=17;
+    public static final int K_INSERT=21;
+    public static final int WS=77;
+    public static final int K_APPLY=28;
+    public static final int K_TIMESTAMP=24;
+    public static final int K_AND=19;
+    public static final int K_LEVEL=13;
+    public static final int K_BATCH=27;
+    public static final int UUID=46;
+    public static final int K_DELETE=31;
+    public static final int FLOAT=39;
+    public static final int K_SELECT=6;
+    public static final int K_LIMIT=15;
+    public static final int K_ALTER=43;
+    public static final int K_SET=30;
+    public static final int K_WHERE=14;
+    public static final int MULTILINE_COMMENT=79;
+    public static final int HEX=76;
+    public static final int K_INTO=22;
+    public static final int T__103=103;
+    public static final int T__104=104;
+    public static final int IDENT=5;
+    public static final int DIGIT=74;
+    public static final int K_FIRST=16;
+    public static final int K_BEGIN=26;
+    public static final int INTEGER=10;
+    public static final int RANGEOP=18;
+    public static final int K_CONSISTENCY=12;
+    public static final int COMPIDENT=35;
+    public static final int K_WITH=34;
+    public static final int T__102=102;
+    public static final int T__101=101;
+    public static final int K_IN=20;
+    public static final int T__100=100;
+    public static final int K_FROM=8;
+    public static final int K_COLUMNFAMILY=36;
+    public static final int K_DROP=42;
+
+        List<Token> tokens = new ArrayList<Token>();
+        
+        public void emit(Token token) {
+            state.token = token;
+            tokens.add(token);
+        }
+        
+        public Token nextToken() {
+            super.nextToken();
+            if (tokens.size() == 0)
+                return Token.EOF_TOKEN;
+            return tokens.remove(0);
+        }
+        
+        private List<String> recognitionErrors = new ArrayList<String>();
+        
+        public void displayRecognitionError(String[] tokenNames, RecognitionException e)
+        {
+            String hdr = getErrorHeader(e);
+            String msg = getErrorMessage(e, tokenNames);
+            recognitionErrors.add(hdr + " " + msg);
+        }
+        
+        public List<String> getRecognitionErrors()
+        {
+            return recognitionErrors;
+        }
+        
+        public void throwLastRecognitionError() throws InvalidRequestException
+        {
+            if (recognitionErrors.size() > 0)
+                throw new InvalidRequestException(recognitionErrors.get((recognitionErrors.size()-1)));
+        }
+
+
+    // delegates
+    // delegators
+
+    public CqlLexer() {;} 
+    public CqlLexer(CharStream input) {
+        this(input, new RecognizerSharedState());
+    }
+    public CqlLexer(CharStream input, RecognizerSharedState state) {
+        super(input,state);
+
+    }
+    public String getGrammarFileName() { return "/home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g"; }
+
+    // $ANTLR start "T__80"
+    public final void mT__80() throws RecognitionException {
+        try {
+            int _type = T__80;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:47:7: ( '(' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:47:9: '('
+            {
+            match('('); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__80"
+
+    // $ANTLR start "T__81"
+    public final void mT__81() throws RecognitionException {
+        try {
+            int _type = T__81;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:48:7: ( ')' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:48:9: ')'
+            {
+            match(')'); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__81"
+
+    // $ANTLR start "T__82"
+    public final void mT__82() throws RecognitionException {
+        try {
+            int _type = T__82;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:49:7: ( ',' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:49:9: ','
+            {
+            match(','); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__82"
+
+    // $ANTLR start "T__83"
+    public final void mT__83() throws RecognitionException {
+        try {
+            int _type = T__83;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:50:7: ( '\\*' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:50:9: '\\*'
+            {
+            match('*'); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__83"
+
+    // $ANTLR start "T__84"
+    public final void mT__84() throws RecognitionException {
+        try {
+            int _type = T__84;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:51:7: ( ';' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:51:9: ';'
+            {
+            match(';'); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__84"
+
+    // $ANTLR start "T__85"
+    public final void mT__85() throws RecognitionException {
+        try {
+            int _type = T__85;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:52:7: ( '=' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:52:9: '='
+            {
+            match('='); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__85"
+
+    // $ANTLR start "T__86"
+    public final void mT__86() throws RecognitionException {
+        try {
+            int _type = T__86;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:53:7: ( 'bytea' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:53:9: 'bytea'
+            {
+            match("bytea"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__86"
+
+    // $ANTLR start "T__87"
+    public final void mT__87() throws RecognitionException {
+        try {
+            int _type = T__87;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:54:7: ( 'ascii' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:54:9: 'ascii'
+            {
+            match("ascii"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__87"
+
+    // $ANTLR start "T__88"
+    public final void mT__88() throws RecognitionException {
+        try {
+            int _type = T__88;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:55:7: ( 'text' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:55:9: 'text'
+            {
+            match("text"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__88"
+
+    // $ANTLR start "T__89"
+    public final void mT__89() throws RecognitionException {
+        try {
+            int _type = T__89;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:56:7: ( 'varchar' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:56:9: 'varchar'
+            {
+            match("varchar"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__89"
+
+    // $ANTLR start "T__90"
+    public final void mT__90() throws RecognitionException {
+        try {
+            int _type = T__90;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:57:7: ( 'int' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:57:9: 'int'
+            {
+            match("int"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__90"
+
+    // $ANTLR start "T__91"
+    public final void mT__91() throws RecognitionException {
+        try {
+            int _type = T__91;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:58:7: ( 'varint' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:58:9: 'varint'
+            {
+            match("varint"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__91"
+
+    // $ANTLR start "T__92"
+    public final void mT__92() throws RecognitionException {
+        try {
+            int _type = T__92;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:59:7: ( 'bigint' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:59:9: 'bigint'
+            {
+            match("bigint"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__92"
+
+    // $ANTLR start "T__93"
+    public final void mT__93() throws RecognitionException {
+        try {
+            int _type = T__93;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:60:7: ( 'uuid' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:60:9: 'uuid'
+            {
+            match("uuid"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__93"
+
+    // $ANTLR start "T__94"
+    public final void mT__94() throws RecognitionException {
+        try {
+            int _type = T__94;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:61:7: ( 'counter' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:61:9: 'counter'
+            {
+            match("counter"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__94"
+
+    // $ANTLR start "T__95"
+    public final void mT__95() throws RecognitionException {
+        try {
+            int _type = T__95;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:62:7: ( 'boolean' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:62:9: 'boolean'
+            {
+            match("boolean"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__95"
+
+    // $ANTLR start "T__96"
+    public final void mT__96() throws RecognitionException {
+        try {
+            int _type = T__96;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:63:7: ( 'date' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:63:9: 'date'
+            {
+            match("date"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__96"
+
+    // $ANTLR start "T__97"
+    public final void mT__97() throws RecognitionException {
+        try {
+            int _type = T__97;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:64:7: ( 'float' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:64:9: 'float'
+            {
+            match("float"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__97"
+
+    // $ANTLR start "T__98"
+    public final void mT__98() throws RecognitionException {
+        try {
+            int _type = T__98;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:65:7: ( 'double' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:65:9: 'double'
+            {
+            match("double"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__98"
+
+    // $ANTLR start "T__99"
+    public final void mT__99() throws RecognitionException {
+        try {
+            int _type = T__99;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:66:7: ( '+' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:66:9: '+'
+            {
+            match('+'); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__99"
+
+    // $ANTLR start "T__100"
+    public final void mT__100() throws RecognitionException {
+        try {
+            int _type = T__100;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:67:8: ( '-' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:67:10: '-'
+            {
+            match('-'); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__100"
+
+    // $ANTLR start "T__101"
+    public final void mT__101() throws RecognitionException {
+        try {
+            int _type = T__101;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:68:8: ( '<' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:68:10: '<'
+            {
+            match('<'); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__101"
+
+    // $ANTLR start "T__102"
+    public final void mT__102() throws RecognitionException {
+        try {
+            int _type = T__102;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:69:8: ( '<=' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:69:10: '<='
+            {
+            match("<="); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__102"
+
+    // $ANTLR start "T__103"
+    public final void mT__103() throws RecognitionException {
+        try {
+            int _type = T__103;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:70:8: ( '>=' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:70:10: '>='
+            {
+            match(">="); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__103"
+
+    // $ANTLR start "T__104"
+    public final void mT__104() throws RecognitionException {
+        try {
+            int _type = T__104;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:71:8: ( '>' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:71:10: '>'
+            {
+            match('>'); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__104"
+
+    // $ANTLR start "K_SELECT"
+    public final void mK_SELECT() throws RecognitionException {
+        try {
+            int _type = K_SELECT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:480:9: ( S E L E C T )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:480:16: S E L E C T
+            {
+            mS(); 
+            mE(); 
+            mL(); 
+            mE(); 
+            mC(); 
+            mT(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_SELECT"
+
+    // $ANTLR start "K_FROM"
+    public final void mK_FROM() throws RecognitionException {
+        try {
+            int _type = K_FROM;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:481:7: ( F R O M )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:481:16: F R O M
+            {
+            mF(); 
+            mR(); 
+            mO(); 
+            mM(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_FROM"
+
+    // $ANTLR start "K_WHERE"
+    public final void mK_WHERE() throws RecognitionException {
+        try {
+            int _type = K_WHERE;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:482:8: ( W H E R E )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:482:16: W H E R E
+            {
+            mW(); 
+            mH(); 
+            mE(); 
+            mR(); 
+            mE(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_WHERE"
+
+    // $ANTLR start "K_AND"
+    public final void mK_AND() throws RecognitionException {
+        try {
+            int _type = K_AND;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:483:6: ( A N D )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:483:16: A N D
+            {
+            mA(); 
+            mN(); 
+            mD(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_AND"
+
+    // $ANTLR start "K_KEY"
+    public final void mK_KEY() throws RecognitionException {
+        try {
+            int _type = K_KEY;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:484:6: ( K E Y )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:484:16: K E Y
+            {
+            mK(); 
+            mE(); 
+            mY(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_KEY"
+
+    // $ANTLR start "K_INSERT"
+    public final void mK_INSERT() throws RecognitionException {
+        try {
+            int _type = K_INSERT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:485:9: ( I N S E R T )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:485:16: I N S E R T
+            {
+            mI(); 
+            mN(); 
+            mS(); 
+            mE(); 
+            mR(); 
+            mT(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_INSERT"
+
+    // $ANTLR start "K_UPDATE"
+    public final void mK_UPDATE() throws RecognitionException {
+        try {
+            int _type = K_UPDATE;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:486:9: ( U P D A T E )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:486:16: U P D A T E
+            {
+            mU(); 
+            mP(); 
+            mD(); 
+            mA(); 
+            mT(); 
+            mE(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_UPDATE"
+
+    // $ANTLR start "K_WITH"
+    public final void mK_WITH() throws RecognitionException {
+        try {
+            int _type = K_WITH;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:487:7: ( W I T H )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:487:16: W I T H
+            {
+            mW(); 
+            mI(); 
+            mT(); 
+            mH(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_WITH"
+
+    // $ANTLR start "K_LIMIT"
+    public final void mK_LIMIT() throws RecognitionException {
+        try {
+            int _type = K_LIMIT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:488:8: ( L I M I T )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:488:16: L I M I T
+            {
+            mL(); 
+            mI(); 
+            mM(); 
+            mI(); 
+            mT(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_LIMIT"
+
+    // $ANTLR start "K_USING"
+    public final void mK_USING() throws RecognitionException {
+        try {
+            int _type = K_USING;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:489:8: ( U S I N G )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:489:16: U S I N G
+            {
+            mU(); 
+            mS(); 
+            mI(); 
+            mN(); 
+            mG(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_USING"
+
+    // $ANTLR start "K_CONSISTENCY"
+    public final void mK_CONSISTENCY() throws RecognitionException {
+        try {
+            int _type = K_CONSISTENCY;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:490:14: ( C O N S I S T E N C Y )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:490:16: C O N S I S T E N C Y
+            {
+            mC(); 
+            mO(); 
+            mN(); 
+            mS(); 
+            mI(); 
+            mS(); 
+            mT(); 
+            mE(); 
+            mN(); 
+            mC(); 
+            mY(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_CONSISTENCY"
+
+    // $ANTLR start "K_LEVEL"
+    public final void mK_LEVEL() throws RecognitionException {
+        try {
+            int _type = K_LEVEL;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:491:8: ( ( O N E | Q U O R U M | A L L | A N Y | L O C A L '_' Q U O R U M | E A C H '_' Q U O R U M ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:491:16: ( O N E | Q U O R U M | A L L | A N Y | L O C A L '_' Q U O R U M | E A C H '_' Q U O R U M )
+            {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:491:16: ( O N E | Q U O R U M | A L L | A N Y | L O C A L '_' Q U O R U M | E A C H '_' Q U O R U M )
+            int alt1=6;
+            switch ( input.LA(1) ) {
+            case 'O':
+            case 'o':
+                {
+                alt1=1;
+                }
+                break;
+            case 'Q':
+            case 'q':
+                {
+                alt1=2;
+                }
+                break;
+            case 'A':
+            case 'a':
+                {
+                int LA1_3 = input.LA(2);
+
+                if ( (LA1_3=='L'||LA1_3=='l') ) {
+                    alt1=3;
+                }
+                else if ( (LA1_3=='N'||LA1_3=='n') ) {
+                    alt1=4;
+                }
+                else {
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 1, 3, input);
+
+                    throw nvae;
+                }
+                }
+                break;
+            case 'L':
+            case 'l':
+                {
+                alt1=5;
+                }
+                break;
+            case 'E':
+            case 'e':
+                {
+                alt1=6;
+                }
+                break;
+            default:
+                NoViableAltException nvae =
+                    new NoViableAltException("", 1, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt1) {
+                case 1 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:491:18: O N E
+                    {
+                    mO(); 
+                    mN(); 
+                    mE(); 
+
+                    }
+                    break;
+                case 2 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:492:18: Q U O R U M
+                    {
+                    mQ(); 
+                    mU(); 
+                    mO(); 
+                    mR(); 
+                    mU(); 
+                    mM(); 
+
+                    }
+                    break;
+                case 3 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:493:18: A L L
+                    {
+                    mA(); 
+                    mL(); 
+                    mL(); 
+
+                    }
+                    break;
+                case 4 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:494:18: A N Y
+                    {
+                    mA(); 
+                    mN(); 
+                    mY(); 
+
+                    }
+                    break;
+                case 5 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:495:18: L O C A L '_' Q U O R U M
+                    {
+                    mL(); 
+                    mO(); 
+                    mC(); 
+                    mA(); 
+                    mL(); 
+                    match('_'); 
+                    mQ(); 
+                    mU(); 
+                    mO(); 
+                    mR(); 
+                    mU(); 
+                    mM(); 
+
+                    }
+                    break;
+                case 6 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:496:18: E A C H '_' Q U O R U M
+                    {
+                    mE(); 
+                    mA(); 
+                    mC(); 
+                    mH(); 
+                    match('_'); 
+                    mQ(); 
+                    mU(); 
+                    mO(); 
+                    mR(); 
+                    mU(); 
+                    mM(); 
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_LEVEL"
+
+    // $ANTLR start "K_USE"
+    public final void mK_USE() throws RecognitionException {
+        try {
+            int _type = K_USE;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:499:6: ( U S E )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:499:16: U S E
+            {
+            mU(); 
+            mS(); 
+            mE(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_USE"
+
+    // $ANTLR start "K_FIRST"
+    public final void mK_FIRST() throws RecognitionException {
+        try {
+            int _type = K_FIRST;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:500:8: ( F I R S T )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:500:16: F I R S T
+            {
+            mF(); 
+            mI(); 
+            mR(); 
+            mS(); 
+            mT(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_FIRST"
+
+    // $ANTLR start "K_REVERSED"
+    public final void mK_REVERSED() throws RecognitionException {
+        try {
+            int _type = K_REVERSED;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:501:11: ( R E V E R S E D )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:501:16: R E V E R S E D
+            {
+            mR(); 
+            mE(); 
+            mV(); 
+            mE(); 
+            mR(); 
+            mS(); 
+            mE(); 
+            mD(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_REVERSED"
+
+    // $ANTLR start "K_COUNT"
+    public final void mK_COUNT() throws RecognitionException {
+        try {
+            int _type = K_COUNT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:502:8: ( C O U N T )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:502:16: C O U N T
+            {
+            mC(); 
+            mO(); 
+            mU(); 
+            mN(); 
+            mT(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_COUNT"
+
+    // $ANTLR start "K_SET"
+    public final void mK_SET() throws RecognitionException {
+        try {
+            int _type = K_SET;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:503:6: ( S E T )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:503:16: S E T
+            {
+            mS(); 
+            mE(); 
+            mT(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_SET"
+
+    // $ANTLR start "K_BEGIN"
+    public final void mK_BEGIN() throws RecognitionException {
+        try {
+            int _type = K_BEGIN;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:504:8: ( B E G I N )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:504:16: B E G I N
+            {
+            mB(); 
+            mE(); 
+            mG(); 
+            mI(); 
+            mN(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_BEGIN"
+
+    // $ANTLR start "K_APPLY"
+    public final void mK_APPLY() throws RecognitionException {
+        try {
+            int _type = K_APPLY;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:505:8: ( A P P L Y )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:505:16: A P P L Y
+            {
+            mA(); 
+            mP(); 
+            mP(); 
+            mL(); 
+            mY(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_APPLY"
+
+    // $ANTLR start "K_BATCH"
+    public final void mK_BATCH() throws RecognitionException {
+        try {
+            int _type = K_BATCH;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:506:8: ( B A T C H )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:506:16: B A T C H
+            {
+            mB(); 
+            mA(); 
+            mT(); 
+            mC(); 
+            mH(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_BATCH"
+
+    // $ANTLR start "K_TRUNCATE"
+    public final void mK_TRUNCATE() throws RecognitionException {
+        try {
+            int _type = K_TRUNCATE;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:507:11: ( T R U N C A T E )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:507:16: T R U N C A T E
+            {
+            mT(); 
+            mR(); 
+            mU(); 
+            mN(); 
+            mC(); 
+            mA(); 
+            mT(); 
+            mE(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_TRUNCATE"
+
+    // $ANTLR start "K_DELETE"
+    public final void mK_DELETE() throws RecognitionException {
+        try {
+            int _type = K_DELETE;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:508:9: ( D E L E T E )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:508:16: D E L E T E
+            {
+            mD(); 
+            mE(); 
+            mL(); 
+            mE(); 
+            mT(); 
+            mE(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_DELETE"
+
+    // $ANTLR start "K_IN"
+    public final void mK_IN() throws RecognitionException {
+        try {
+            int _type = K_IN;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:509:5: ( I N )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:509:16: I N
+            {
+            mI(); 
+            mN(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_IN"
+
+    // $ANTLR start "K_CREATE"
+    public final void mK_CREATE() throws RecognitionException {
+        try {
+            int _type = K_CREATE;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:510:9: ( C R E A T E )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:510:16: C R E A T E
+            {
+            mC(); 
+            mR(); 
+            mE(); 
+            mA(); 
+            mT(); 
+            mE(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_CREATE"
+
+    // $ANTLR start "K_KEYSPACE"
+    public final void mK_KEYSPACE() throws RecognitionException {
+        try {
+            int _type = K_KEYSPACE;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:511:11: ( ( K E Y S P A C E | S C H E M A ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:511:16: ( K E Y S P A C E | S C H E M A )
+            {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:511:16: ( K E Y S P A C E | S C H E M A )
+            int alt2=2;
+            int LA2_0 = input.LA(1);
+
+            if ( (LA2_0=='K'||LA2_0=='k') ) {
+                alt2=1;
+            }
+            else if ( (LA2_0=='S'||LA2_0=='s') ) {
+                alt2=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 2, 0, input);
+
+                throw nvae;
+            }
+            switch (alt2) {
+                case 1 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:511:18: K E Y S P A C E
+                    {
+                    mK(); 
+                    mE(); 
+                    mY(); 
+                    mS(); 
+                    mP(); 
+                    mA(); 
+                    mC(); 
+                    mE(); 
+
+                    }
+                    break;
+                case 2 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:512:20: S C H E M A
+                    {
+                    mS(); 
+                    mC(); 
+                    mH(); 
+                    mE(); 
+                    mM(); 
+                    mA(); 
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_KEYSPACE"
+
+    // $ANTLR start "K_COLUMNFAMILY"
+    public final void mK_COLUMNFAMILY() throws RecognitionException {
+        try {
+            int _type = K_COLUMNFAMILY;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:513:15: ( ( C O L U M N F A M I L Y | T A B L E ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:513:16: ( C O L U M N F A M I L Y | T A B L E )
+            {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:513:16: ( C O L U M N F A M I L Y | T A B L E )
+            int alt3=2;
+            int LA3_0 = input.LA(1);
+
+            if ( (LA3_0=='C'||LA3_0=='c') ) {
+                alt3=1;
+            }
+            else if ( (LA3_0=='T'||LA3_0=='t') ) {
+                alt3=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 3, 0, input);
+
+                throw nvae;
+            }
+            switch (alt3) {
+                case 1 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:513:18: C O L U M N F A M I L Y
+                    {
+                    mC(); 
+                    mO(); 
+                    mL(); 
+                    mU(); 
+                    mM(); 
+                    mN(); 
+                    mF(); 
+                    mA(); 
+                    mM(); 
+                    mI(); 
+                    mL(); 
+                    mY(); 
+
+                    }
+                    break;
+                case 2 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:514:20: T A B L E
+                    {
+                    mT(); 
+                    mA(); 
+                    mB(); 
+                    mL(); 
+                    mE(); 
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_COLUMNFAMILY"
+
+    // $ANTLR start "K_INDEX"
+    public final void mK_INDEX() throws RecognitionException {
+        try {
+            int _type = K_INDEX;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:515:8: ( I N D E X )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:515:16: I N D E X
+            {
+            mI(); 
+            mN(); 
+            mD(); 
+            mE(); 
+            mX(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_INDEX"
+
+    // $ANTLR start "K_ON"
+    public final void mK_ON() throws RecognitionException {
+        try {
+            int _type = K_ON;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:516:5: ( O N )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:516:16: O N
+            {
+            mO(); 
+            mN(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_ON"
+
+    // $ANTLR start "K_DROP"
+    public final void mK_DROP() throws RecognitionException {
+        try {
+            int _type = K_DROP;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:517:7: ( D R O P )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:517:16: D R O P
+            {
+            mD(); 
+            mR(); 
+            mO(); 
+            mP(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_DROP"
+
+    // $ANTLR start "K_PRIMARY"
+    public final void mK_PRIMARY() throws RecognitionException {
+        try {
+            int _type = K_PRIMARY;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:518:10: ( P R I M A R Y )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:518:16: P R I M A R Y
+            {
+            mP(); 
+            mR(); 
+            mI(); 
+            mM(); 
+            mA(); 
+            mR(); 
+            mY(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_PRIMARY"
+
+    // $ANTLR start "K_INTO"
+    public final void mK_INTO() throws RecognitionException {
+        try {
+            int _type = K_INTO;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:519:7: ( I N T O )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:519:16: I N T O
+            {
+            mI(); 
+            mN(); 
+            mT(); 
+            mO(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_INTO"
+
+    // $ANTLR start "K_VALUES"
+    public final void mK_VALUES() throws RecognitionException {
+        try {
+            int _type = K_VALUES;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:520:9: ( V A L U E S )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:520:16: V A L U E S
+            {
+            mV(); 
+            mA(); 
+            mL(); 
+            mU(); 
+            mE(); 
+            mS(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_VALUES"
+
+    // $ANTLR start "K_TIMESTAMP"
+    public final void mK_TIMESTAMP() throws RecognitionException {
+        try {
+            int _type = K_TIMESTAMP;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:521:12: ( T I M E S T A M P )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:521:16: T I M E S T A M P
+            {
+            mT(); 
+            mI(); 
+            mM(); 
+            mE(); 
+            mS(); 
+            mT(); 
+            mA(); 
+            mM(); 
+            mP(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_TIMESTAMP"
+
+    // $ANTLR start "K_TTL"
+    public final void mK_TTL() throws RecognitionException {
+        try {
+            int _type = K_TTL;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:522:6: ( T T L )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:522:16: T T L
+            {
+            mT(); 
+            mT(); 
+            mL(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_TTL"
+
+    // $ANTLR start "K_ALTER"
+    public final void mK_ALTER() throws RecognitionException {
+        try {
+            int _type = K_ALTER;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:523:8: ( A L T E R )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:523:16: A L T E R
+            {
+            mA(); 
+            mL(); 
+            mT(); 
+            mE(); 
+            mR(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_ALTER"
+
+    // $ANTLR start "K_ADD"
+    public final void mK_ADD() throws RecognitionException {
+        try {
+            int _type = K_ADD;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:524:6: ( A D D )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:524:16: A D D
+            {
+            mA(); 
+            mD(); 
+            mD(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_ADD"
+
+    // $ANTLR start "K_TYPE"
+    public final void mK_TYPE() throws RecognitionException {
+        try {
+            int _type = K_TYPE;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:525:7: ( T Y P E )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:525:16: T Y P E
+            {
+            mT(); 
+            mY(); 
+            mP(); 
+            mE(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K_TYPE"
+
+    // $ANTLR start "A"
+    public final void mA() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:528:11: ( ( 'a' | 'A' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:528:13: ( 'a' | 'A' )
+            {
+            if ( input.LA(1)=='A'||input.LA(1)=='a' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "A"
+
+    // $ANTLR start "B"
+    public final void mB() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:529:11: ( ( 'b' | 'B' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:529:13: ( 'b' | 'B' )
+            {
+            if ( input.LA(1)=='B'||input.LA(1)=='b' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "B"
+
+    // $ANTLR start "C"
+    public final void mC() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:530:11: ( ( 'c' | 'C' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:530:13: ( 'c' | 'C' )
+            {
+            if ( input.LA(1)=='C'||input.LA(1)=='c' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "C"
+
+    // $ANTLR start "D"
+    public final void mD() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:531:11: ( ( 'd' | 'D' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:531:13: ( 'd' | 'D' )
+            {
+            if ( input.LA(1)=='D'||input.LA(1)=='d' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "D"
+
+    // $ANTLR start "E"
+    public final void mE() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:532:11: ( ( 'e' | 'E' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:532:13: ( 'e' | 'E' )
+            {
+            if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "E"
+
+    // $ANTLR start "F"
+    public final void mF() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:533:11: ( ( 'f' | 'F' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:533:13: ( 'f' | 'F' )
+            {
+            if ( input.LA(1)=='F'||input.LA(1)=='f' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "F"
+
+    // $ANTLR start "G"
+    public final void mG() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:534:11: ( ( 'g' | 'G' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:534:13: ( 'g' | 'G' )
+            {
+            if ( input.LA(1)=='G'||input.LA(1)=='g' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "G"
+
+    // $ANTLR start "H"
+    public final void mH() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:535:11: ( ( 'h' | 'H' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:535:13: ( 'h' | 'H' )
+            {
+            if ( input.LA(1)=='H'||input.LA(1)=='h' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "H"
+
+    // $ANTLR start "I"
+    public final void mI() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:536:11: ( ( 'i' | 'I' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:536:13: ( 'i' | 'I' )
+            {
+            if ( input.LA(1)=='I'||input.LA(1)=='i' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "I"
+
+    // $ANTLR start "J"
+    public final void mJ() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:537:11: ( ( 'j' | 'J' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:537:13: ( 'j' | 'J' )
+            {
+            if ( input.LA(1)=='J'||input.LA(1)=='j' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "J"
+
+    // $ANTLR start "K"
+    public final void mK() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:538:11: ( ( 'k' | 'K' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:538:13: ( 'k' | 'K' )
+            {
+            if ( input.LA(1)=='K'||input.LA(1)=='k' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "K"
+
+    // $ANTLR start "L"
+    public final void mL() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:539:11: ( ( 'l' | 'L' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:539:13: ( 'l' | 'L' )
+            {
+            if ( input.LA(1)=='L'||input.LA(1)=='l' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "L"
+
+    // $ANTLR start "M"
+    public final void mM() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:540:11: ( ( 'm' | 'M' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:540:13: ( 'm' | 'M' )
+            {
+            if ( input.LA(1)=='M'||input.LA(1)=='m' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "M"
+
+    // $ANTLR start "N"
+    public final void mN() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:541:11: ( ( 'n' | 'N' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:541:13: ( 'n' | 'N' )
+            {
+            if ( input.LA(1)=='N'||input.LA(1)=='n' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "N"
+
+    // $ANTLR start "O"
+    public final void mO() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:542:11: ( ( 'o' | 'O' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:542:13: ( 'o' | 'O' )
+            {
+            if ( input.LA(1)=='O'||input.LA(1)=='o' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "O"
+
+    // $ANTLR start "P"
+    public final void mP() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:543:11: ( ( 'p' | 'P' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:543:13: ( 'p' | 'P' )
+            {
+            if ( input.LA(1)=='P'||input.LA(1)=='p' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "P"
+
+    // $ANTLR start "Q"
+    public final void mQ() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:544:11: ( ( 'q' | 'Q' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:544:13: ( 'q' | 'Q' )
+            {
+            if ( input.LA(1)=='Q'||input.LA(1)=='q' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "Q"
+
+    // $ANTLR start "R"
+    public final void mR() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:545:11: ( ( 'r' | 'R' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:545:13: ( 'r' | 'R' )
+            {
+            if ( input.LA(1)=='R'||input.LA(1)=='r' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "R"
+
+    // $ANTLR start "S"
+    public final void mS() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:546:11: ( ( 's' | 'S' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:546:13: ( 's' | 'S' )
+            {
+            if ( input.LA(1)=='S'||input.LA(1)=='s' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "S"
+
+    // $ANTLR start "T"
+    public final void mT() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:547:11: ( ( 't' | 'T' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:547:13: ( 't' | 'T' )
+            {
+            if ( input.LA(1)=='T'||input.LA(1)=='t' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T"
+
+    // $ANTLR start "U"
+    public final void mU() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:548:11: ( ( 'u' | 'U' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:548:13: ( 'u' | 'U' )
+            {
+            if ( input.LA(1)=='U'||input.LA(1)=='u' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "U"
+
+    // $ANTLR start "V"
+    public final void mV() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:549:11: ( ( 'v' | 'V' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:549:13: ( 'v' | 'V' )
+            {
+            if ( input.LA(1)=='V'||input.LA(1)=='v' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "V"
+
+    // $ANTLR start "W"
+    public final void mW() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:550:11: ( ( 'w' | 'W' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:550:13: ( 'w' | 'W' )
+            {
+            if ( input.LA(1)=='W'||input.LA(1)=='w' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "W"
+
+    // $ANTLR start "X"
+    public final void mX() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:551:11: ( ( 'x' | 'X' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:551:13: ( 'x' | 'X' )
+            {
+            if ( input.LA(1)=='X'||input.LA(1)=='x' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "X"
+
+    // $ANTLR start "Y"
+    public final void mY() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:552:11: ( ( 'y' | 'Y' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:552:13: ( 'y' | 'Y' )
+            {
+            if ( input.LA(1)=='Y'||input.LA(1)=='y' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "Y"
+
+    // $ANTLR start "Z"
+    public final void mZ() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:553:11: ( ( 'z' | 'Z' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:553:13: ( 'z' | 'Z' )
+            {
+            if ( input.LA(1)=='Z'||input.LA(1)=='z' ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "Z"
+
+    // $ANTLR start "STRING_LITERAL"
+    public final void mSTRING_LITERAL() throws RecognitionException {
+        try {
+            int _type = STRING_LITERAL;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            int c;
+
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:556:5: ( '\\'' (c=~ ( '\\'' | '\\r' | '\\n' ) | '\\'' '\\'' )* '\\'' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:556:7: '\\'' (c=~ ( '\\'' | '\\r' | '\\n' ) | '\\'' '\\'' )* '\\''
+            {
+            match('\''); 
+             StringBuilder b = new StringBuilder(); 
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:558:7: (c=~ ( '\\'' | '\\r' | '\\n' ) | '\\'' '\\'' )*
+            loop4:
+            do {
+                int alt4=3;
+                int LA4_0 = input.LA(1);
+
+                if ( (LA4_0=='\'') ) {
+                    int LA4_1 = input.LA(2);
+
+                    if ( (LA4_1=='\'') ) {
+                        alt4=2;
+                    }
+
+
+                }
+                else if ( ((LA4_0>='\u0000' && LA4_0<='\t')||(LA4_0>='\u000B' && LA4_0<='\f')||(LA4_0>='\u000E' && LA4_0<='&')||(LA4_0>='(' && LA4_0<='\uFFFF')) ) {
+                    alt4=1;
+                }
+
+
+                switch (alt4) {
+            	case 1 :
+            	    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:558:9: c=~ ( '\\'' | '\\r' | '\\n' )
+            	    {
+            	    c= input.LA(1);
+            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='\uFFFF') ) {
+            	        input.consume();
+
+            	    }
+            	    else {
+            	        MismatchedSetException mse = new MismatchedSetException(null,input);
+            	        recover(mse);
+            	        throw mse;}
+
+            	     b.appendCodePoint(c);
+
+            	    }
+            	    break;
+            	case 2 :
+            	    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:559:9: '\\'' '\\''
+            	    {
+            	    match('\''); 
+            	    match('\''); 
+            	     b.appendCodePoint('\'');
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop4;
+                }
+            } while (true);
+
+            match('\''); 
+             setText(b.toString()); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "STRING_LITERAL"
+
+    // $ANTLR start "DIGIT"
+    public final void mDIGIT() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:566:5: ( '0' .. '9' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:566:7: '0' .. '9'
+            {
+            matchRange('0','9'); 
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "DIGIT"
+
+    // $ANTLR start "LETTER"
+    public final void mLETTER() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:570:5: ( ( 'A' .. 'Z' | 'a' .. 'z' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:570:7: ( 'A' .. 'Z' | 'a' .. 'z' )
+            {
+            if ( (input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "LETTER"
+
+    // $ANTLR start "HEX"
+    public final void mHEX() throws RecognitionException {
+        try {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:574:5: ( ( 'A' .. 'F' | 'a' .. 'f' | '0' .. '9' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:574:7: ( 'A' .. 'F' | 'a' .. 'f' | '0' .. '9' )
+            {
+            if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {
+                input.consume();
+
+            }
+            else {
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                recover(mse);
+                throw mse;}
+
+
+            }
+
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "HEX"
+
+    // $ANTLR start "RANGEOP"
+    public final void mRANGEOP() throws RecognitionException {
+        try {
+            int _type = RANGEOP;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:578:5: ( '..' )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:578:7: '..'
+            {
+            match(".."); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "RANGEOP"
+
+    // $ANTLR start "INTEGER"
+    public final void mINTEGER() throws RecognitionException {
+        try {
+            int _type = INTEGER;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:582:5: ( ( '-' )? ( DIGIT )+ )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:582:7: ( '-' )? ( DIGIT )+
+            {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:582:7: ( '-' )?
+            int alt5=2;
+            int LA5_0 = input.LA(1);
+
+            if ( (LA5_0=='-') ) {
+                alt5=1;
+            }
+            switch (alt5) {
+                case 1 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:582:7: '-'
+                    {
+                    match('-'); 
+
+                    }
+                    break;
+
+            }
+
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:582:12: ( DIGIT )+
+            int cnt6=0;
+            loop6:
+            do {
+                int alt6=2;
+                int LA6_0 = input.LA(1);
+
+                if ( ((LA6_0>='0' && LA6_0<='9')) ) {
+                    alt6=1;
+                }
+
+
+                switch (alt6) {
+            	case 1 :
+            	    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:582:12: DIGIT
+            	    {
+            	    mDIGIT(); 
+
+            	    }
+            	    break;
+
+            	default :
+            	    if ( cnt6 >= 1 ) break loop6;
+                        EarlyExitException eee =
+                            new EarlyExitException(6, input);
+                        throw eee;
+                }
+                cnt6++;
+            } while (true);
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "INTEGER"
+
+    // $ANTLR start "FLOAT"
+    public final void mFLOAT() throws RecognitionException {
+        try {
+            int _type = FLOAT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            CommonToken d=null;
+            CommonToken r=null;
+
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:589:5: (d= INTEGER r= RANGEOP | INTEGER '.' INTEGER )
+            int alt7=2;
+            alt7 = dfa7.predict(input);
+            switch (alt7) {
+                case 1 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:589:7: d= INTEGER r= RANGEOP
+                    {
+                    int dStart1863 = getCharIndex();
+                    mINTEGER(); 
+                    d = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, dStart1863, getCharIndex()-1);
+                    int rStart1867 = getCharIndex();
+                    mRANGEOP(); 
+                    r = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, rStart1867, getCharIndex()-1);
+
+                              d.setType(INTEGER);
+                              emit(d);
+                              r.setType(RANGEOP);
+                              emit(r);
+                          
+
+                    }
+                    break;
+                case 2 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:596:9: INTEGER '.' INTEGER
+                    {
+                    mINTEGER(); 
+                    match('.'); 
+                    mINTEGER(); 
+
+                    }
+                    break;
+
+            }
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "FLOAT"
+
+    // $ANTLR start "IDENT"
+    public final void mIDENT() throws RecognitionException {
+        try {
+            int _type = IDENT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:600:5: ( LETTER ( LETTER | DIGIT | '_' )* )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:600:7: LETTER ( LETTER | DIGIT | '_' )*
+            {
+            mLETTER(); 
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:600:14: ( LETTER | DIGIT | '_' )*
+            loop8:
+            do {
+                int alt8=2;
+                int LA8_0 = input.LA(1);
+
+                if ( ((LA8_0>='0' && LA8_0<='9')||(LA8_0>='A' && LA8_0<='Z')||LA8_0=='_'||(LA8_0>='a' && LA8_0<='z')) ) {
+                    alt8=1;
+                }
+
+
+                switch (alt8) {
+            	case 1 :
+            	    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:
+            	    {
+            	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+            	        input.consume();
+
+            	    }
+            	    else {
+            	        MismatchedSetException mse = new MismatchedSetException(null,input);
+            	        recover(mse);
+            	        throw mse;}
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop8;
+                }
+            } while (true);
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "IDENT"
+
+    // $ANTLR start "COMPIDENT"
+    public final void mCOMPIDENT() throws RecognitionException {
+        try {
+            int _type = COMPIDENT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:604:5: ( IDENT ( ':' IDENT )* )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:604:7: IDENT ( ':' IDENT )*
+            {
+            mIDENT(); 
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:604:13: ( ':' IDENT )*
+            loop9:
+            do {
+                int alt9=2;
+                int LA9_0 = input.LA(1);
+
+                if ( (LA9_0==':') ) {
+                    alt9=1;
+                }
+
+
+                switch (alt9) {
+            	case 1 :
+            	    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:604:15: ':' IDENT
+            	    {
+            	    match(':'); 
+            	    mIDENT(); 
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop9;
+                }
+            } while (true);
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "COMPIDENT"
+
+    // $ANTLR start "UUID"
+    public final void mUUID() throws RecognitionException {
+        try {
+            int _type = UUID;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:608:5: ( HEX HEX HEX HEX HEX HEX HEX HEX '-' HEX HEX HEX HEX '-' HEX HEX HEX HEX '-' HEX HEX HEX HEX '-' HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:608:7: HEX HEX HEX HEX HEX HEX HEX HEX '-' HEX HEX HEX HEX '-' HEX HEX HEX HEX '-' HEX HEX HEX HEX '-' HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX
+            {
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            match('-'); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            match('-'); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            match('-'); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            match('-'); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+            mHEX(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "UUID"
+
+    // $ANTLR start "WS"
+    public final void mWS() throws RecognitionException {
+        try {
+            int _type = WS;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:616:5: ( ( ' ' | '\\t' | '\\n' | '\\r' )+ )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:616:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
+            {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:616:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
+            int cnt10=0;
+            loop10:
+            do {
+                int alt10=2;
+                int LA10_0 = input.LA(1);
+
+                if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) {
+                    alt10=1;
+                }
+
+
+                switch (alt10) {
+            	case 1 :
+            	    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:
+            	    {
+            	    if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
+            	        input.consume();
+
+            	    }
+            	    else {
+            	        MismatchedSetException mse = new MismatchedSetException(null,input);
+            	        recover(mse);
+            	        throw mse;}
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    if ( cnt10 >= 1 ) break loop10;
+                        EarlyExitException eee =
+                            new EarlyExitException(10, input);
+                        throw eee;
+                }
+                cnt10++;
+            } while (true);
+
+             _channel = HIDDEN; 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "WS"
+
+    // $ANTLR start "COMMENT"
+    public final void mCOMMENT() throws RecognitionException {
+        try {
+            int _type = COMMENT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:620:5: ( ( '--' | '//' ) ( . )* ( '\\n' | '\\r' ) )
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:620:7: ( '--' | '//' ) ( . )* ( '\\n' | '\\r' )
+            {
+            // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:620:7: ( '--' | '//' )
+            int alt11=2;
+            int LA11_0 = input.LA(1);
+
+            if ( (LA11_0=='-') ) {
+                alt11=1;
+            }
+            else if ( (LA11_0=='/') ) {
+                alt11=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 11, 0, input);
+
+                throw nvae;
+            }
+            switch (alt11) {
+                case 1 :
+                    // /home/drift/svn/cassandra/trunk/src/java/org/apache/cassandra/cql/Cql.g:620:8: '--'
+                    {
+                    match("--"); 
+
+
+                    }

[... 1382 lines stripped ...]


Mime
View raw message