hadoop-common-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From st...@apache.org
Subject svn commit: r599162 [4/4] - in /lucene/hadoop/trunk/src/contrib/hbase: ./ src/java/org/apache/hadoop/hbase/mapred/ src/java/org/apache/hadoop/hbase/shell/ src/java/org/apache/hadoop/hbase/shell/algebra/ src/java/org/apache/hadoop/hbase/shell/algebra/ge...
Date Wed, 28 Nov 2007 22:10:27 GMT
Modified: lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserTokenManager.java
URL: http://svn.apache.org/viewvc/lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserTokenManager.java?rev=599162&r1=599161&r2=599162&view=diff
==============================================================================
--- lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserTokenManager.java (original)
+++ lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserTokenManager.java Wed Nov 28 14:10:21 2007
@@ -27,82 +27,87 @@
 import java.io.StringReader;
 import java.io.Reader;
 import java.io.Writer;
+import java.net.URLEncoder;
+import java.io.UnsupportedEncodingException;
 import org.apache.hadoop.hbase.shell.*;
 
 public class ParserTokenManager implements ParserConstants
 {
   public  java.io.PrintStream debugStream = System.out;
   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
-private final int jjStopStringLiteralDfa_0(int pos, long active0)
+private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
 {
    switch (pos)
    {
       case 0:
          if ((active0 & 0x800000000L) != 0L)
-            return 32;
-         if ((active0 & 0xfffe03ffffffe0L) != 0L)
+            return 3;
+         if ((active0 & 0x7fffe603ffffffe0L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             return 1;
          }
          return -1;
       case 1:
-         if ((active0 & 0x200002000L) != 0L)
+         if ((active0 & 0x4008040200032000L) != 0L)
             return 1;
-         if ((active0 & 0xfffe01ffffdfe0L) != 0L)
+         if ((active0 & 0x3ff7e201fffcdfe0L) != 0L)
          {
-            jjmatchedKind = 56;
-            jjmatchedPos = 1;
+            if (jjmatchedPos != 1)
+            {
+               jjmatchedKind = 63;
+               jjmatchedPos = 1;
+            }
             return 1;
          }
          return -1;
       case 2:
-         if ((active0 & 0x40000104004000L) != 0L)
+         if ((active0 & 0x400020104004000L) != 0L)
             return 1;
-         if ((active0 & 0xbffe00fbff9fe0L) != 0L)
+         if ((active0 & 0x3bffe000fbff9fe0L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 2;
             return 1;
          }
          return -1;
       case 3:
-         if ((active0 & 0x100002029720L) != 0L)
-            return 1;
-         if ((active0 & 0xbfee00f9fd08c0L) != 0L)
+         if ((active0 & 0x2bfee000f9fd08c0L) != 0L)
          {
             if (jjmatchedPos != 3)
             {
-               jjmatchedKind = 56;
+               jjmatchedKind = 63;
                jjmatchedPos = 3;
             }
             return 1;
          }
+         if ((active0 & 0x1001000002029720L) != 0L)
+            return 1;
          return -1;
       case 4:
-         if ((active0 & 0xbfce0078f90a00L) != 0L)
+         if ((active0 & 0xbfce00078f90a00L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 4;
             return 1;
          }
-         if ((active0 & 0x2000810400c0L) != 0L)
+         if ((active0 & 0x20020000810400c0L) != 0L)
             return 1;
          return -1;
       case 5:
-         if ((active0 & 0x3f8e0070c00200L) != 0L)
+         if ((active0 & 0x3f8e00070c00200L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 5;
             return 1;
          }
-         if ((active0 & 0x80400008390800L) != 0L)
+         if ((active0 & 0x804000008390800L) != 0L)
             return 1;
          return -1;
       case 6:
-         if ((active0 & 0x3f8e0070800200L) != 0L)
+         if ((active0 & 0x3f8e00070800200L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 6;
             return 1;
          }
@@ -110,130 +115,130 @@
             return 1;
          return -1;
       case 7:
-         if ((active0 & 0x2f8e0070000000L) != 0L)
+         if ((active0 & 0x2f8e00070000000L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 7;
             return 1;
          }
-         if ((active0 & 0x10000000800200L) != 0L)
+         if ((active0 & 0x100000000800200L) != 0L)
             return 1;
          return -1;
       case 8:
-         if ((active0 & 0x2f0e0050000000L) != 0L)
+         if ((active0 & 0x2f0e00050000000L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 8;
             return 1;
          }
-         if ((active0 & 0x800020000000L) != 0L)
+         if ((active0 & 0x8000020000000L) != 0L)
             return 1;
          return -1;
       case 9:
-         if ((active0 & 0x2f0a0050000000L) != 0L)
+         if ((active0 & 0x400000000000L) != 0L)
+            return 1;
+         if ((active0 & 0x2f0a00050000000L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 9;
             return 1;
          }
-         if ((active0 & 0x40000000000L) != 0L)
-            return 1;
          return -1;
       case 10:
-         if ((active0 & 0x29080000000000L) != 0L)
+         if ((active0 & 0x290800000000000L) != 0L)
             return 1;
-         if ((active0 & 0x6020050000000L) != 0L)
+         if ((active0 & 0x60200050000000L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 10;
             return 1;
          }
          return -1;
       case 11:
-         if ((active0 & 0x6000010000000L) != 0L)
+         if ((active0 & 0x200040000000L) != 0L)
+            return 1;
+         if ((active0 & 0x60000010000000L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 11;
             return 1;
          }
-         if ((active0 & 0x20040000000L) != 0L)
-            return 1;
          return -1;
       case 12:
-         if ((active0 & 0x6000010000000L) != 0L)
+         if ((active0 & 0x60000010000000L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 12;
             return 1;
          }
          return -1;
       case 13:
-         if ((active0 & 0x6000000000000L) != 0L)
+         if ((active0 & 0x10000000L) != 0L)
+            return 1;
+         if ((active0 & 0x60000000000000L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 13;
             return 1;
          }
-         if ((active0 & 0x10000000L) != 0L)
-            return 1;
          return -1;
       case 14:
-         if ((active0 & 0x6000000000000L) != 0L)
+         if ((active0 & 0x60000000000000L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 14;
             return 1;
          }
          return -1;
       case 15:
-         if ((active0 & 0x6000000000000L) != 0L)
+         if ((active0 & 0x60000000000000L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 15;
             return 1;
          }
          return -1;
       case 16:
-         if ((active0 & 0x6000000000000L) != 0L)
+         if ((active0 & 0x60000000000000L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 16;
             return 1;
          }
          return -1;
       case 17:
-         if ((active0 & 0x6000000000000L) != 0L)
+         if ((active0 & 0x60000000000000L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 17;
             return 1;
          }
          return -1;
       case 18:
-         if ((active0 & 0x6000000000000L) != 0L)
+         if ((active0 & 0x60000000000000L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 18;
             return 1;
          }
          return -1;
       case 19:
-         if ((active0 & 0x4000000000000L) != 0L)
+         if ((active0 & 0x40000000000000L) != 0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 63;
             jjmatchedPos = 19;
             return 1;
          }
-         if ((active0 & 0x2000000000000L) != 0L)
+         if ((active0 & 0x20000000000000L) != 0L)
             return 1;
          return -1;
       default :
          return -1;
    }
 }
-private final int jjStartNfa_0(int pos, long active0)
+private final int jjStartNfa_0(int pos, long active0, long active1)
 {
-   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
+   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
 }
 private final int jjStopAtPos(int pos, int kind)
 {
@@ -253,31 +258,35 @@
 {
    switch(curChar)
    {
+      case 33:
+         return jjMoveStringLiteralDfa1_0(0x80000000000L);
       case 40:
          return jjStopAtPos(0, 36);
       case 41:
          return jjStopAtPos(0, 37);
       case 42:
-         return jjStopAtPos(0, 40);
+         return jjStopAtPos(0, 44);
       case 44:
          return jjStopAtPos(0, 34);
       case 46:
-         return jjStartNfaWithStates_0(0, 35, 32);
+         return jjStartNfaWithStates_0(0, 35, 3);
       case 59:
-         return jjStopAtPos(0, 62);
+         return jjStopAtPos(0, 69);
       case 60:
-         return jjMoveStringLiteralDfa1_0(0x8000000000L);
+         return jjStopAtPos(0, 40);
       case 61:
          return jjStopAtPos(0, 38);
+      case 62:
+         return jjStopAtPos(0, 39);
       case 65:
       case 97:
-         return jjMoveStringLiteralDfa1_0(0x40000100000040L);
+         return jjMoveStringLiteralDfa1_0(0x400000100000040L);
       case 66:
       case 98:
-         return jjMoveStringLiteralDfa1_0(0x1200000000000L);
+         return jjMoveStringLiteralDfa1_0(0x4012000000000000L);
       case 67:
       case 99:
-         return jjMoveStringLiteralDfa1_0(0x82080010000880L);
+         return jjMoveStringLiteralDfa1_0(0x820800010000880L);
       case 68:
       case 100:
          return jjMoveStringLiteralDfa1_0(0x481600L);
@@ -287,12 +296,15 @@
       case 70:
       case 102:
          return jjMoveStringLiteralDfa1_0(0x2002000L);
+      case 71:
+      case 103:
+         return jjMoveStringLiteralDfa1_0(0x2000000000000000L);
       case 72:
       case 104:
          return jjMoveStringLiteralDfa1_0(0x20L);
       case 73:
       case 105:
-         return jjMoveStringLiteralDfa1_0(0x800000030000L);
+         return jjMoveStringLiteralDfa1_0(0x8040000030000L);
       case 74:
       case 106:
          return jjMoveStringLiteralDfa1_0(0x4000L);
@@ -301,25 +313,25 @@
          return jjMoveStringLiteralDfa1_0(0x80000000L);
       case 77:
       case 109:
-         return jjMoveStringLiteralDfa1_0(0x60000000000L);
+         return jjMoveStringLiteralDfa1_0(0x600000000000L);
       case 78:
       case 110:
-         return jjMoveStringLiteralDfa1_0(0x30100040000000L);
+         return jjMoveStringLiteralDfa1_0(0x301020040000000L);
       case 79:
       case 111:
          return jjMoveStringLiteralDfa1_0(0x200000000L);
       case 82:
       case 114:
-         return jjMoveStringLiteralDfa1_0(0x4400004000000L);
+         return jjMoveStringLiteralDfa1_0(0x44000004000000L);
       case 83:
       case 115:
-         return jjMoveStringLiteralDfa1_0(0x900100L);
+         return jjMoveStringLiteralDfa1_0(0x1000000000900100L);
       case 84:
       case 116:
          return jjMoveStringLiteralDfa1_0(0x20040000L);
       case 86:
       case 118:
-         return jjMoveStringLiteralDfa1_0(0x8000008000000L);
+         return jjMoveStringLiteralDfa1_0(0x80000008000000L);
       case 87:
       case 119:
          return jjMoveStringLiteralDfa1_0(0x1000000L);
@@ -331,44 +343,49 @@
 {
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(0, active0);
+      jjStopStringLiteralDfa_0(0, active0, 0L);
       return 1;
    }
    switch(curChar)
    {
-      case 62:
-         if ((active0 & 0x8000000000L) != 0L)
-            return jjStopAtPos(1, 39);
+      case 61:
+         if ((active0 & 0x80000000000L) != 0L)
+            return jjStopAtPos(1, 43);
          break;
       case 65:
       case 97:
-         return jjMoveStringLiteralDfa2_0(active0, 0x60008044000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x1000600008044000L);
       case 68:
       case 100:
-         return jjMoveStringLiteralDfa2_0(active0, 0x40000000000000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x400000000000000L);
       case 69:
       case 101:
-         return jjMoveStringLiteralDfa2_0(active0, 0xc400000180620L);
+         return jjMoveStringLiteralDfa2_0(active0, 0xc4000000180620L);
       case 72:
       case 104:
-         return jjMoveStringLiteralDfa2_0(active0, 0x80000001000100L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x800000001000100L);
       case 73:
       case 105:
          return jjMoveStringLiteralDfa2_0(active0, 0xa0400000L);
       case 76:
       case 108:
-         return jjMoveStringLiteralDfa2_0(active0, 0x12000000000c0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x120000000000c0L);
       case 78:
       case 110:
-         return jjMoveStringLiteralDfa2_0(active0, 0x800100230000L);
+         if ((active0 & 0x40000000000L) != 0L)
+         {
+            jjmatchedKind = 42;
+            jjmatchedPos = 1;
+         }
+         return jjMoveStringLiteralDfa2_0(active0, 0x8000100230000L);
       case 79:
       case 111:
-         return jjMoveStringLiteralDfa2_0(active0, 0x2180014000000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x21820014000000L);
       case 82:
       case 114:
          if ((active0 & 0x200000000L) != 0L)
             return jjStartNfaWithStates_0(1, 33, 1);
-         return jjMoveStringLiteralDfa2_0(active0, 0x2001800L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x2000000002001800L);
       case 83:
       case 115:
          if ((active0 & 0x2000L) != 0L)
@@ -379,43 +396,48 @@
          return jjMoveStringLiteralDfa2_0(active0, 0x800000L);
       case 85:
       case 117:
-         return jjMoveStringLiteralDfa2_0(active0, 0x30000040000000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x300000040000000L);
       case 88:
       case 120:
          return jjMoveStringLiteralDfa2_0(active0, 0x8000L);
+      case 89:
+      case 121:
+         if ((active0 & 0x4000000000000000L) != 0L)
+            return jjStartNfaWithStates_0(1, 62, 1);
+         break;
       default :
          break;
    }
-   return jjStartNfa_0(0, active0);
+   return jjStartNfa_0(0, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(0, old0); 
+      return jjStartNfa_0(0, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(1, active0);
+      jjStopStringLiteralDfa_0(1, active0, 0L);
       return 2;
    }
    switch(curChar)
    {
       case 95:
-         return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x8000000000000L);
       case 65:
       case 97:
-         return jjMoveStringLiteralDfa3_0(active0, 0x80000000a00000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x800000000a00000L);
       case 66:
       case 98:
          return jjMoveStringLiteralDfa3_0(active0, 0x40000L);
       case 67:
       case 99:
-         return jjMoveStringLiteralDfa3_0(active0, 0x8400000000000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x84000000000000L);
       case 68:
       case 100:
          if ((active0 & 0x100000000L) != 0L)
             return jjStartNfaWithStates_0(2, 32, 1);
-         else if ((active0 & 0x40000000000000L) != 0L)
-            return jjStartNfaWithStates_0(2, 54, 1);
+         else if ((active0 & 0x400000000000000L) != 0L)
+            return jjStartNfaWithStates_0(2, 58, 1);
          break;
       case 69:
       case 101:
@@ -428,13 +450,13 @@
          return jjMoveStringLiteralDfa3_0(active0, 0x18180020L);
       case 77:
       case 109:
-         return jjMoveStringLiteralDfa3_0(active0, 0x300800e0000000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x3008000e0000000L);
       case 78:
       case 110:
-         return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000L);
       case 79:
       case 111:
-         return jjMoveStringLiteralDfa3_0(active0, 0x1200002001100L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x2012000002001100L);
       case 82:
       case 114:
          if ((active0 & 0x4000L) != 0L)
@@ -445,10 +467,15 @@
          return jjMoveStringLiteralDfa3_0(active0, 0x410600L);
       case 84:
       case 116:
-         return jjMoveStringLiteralDfa3_0(active0, 0x4000000020040L);
+         if ((active0 & 0x20000000000L) != 0L)
+            return jjStartNfaWithStates_0(2, 41, 1);
+         return jjMoveStringLiteralDfa3_0(active0, 0x40000000020040L);
       case 85:
       case 117:
-         return jjMoveStringLiteralDfa3_0(active0, 0x2000000000000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x20000000000000L);
+      case 86:
+      case 118:
+         return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000000L);
       case 87:
       case 119:
          if ((active0 & 0x4000000L) != 0L)
@@ -456,25 +483,25 @@
          break;
       case 88:
       case 120:
-         return jjMoveStringLiteralDfa3_0(active0, 0x60000000000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x600000000000L);
       default :
          break;
    }
-   return jjStartNfa_0(1, active0);
+   return jjStartNfa_0(1, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(1, old0); 
+      return jjStartNfa_0(1, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(2, active0);
+      jjStopStringLiteralDfa_0(2, active0, 0L);
       return 3;
    }
    switch(curChar)
    {
       case 95:
-         return jjMoveStringLiteralDfa4_0(active0, 0x30060040000000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x300600040000000L);
       case 65:
       case 97:
          return jjMoveStringLiteralDfa4_0(active0, 0x400880L);
@@ -488,11 +515,13 @@
             jjmatchedKind = 10;
             jjmatchedPos = 3;
          }
-         return jjMoveStringLiteralDfa4_0(active0, 0x200000000200L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x2000000000200L);
       case 69:
       case 101:
-         if ((active0 & 0x100000000000L) != 0L)
-            return jjStartNfaWithStates_0(3, 44, 1);
+         if ((active0 & 0x1000000000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 48, 1);
+         else if ((active0 & 0x1000000000000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 60, 1);
          return jjMoveStringLiteralDfa4_0(active0, 0x20190040L);
       case 73:
       case 105:
@@ -504,22 +533,22 @@
       case 109:
          if ((active0 & 0x2000000L) != 0L)
             return jjStartNfaWithStates_0(3, 25, 1);
-         return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L);
       case 78:
       case 110:
-         return jjMoveStringLiteralDfa4_0(active0, 0x82000000000000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x820000000000000L);
       case 79:
       case 111:
          if ((active0 & 0x20000L) != 0L)
             return jjStartNfaWithStates_0(3, 17, 1);
-         return jjMoveStringLiteralDfa4_0(active0, 0x5400000000000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x54000000000000L);
       case 80:
       case 112:
          if ((active0 & 0x20L) != 0L)
             return jjStartNfaWithStates_0(3, 5, 1);
          else if ((active0 & 0x1000L) != 0L)
             return jjStartNfaWithStates_0(3, 12, 1);
-         return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L);
       case 82:
       case 114:
          return jjMoveStringLiteralDfa4_0(active0, 0x1800000L);
@@ -527,10 +556,10 @@
       case 116:
          if ((active0 & 0x8000L) != 0L)
             return jjStartNfaWithStates_0(3, 15, 1);
-         return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x80000000000000L);
       case 85:
       case 117:
-         return jjMoveStringLiteralDfa4_0(active0, 0x18000000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x2000000018000000L);
       case 87:
       case 119:
          if ((active0 & 0x100L) != 0L)
@@ -539,15 +568,15 @@
       default :
          break;
    }
-   return jjStartNfa_0(2, active0);
+   return jjStartNfa_0(2, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(2, old0); 
+      return jjStartNfa_0(2, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(3, active0);
+      jjStopStringLiteralDfa_0(3, active0, 0L);
       return 4;
    }
    switch(curChar)
@@ -564,34 +593,39 @@
             return jjStartNfaWithStates_0(4, 18, 1);
          else if ((active0 & 0x1000000L) != 0L)
             return jjStartNfaWithStates_0(4, 24, 1);
-         return jjMoveStringLiteralDfa5_0(active0, 0x20800008000000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x208000008000000L);
       case 71:
       case 103:
-         return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x800000000000000L);
       case 72:
       case 104:
-         return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L);
       case 75:
       case 107:
-         if ((active0 & 0x200000000000L) != 0L)
-            return jjStartNfaWithStates_0(4, 45, 1);
+         if ((active0 & 0x2000000000000L) != 0L)
+            return jjStartNfaWithStates_0(4, 49, 1);
          break;
       case 76:
       case 108:
-         return jjMoveStringLiteralDfa5_0(active0, 0x40000200000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x400000200000L);
       case 77:
       case 109:
-         return jjMoveStringLiteralDfa5_0(active0, 0x1000010000000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x10000010000000L);
       case 79:
       case 111:
-         return jjMoveStringLiteralDfa5_0(active0, 0x8000000000000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L);
+      case 80:
+      case 112:
+         if ((active0 & 0x2000000000000000L) != 0L)
+            return jjStartNfaWithStates_0(4, 61, 1);
+         break;
       case 82:
       case 114:
          if ((active0 & 0x40L) != 0L)
             return jjStartNfaWithStates_0(4, 6, 1);
          else if ((active0 & 0x80L) != 0L)
             return jjStartNfaWithStates_0(4, 7, 1);
-         return jjMoveStringLiteralDfa5_0(active0, 0x480000010200L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x4800000010200L);
       case 83:
       case 115:
          return jjMoveStringLiteralDfa5_0(active0, 0x20000000L);
@@ -599,39 +633,39 @@
       case 116:
          if ((active0 & 0x80000000L) != 0L)
             return jjStartNfaWithStates_0(4, 31, 1);
-         return jjMoveStringLiteralDfa5_0(active0, 0x2000000880800L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x20000000880800L);
       case 85:
       case 117:
-         return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x40000000000000L);
       case 86:
       case 118:
-         return jjMoveStringLiteralDfa5_0(active0, 0x20040000000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x200040000000L);
       default :
          break;
    }
-   return jjStartNfa_0(3, active0);
+   return jjStartNfa_0(3, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(3, old0); 
+      return jjStartNfa_0(3, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(4, active0);
+      jjStopStringLiteralDfa_0(4, active0, 0L);
       return 5;
    }
    switch(curChar)
    {
       case 65:
       case 97:
-         return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x100000000000000L);
       case 67:
       case 99:
-         return jjMoveStringLiteralDfa6_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x40000000000000L);
       case 68:
       case 100:
-         if ((active0 & 0x400000000000L) != 0L)
-            return jjStartNfaWithStates_0(5, 46, 1);
+         if ((active0 & 0x4000000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 50, 1);
          break;
       case 69:
       case 101:
@@ -641,27 +675,27 @@
             return jjStartNfaWithStates_0(5, 19, 1);
          else if ((active0 & 0x200000L) != 0L)
             return jjStartNfaWithStates_0(5, 21, 1);
-         else if ((active0 & 0x80000000000000L) != 0L)
-            return jjStartNfaWithStates_0(5, 55, 1);
-         return jjMoveStringLiteralDfa6_0(active0, 0xe0040000000L);
+         else if ((active0 & 0x800000000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 59, 1);
+         return jjMoveStringLiteralDfa6_0(active0, 0xe00040000000L);
       case 70:
       case 102:
-         return jjMoveStringLiteralDfa6_0(active0, 0x1000000000000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L);
       case 73:
       case 105:
-         return jjMoveStringLiteralDfa6_0(active0, 0x2000000800200L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x20000000800200L);
       case 76:
       case 108:
          return jjMoveStringLiteralDfa6_0(active0, 0x400000L);
       case 77:
       case 109:
-         return jjMoveStringLiteralDfa6_0(active0, 0x800000000000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x8000000000000L);
       case 78:
       case 110:
-         return jjMoveStringLiteralDfa6_0(active0, 0x20000010000000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x200000010000000L);
       case 82:
       case 114:
-         return jjMoveStringLiteralDfa6_0(active0, 0x8000000000000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x80000000000000L);
       case 83:
       case 115:
          if ((active0 & 0x8000000L) != 0L)
@@ -677,21 +711,21 @@
       default :
          break;
    }
-   return jjStartNfa_0(4, active0);
+   return jjStartNfa_0(4, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(4, old0); 
+      return jjStartNfa_0(4, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(5, active0);
+      jjStopStringLiteralDfa_0(5, active0, 0L);
       return 6;
    }
    switch(curChar)
    {
       case 95:
-         return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x80000000000000L);
       case 65:
       case 97:
          return jjMoveStringLiteralDfa7_0(active0, 0x20000000L);
@@ -708,37 +742,37 @@
          return jjMoveStringLiteralDfa7_0(active0, 0x10000000L);
       case 72:
       case 104:
-         return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x40000000000000L);
       case 73:
       case 105:
-         return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);
       case 78:
       case 110:
-         return jjMoveStringLiteralDfa7_0(active0, 0x2040000800000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x20400000800000L);
       case 79:
       case 111:
-         return jjMoveStringLiteralDfa7_0(active0, 0x800000000000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000L);
       case 82:
       case 114:
-         return jjMoveStringLiteralDfa7_0(active0, 0x20040000000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x200040000000L);
       case 83:
       case 115:
-         return jjMoveStringLiteralDfa7_0(active0, 0x10080000000000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x100800000000000L);
       case 84:
       case 116:
-         return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x200000000000000L);
       default :
          break;
    }
-   return jjStartNfa_0(5, active0);
+   return jjStartNfa_0(5, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(5, old0); 
+      return jjStartNfa_0(5, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(6, active0);
+      jjStopStringLiteralDfa_0(6, active0, 0L);
       return 7;
    }
    switch(curChar)
@@ -750,53 +784,53 @@
       case 101:
          if ((active0 & 0x200L) != 0L)
             return jjStartNfaWithStates_0(7, 9, 1);
-         return jjMoveStringLiteralDfa8_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x40000000000000L);
       case 71:
       case 103:
          if ((active0 & 0x800000L) != 0L)
             return jjStartNfaWithStates_0(7, 23, 1);
-         return jjMoveStringLiteralDfa8_0(active0, 0x2040000000000L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x20400000000000L);
       case 72:
       case 104:
-         if ((active0 & 0x10000000000000L) != 0L)
-            return jjStartNfaWithStates_0(7, 52, 1);
+         if ((active0 & 0x100000000000000L) != 0L)
+            return jjStartNfaWithStates_0(7, 56, 1);
          break;
       case 76:
       case 108:
-         return jjMoveStringLiteralDfa8_0(active0, 0x1000000000000L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x10000000000000L);
       case 77:
       case 109:
          return jjMoveStringLiteralDfa8_0(active0, 0x20000000L);
       case 82:
       case 114:
-         return jjMoveStringLiteralDfa8_0(active0, 0x20800000000000L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x208000000000000L);
       case 83:
       case 115:
-         return jjMoveStringLiteralDfa8_0(active0, 0x80a0040000000L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x80a00040000000L);
       default :
          break;
    }
-   return jjStartNfa_0(6, active0);
+   return jjStartNfa_0(6, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(6, old0); 
+      return jjStartNfa_0(6, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(7, active0);
+      jjStopStringLiteralDfa_0(7, active0, 0L);
       return 8;
    }
    switch(curChar)
    {
       case 95:
-         return jjMoveStringLiteralDfa9_0(active0, 0x2000000000000L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L);
       case 68:
       case 100:
-         return jjMoveStringLiteralDfa9_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x40000000000000L);
       case 73:
       case 105:
-         return jjMoveStringLiteralDfa9_0(active0, 0x280a0040000000L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x280a00040000000L);
       case 77:
       case 109:
          return jjMoveStringLiteralDfa9_0(active0, 0x10000000L);
@@ -807,104 +841,104 @@
          break;
       case 84:
       case 116:
-         return jjMoveStringLiteralDfa9_0(active0, 0x1040000000000L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x10400000000000L);
       case 89:
       case 121:
-         if ((active0 & 0x800000000000L) != 0L)
-            return jjStartNfaWithStates_0(8, 47, 1);
+         if ((active0 & 0x8000000000000L) != 0L)
+            return jjStartNfaWithStates_0(8, 51, 1);
          break;
       default :
          break;
    }
-   return jjStartNfa_0(7, active0);
+   return jjStartNfa_0(7, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(7, old0); 
+      return jjStartNfa_0(7, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(8, active0);
+      jjStopStringLiteralDfa_0(8, active0, 0L);
       return 9;
    }
    switch(curChar)
    {
       case 95:
-         return jjMoveStringLiteralDfa10_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x40000000000000L);
       case 66:
       case 98:
-         return jjMoveStringLiteralDfa10_0(active0, 0x2000000000000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x20000000000000L);
       case 69:
       case 101:
-         return jjMoveStringLiteralDfa10_0(active0, 0x21000000000000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x210000000000000L);
       case 72:
       case 104:
-         if ((active0 & 0x40000000000L) != 0L)
-            return jjStartNfaWithStates_0(9, 42, 1);
+         if ((active0 & 0x400000000000L) != 0L)
+            return jjStartNfaWithStates_0(9, 46, 1);
          break;
       case 73:
       case 105:
          return jjMoveStringLiteralDfa10_0(active0, 0x10000000L);
       case 79:
       case 111:
-         return jjMoveStringLiteralDfa10_0(active0, 0xa0040000000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0xa00040000000L);
       case 90:
       case 122:
-         return jjMoveStringLiteralDfa10_0(active0, 0x8000000000000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x80000000000000L);
       default :
          break;
    }
-   return jjStartNfa_0(8, active0);
+   return jjStartNfa_0(8, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(8, old0); 
+      return jjStartNfa_0(8, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(9, active0);
+      jjStopStringLiteralDfa_0(9, active0, 0L);
       return 10;
    }
    switch(curChar)
    {
       case 66:
       case 98:
-         return jjMoveStringLiteralDfa11_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x40000000000000L);
       case 69:
       case 101:
-         if ((active0 & 0x8000000000000L) != 0L)
-            return jjStartNfaWithStates_0(10, 51, 1);
+         if ((active0 & 0x80000000000000L) != 0L)
+            return jjStartNfaWithStates_0(10, 55, 1);
          break;
       case 76:
       case 108:
-         return jjMoveStringLiteralDfa11_0(active0, 0x2000010000000L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x20000010000000L);
       case 78:
       case 110:
-         if ((active0 & 0x80000000000L) != 0L)
-            return jjStartNfaWithStates_0(10, 43, 1);
-         return jjMoveStringLiteralDfa11_0(active0, 0x20040000000L);
+         if ((active0 & 0x800000000000L) != 0L)
+            return jjStartNfaWithStates_0(10, 47, 1);
+         return jjMoveStringLiteralDfa11_0(active0, 0x200040000000L);
       case 82:
       case 114:
-         if ((active0 & 0x1000000000000L) != 0L)
-            return jjStartNfaWithStates_0(10, 48, 1);
+         if ((active0 & 0x10000000000000L) != 0L)
+            return jjStartNfaWithStates_0(10, 52, 1);
          break;
       case 83:
       case 115:
-         if ((active0 & 0x20000000000000L) != 0L)
-            return jjStartNfaWithStates_0(10, 53, 1);
+         if ((active0 & 0x200000000000000L) != 0L)
+            return jjStartNfaWithStates_0(10, 57, 1);
          break;
       default :
          break;
    }
-   return jjStartNfa_0(9, active0);
+   return jjStartNfa_0(9, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(9, old0); 
+      return jjStartNfa_0(9, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(10, active0);
+      jjStopStringLiteralDfa_0(10, active0, 0L);
       return 11;
    }
    switch(curChar)
@@ -914,29 +948,29 @@
          return jjMoveStringLiteralDfa12_0(active0, 0x10000000L);
       case 76:
       case 108:
-         return jjMoveStringLiteralDfa12_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x40000000000000L);
       case 79:
       case 111:
-         return jjMoveStringLiteralDfa12_0(active0, 0x2000000000000L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x20000000000000L);
       case 83:
       case 115:
          if ((active0 & 0x40000000L) != 0L)
             return jjStartNfaWithStates_0(11, 30, 1);
-         else if ((active0 & 0x20000000000L) != 0L)
-            return jjStartNfaWithStates_0(11, 41, 1);
+         else if ((active0 & 0x200000000000L) != 0L)
+            return jjStartNfaWithStates_0(11, 45, 1);
          break;
       default :
          break;
    }
-   return jjStartNfa_0(10, active0);
+   return jjStartNfa_0(10, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa12_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(10, old0); 
+      return jjStartNfa_0(10, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(11, active0);
+      jjStopStringLiteralDfa_0(11, active0, 0L);
       return 12;
    }
    switch(curChar)
@@ -946,29 +980,29 @@
          return jjMoveStringLiteralDfa13_0(active0, 0x10000000L);
       case 79:
       case 111:
-         return jjMoveStringLiteralDfa13_0(active0, 0x6000000000000L);
+         return jjMoveStringLiteralDfa13_0(active0, 0x60000000000000L);
       default :
          break;
    }
-   return jjStartNfa_0(11, active0);
+   return jjStartNfa_0(11, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa13_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(11, old0); 
+      return jjStartNfa_0(11, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(12, active0);
+      jjStopStringLiteralDfa_0(12, active0, 0L);
       return 13;
    }
    switch(curChar)
    {
       case 77:
       case 109:
-         return jjMoveStringLiteralDfa14_0(active0, 0x2000000000000L);
+         return jjMoveStringLiteralDfa14_0(active0, 0x20000000000000L);
       case 79:
       case 111:
-         return jjMoveStringLiteralDfa14_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa14_0(active0, 0x40000000000000L);
       case 83:
       case 115:
          if ((active0 & 0x10000000L) != 0L)
@@ -977,162 +1011,162 @@
       default :
          break;
    }
-   return jjStartNfa_0(12, active0);
+   return jjStartNfa_0(12, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa14_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(12, old0); 
+      return jjStartNfa_0(12, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(13, active0);
+      jjStopStringLiteralDfa_0(13, active0, 0L);
       return 14;
    }
    switch(curChar)
    {
       case 70:
       case 102:
-         return jjMoveStringLiteralDfa15_0(active0, 0x2000000000000L);
+         return jjMoveStringLiteralDfa15_0(active0, 0x20000000000000L);
       case 77:
       case 109:
-         return jjMoveStringLiteralDfa15_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa15_0(active0, 0x40000000000000L);
       default :
          break;
    }
-   return jjStartNfa_0(13, active0);
+   return jjStartNfa_0(13, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa15_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(13, old0); 
+      return jjStartNfa_0(13, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(14, active0);
+      jjStopStringLiteralDfa_0(14, active0, 0L);
       return 15;
    }
    switch(curChar)
    {
       case 70:
       case 102:
-         return jjMoveStringLiteralDfa16_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa16_0(active0, 0x40000000000000L);
       case 73:
       case 105:
-         return jjMoveStringLiteralDfa16_0(active0, 0x2000000000000L);
+         return jjMoveStringLiteralDfa16_0(active0, 0x20000000000000L);
       default :
          break;
    }
-   return jjStartNfa_0(14, active0);
+   return jjStartNfa_0(14, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa16_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(14, old0); 
+      return jjStartNfa_0(14, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(15, active0);
+      jjStopStringLiteralDfa_0(15, active0, 0L);
       return 16;
    }
    switch(curChar)
    {
       case 73:
       case 105:
-         return jjMoveStringLiteralDfa17_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa17_0(active0, 0x40000000000000L);
       case 76:
       case 108:
-         return jjMoveStringLiteralDfa17_0(active0, 0x2000000000000L);
+         return jjMoveStringLiteralDfa17_0(active0, 0x20000000000000L);
       default :
          break;
    }
-   return jjStartNfa_0(15, active0);
+   return jjStartNfa_0(15, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa17_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(15, old0); 
+      return jjStartNfa_0(15, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(16, active0);
+      jjStopStringLiteralDfa_0(16, active0, 0L);
       return 17;
    }
    switch(curChar)
    {
       case 76:
       case 108:
-         return jjMoveStringLiteralDfa18_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa18_0(active0, 0x40000000000000L);
       case 84:
       case 116:
-         return jjMoveStringLiteralDfa18_0(active0, 0x2000000000000L);
+         return jjMoveStringLiteralDfa18_0(active0, 0x20000000000000L);
       default :
          break;
    }
-   return jjStartNfa_0(16, active0);
+   return jjStartNfa_0(16, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa18_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(16, old0); 
+      return jjStartNfa_0(16, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(17, active0);
+      jjStopStringLiteralDfa_0(17, active0, 0L);
       return 18;
    }
    switch(curChar)
    {
       case 69:
       case 101:
-         return jjMoveStringLiteralDfa19_0(active0, 0x2000000000000L);
+         return jjMoveStringLiteralDfa19_0(active0, 0x20000000000000L);
       case 84:
       case 116:
-         return jjMoveStringLiteralDfa19_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa19_0(active0, 0x40000000000000L);
       default :
          break;
    }
-   return jjStartNfa_0(17, active0);
+   return jjStartNfa_0(17, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa19_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(17, old0); 
+      return jjStartNfa_0(17, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(18, active0);
+      jjStopStringLiteralDfa_0(18, active0, 0L);
       return 19;
    }
    switch(curChar)
    {
       case 69:
       case 101:
-         return jjMoveStringLiteralDfa20_0(active0, 0x4000000000000L);
+         return jjMoveStringLiteralDfa20_0(active0, 0x40000000000000L);
       case 82:
       case 114:
-         if ((active0 & 0x2000000000000L) != 0L)
-            return jjStartNfaWithStates_0(19, 49, 1);
+         if ((active0 & 0x20000000000000L) != 0L)
+            return jjStartNfaWithStates_0(19, 53, 1);
          break;
       default :
          break;
    }
-   return jjStartNfa_0(18, active0);
+   return jjStartNfa_0(18, active0, 0L);
 }
 private final int jjMoveStringLiteralDfa20_0(long old0, long active0)
 {
    if (((active0 &= old0)) == 0L)
-      return jjStartNfa_0(18, old0); 
+      return jjStartNfa_0(18, old0, 0L);
    try { curChar = input_stream.readChar(); }
    catch(java.io.IOException e) {
-      jjStopStringLiteralDfa_0(19, active0);
+      jjStopStringLiteralDfa_0(19, active0, 0L);
       return 20;
    }
    switch(curChar)
    {
       case 82:
       case 114:
-         if ((active0 & 0x4000000000000L) != 0L)
-            return jjStartNfaWithStates_0(20, 50, 1);
+         if ((active0 & 0x40000000000000L) != 0L)
+            return jjStartNfaWithStates_0(20, 54, 1);
          break;
       default :
          break;
    }
-   return jjStartNfa_0(19, active0);
+   return jjStartNfa_0(19, active0, 0L);
 }
 private final void jjCheckNAdd(int state)
 {
@@ -1189,42 +1223,28 @@
                case 0:
                   if ((0x3ff000000000000L & l) != 0L)
                   {
-                     if (kind > 57)
-                        kind = 57;
+                     if (kind > 64)
+                        kind = 64;
                      jjCheckNAddStates(0, 6);
                   }
-                  else if ((0x400e00000000000L & l) != 0L)
+                  else if ((0x400a00000000000L & l) != 0L)
                   {
-                     if (kind > 56)
-                        kind = 56;
+                     if (kind > 63)
+                        kind = 63;
                      jjCheckNAdd(1);
                   }
                   else if (curChar == 39)
                      jjCheckNAddStates(7, 9);
                   else if (curChar == 34)
                      jjCheckNAdd(8);
-                  if (curChar == 46)
+                  else if (curChar == 46)
                      jjCheckNAdd(3);
                   break;
-               case 32:
-                  if ((0x7ffe00000000000L & l) != 0L)
-                  {
-                     if (kind > 56)
-                        kind = 56;
-                     jjCheckNAdd(1);
-                  }
-                  if ((0x3ff000000000000L & l) != 0L)
-                  {
-                     if (kind > 58)
-                        kind = 58;
-                     jjCheckNAddTwoStates(3, 4);
-                  }
-                  break;
                case 1:
-                  if ((0x7ffe00000000000L & l) == 0L)
+                  if ((0x7ffa00000000000L & l) == 0L)
                      break;
-                  if (kind > 56)
-                     kind = 56;
+                  if (kind > 63)
+                     kind = 63;
                   jjCheckNAdd(1);
                   break;
                case 2:
@@ -1234,8 +1254,8 @@
                case 3:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
-                  if (kind > 58)
-                     kind = 58;
+                  if (kind > 65)
+                     kind = 65;
                   jjCheckNAddTwoStates(3, 4);
                   break;
                case 5:
@@ -1245,8 +1265,8 @@
                case 6:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
-                  if (kind > 58)
-                     kind = 58;
+                  if (kind > 65)
+                     kind = 65;
                   jjCheckNAdd(6);
                   break;
                case 7:
@@ -1258,8 +1278,8 @@
                      jjCheckNAddTwoStates(8, 9);
                   break;
                case 9:
-                  if (curChar == 34 && kind > 60)
-                     kind = 60;
+                  if (curChar == 34 && kind > 67)
+                     kind = 67;
                   break;
                case 10:
                   if (curChar == 39)
@@ -1282,21 +1302,21 @@
                      jjCheckNAddStates(10, 12);
                   break;
                case 15:
-                  if (curChar == 39 && kind > 61)
-                     kind = 61;
+                  if (curChar == 39 && kind > 68)
+                     kind = 68;
                   break;
                case 16:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
-                  if (kind > 57)
-                     kind = 57;
+                  if (kind > 64)
+                     kind = 64;
                   jjCheckNAddStates(0, 6);
                   break;
                case 17:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
-                  if (kind > 57)
-                     kind = 57;
+                  if (kind > 64)
+                     kind = 64;
                   jjCheckNAdd(17);
                   break;
                case 18:
@@ -1310,8 +1330,8 @@
                case 20:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
-                  if (kind > 58)
-                     kind = 58;
+                  if (kind > 65)
+                     kind = 65;
                   jjCheckNAddTwoStates(20, 21);
                   break;
                case 22:
@@ -1321,8 +1341,8 @@
                case 23:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
-                  if (kind > 58)
-                     kind = 58;
+                  if (kind > 65)
+                     kind = 65;
                   jjCheckNAdd(23);
                   break;
                case 24:
@@ -1336,15 +1356,15 @@
                case 27:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
-                  if (kind > 58)
-                     kind = 58;
+                  if (kind > 65)
+                     kind = 65;
                   jjCheckNAdd(27);
                   break;
                case 28:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
-                  if (kind > 58)
-                     kind = 58;
+                  if (kind > 65)
+                     kind = 65;
                   jjCheckNAddTwoStates(28, 29);
                   break;
                case 30:
@@ -1354,8 +1374,8 @@
                case 31:
                   if ((0x3ff000000000000L & l) == 0L)
                      break;
-                  if (kind > 58)
-                     kind = 58;
+                  if (kind > 65)
+                     kind = 65;
                   jjCheckNAdd(31);
                   break;
                default : break;
@@ -1370,18 +1390,11 @@
             switch(jjstateSet[--i])
             {
                case 0:
-                  if ((0x7fffffe87fffffeL & l) == 0L)
-                     break;
-                  if (kind > 56)
-                     kind = 56;
-                  jjCheckNAdd(1);
-                  break;
-               case 32:
                case 1:
                   if ((0x7fffffe87fffffeL & l) == 0L)
                      break;
-                  if (kind > 56)
-                     kind = 56;
+                  if (kind > 63)
+                     kind = 63;
                   jjCheckNAdd(1);
                   break;
                case 4:
@@ -1457,17 +1470,18 @@
 public static final String[] jjstrLiteralImages = {
 "", null, null, null, null, null, null, null, null, null, null, null, null, 
 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
-null, null, null, null, null, null, null, "\54", "\56", "\50", "\51", "\75", 
-"\74\76", "\52", null, null, null, null, null, null, null, null, null, null, null, null, 
-null, null, null, null, null, null, null, null, null, "\73", };
+null, null, null, null, null, null, null, "\54", "\56", "\50", "\51", "\75", "\76", 
+"\74", null, null, "\41\75", "\52", null, null, null, null, null, null, null, null, 
+null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
+null, null, "\73", };
 public static final String[] lexStateNames = {
    "DEFAULT", 
 };
 static final long[] jjtoToken = {
-   0x77ffffffffffffe1L, 
+   0xffffffffffffffe1L, 0x3bL, 
 };
 static final long[] jjtoSkip = {
-   0x1eL, 
+   0x1eL, 0x0L, 
 };
 protected SimpleCharStream input_stream;
 private final int[] jjrounds = new int[32];

Added: lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/TestSubstitutionVariables.java
URL: http://svn.apache.org/viewvc/lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/TestSubstitutionVariables.java?rev=599162&view=auto
==============================================================================
--- lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/TestSubstitutionVariables.java (added)
+++ lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/TestSubstitutionVariables.java Wed Nov 28 14:10:21 2007
@@ -0,0 +1,74 @@
+/**
+ * Copyright 2007 The Apache Software Foundation
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.shell;
+
+import java.io.OutputStreamWriter;
+import java.io.UnsupportedEncodingException;
+import java.io.Writer;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import junit.textui.TestRunner;
+
+import org.apache.hadoop.hbase.HBaseConfiguration;
+import org.apache.hadoop.hbase.shell.algebra.Constants;
+import org.apache.hadoop.hbase.shell.algebra.TestBooleanCondition;
+
+/**
+ * Binding variables, substitution variables test
+ */
+public class TestSubstitutionVariables extends TestCase {
+  
+  private String TABLE_NAME = "table_name";
+  private String SUBSTITUTION_VARIABLE = "A";
+  static HBaseConfiguration conf = new HBaseConfiguration();
+  
+  public void testSubstitution() {
+    SubstituteCommand substitute = new SubstituteCommand(null);
+    
+    substitute.setKey(SUBSTITUTION_VARIABLE);
+    substitute.setInput(TABLE_NAME);
+    substitute.execute(conf);
+    
+    VariableRef ref = VariablesPool.get(SUBSTITUTION_VARIABLE).get(null);
+    assertTrue(ref.getArgument().equals(TABLE_NAME));
+  }
+  
+  public void testCombinedQueries() throws UnsupportedEncodingException {
+    Writer out = new OutputStreamWriter(System.out, "UTF-8");
+    SubstituteCommand substitute = new SubstituteCommand(out);
+    
+    substitute.setKey(SUBSTITUTION_VARIABLE);
+    substitute.setInput(TABLE_NAME);
+    substitute.execute(conf);
+    
+    substitute = new SubstituteCommand(out);
+    substitute.setKey("B");
+    substitute.setChainKey(SUBSTITUTION_VARIABLE);
+    substitute.setOperation(Constants.RELATIONAL_SELECTION);
+    substitute.setCondition(TestBooleanCondition.EXPRESSION_OR);
+    substitute.execute(conf);
+  }
+  
+  public static void main(String[] args) {
+    TestRunner.run(new TestSuite(TestSubstitutionVariables.class));
+  }
+  
+}

Added: lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestBooleanCondition.java
URL: http://svn.apache.org/viewvc/lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestBooleanCondition.java?rev=599162&view=auto
==============================================================================
--- lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestBooleanCondition.java (added)
+++ lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestBooleanCondition.java Wed Nov 28 14:10:21 2007
@@ -0,0 +1,84 @@
+/**
+ * Copyright 2007 The Apache Software Foundation
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.shell.algebra;
+
+import java.io.UnsupportedEncodingException;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import junit.textui.TestRunner;
+
+import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
+import org.apache.hadoop.hbase.shell.algebra.generated.ExpressionParser;
+import org.apache.hadoop.hbase.shell.algebra.generated.ParseException;
+import org.apache.hadoop.io.MapWritable;
+import org.apache.hadoop.io.Text;
+
+/**
+ * Test boolean expression
+ */
+public class TestBooleanCondition extends TestCase {
+  ExpressionParser expression;
+  public static String EXPRESSION_OR = "key:2 = value2 OR key:3 = value1";
+  public static String EXPRESSION_AND = "key:2 = value2 AND key:3 = value1";
+  public static String EXPRESSION = "key:3 > 1";
+  public static String TERM_FILTER = "key:4 > 100 AND key:4 !! 110|120|130|140|150";
+
+  Text[] keys = { new Text("key:1"), new Text("key:2"), new Text("key:3"), new Text("key:4") };
+
+  ImmutableBytesWritable[] values = {
+      new ImmutableBytesWritable("value1".getBytes()),
+      new ImmutableBytesWritable("value2".getBytes()),
+      new ImmutableBytesWritable("3".getBytes()),
+      new ImmutableBytesWritable("150".getBytes())
+  };
+
+  public void testCheckConstraints() throws UnsupportedEncodingException {
+    MapWritable data = new MapWritable();
+    for (int i = 0; i < keys.length; i++) {
+      data.put(keys[i], values[i]);
+    }
+
+    try {
+      expression = new ExpressionParser(EXPRESSION_OR);
+      expression.booleanExpressionParse();
+      assertTrue(expression.checkConstraints(data));
+
+      expression = new ExpressionParser(EXPRESSION_AND);
+      expression.booleanExpressionParse();
+      assertFalse(expression.checkConstraints(data));
+
+      expression = new ExpressionParser(EXPRESSION);
+      expression.booleanExpressionParse();
+      assertTrue(expression.checkConstraints(data));
+      
+      expression = new ExpressionParser(TERM_FILTER);
+      expression.booleanExpressionParse();
+      assertFalse(expression.checkConstraints(data));
+    } catch (ParseException e) {
+      e.printStackTrace();
+    }
+  }
+
+  public static void main(String[] args) {
+    TestRunner.run(new TestSuite(TestBooleanCondition.class));
+  }
+
+}

Added: lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestBooleanTermFilter.java
URL: http://svn.apache.org/viewvc/lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestBooleanTermFilter.java?rev=599162&view=auto
==============================================================================
--- lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestBooleanTermFilter.java (added)
+++ lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestBooleanTermFilter.java Wed Nov 28 14:10:21 2007
@@ -0,0 +1,250 @@
+/**
+ * Copyright 2007 The Apache Software Foundation
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.shell.algebra;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.Random;
+import java.util.TreeMap;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.hadoop.dfs.MiniDFSCluster;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.hbase.HBaseAdmin;
+import org.apache.hadoop.hbase.HBaseConfiguration;
+import org.apache.hadoop.hbase.HColumnDescriptor;
+import org.apache.hadoop.hbase.HConstants;
+import org.apache.hadoop.hbase.HScannerInterface;
+import org.apache.hadoop.hbase.HStoreKey;
+import org.apache.hadoop.hbase.HTable;
+import org.apache.hadoop.hbase.HTableDescriptor;
+import org.apache.hadoop.hbase.MasterNotRunningException;
+import org.apache.hadoop.hbase.MiniHBaseCluster;
+import org.apache.hadoop.hbase.MultiRegionTable;
+import org.apache.hadoop.hbase.mapred.IdentityTableReduce;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapred.JobClient;
+import org.apache.hadoop.mapred.JobConf;
+import org.apache.hadoop.mapred.MiniMRCluster;
+
+public class TestBooleanTermFilter extends MultiRegionTable {
+  @SuppressWarnings("hiding")
+  private static final Log LOG = LogFactory.getLog(TestBooleanTermFilter.class
+      .getName());
+
+  static final String INPUT_TABLE = "test_table";
+  static final String OUTPUT_TABLE = "result_table";
+  static final Text COUNT_COLUMNFAMILY = new Text("count:");
+  static final Text RANDOMINT_COLUMNFAMILY = new Text("randomInt:");
+  static final String GROUP_COLUMN_FAMILIES = "count: randomInt:";
+  static final String BOOLEAN_TERM = "randomInt: > 100 AND count: <= 100 AND randomInt: !! 110|120|130|140|150";
+  private MiniDFSCluster dfsCluster = null;
+  private FileSystem fs;
+  private Path dir;
+  private MiniHBaseCluster hCluster = null;
+
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public void setUp() throws Exception {
+    super.setUp();
+    conf.setLong("hbase.hregion.max.filesize", 256 * 1024);
+    dfsCluster = new MiniDFSCluster(conf, 1, true, (String[]) null);
+    try {
+      fs = dfsCluster.getFileSystem();
+      dir = new Path("/hbase");
+      fs.mkdirs(dir);
+      // Start up HBase cluster
+      hCluster = new MiniHBaseCluster(conf, 1, dfsCluster);
+    } catch (Exception e) {
+      if (dfsCluster != null) {
+        dfsCluster.shutdown();
+        dfsCluster = null;
+      }
+      throw e;
+    }
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public void tearDown() throws Exception {
+    super.tearDown();
+    if (hCluster != null) {
+      hCluster.shutdown();
+    }
+
+    if (dfsCluster != null) {
+      dfsCluster.shutdown();
+    }
+
+    if (fs != null) {
+      try {
+        fs.close();
+      } catch (IOException e) {
+        LOG.info("During tear down got a " + e.getMessage());
+      }
+    }
+  }
+
+  public void testBooleanFilterMapReduce() {
+    try {
+      HTableDescriptor desc = new HTableDescriptor(INPUT_TABLE);
+      String[] columns = GROUP_COLUMN_FAMILIES.split(" ");
+      for (int i = 0; i < columns.length; i++) {
+        desc.addFamily(new HColumnDescriptor(columns[i]));
+      }
+      HBaseAdmin admin = new HBaseAdmin(this.conf);
+      admin.createTable(desc);
+
+      // insert random data into the input table
+      HTable table = new HTable(conf, new Text(INPUT_TABLE));
+      Random oRandom = new Random();
+
+      for (int j = 0; j < 200; j++) {
+        int i = oRandom.nextInt(200) + 1;
+
+        long lockid = table.startUpdate(new Text("rowKey" + j));
+        table.put(lockid, COUNT_COLUMNFAMILY, Integer.toString(j).getBytes(
+            HConstants.UTF8_ENCODING));
+        table.put(lockid, RANDOMINT_COLUMNFAMILY, Integer.toString(i).getBytes(
+            HConstants.UTF8_ENCODING));
+        table.commit(lockid, System.currentTimeMillis());
+      }
+
+      long lockid = table.startUpdate(new Text("rowKey2001"));
+      table.put(lockid, COUNT_COLUMNFAMILY, "12"
+          .getBytes(HConstants.UTF8_ENCODING));
+      table.put(lockid, RANDOMINT_COLUMNFAMILY, "120"
+          .getBytes(HConstants.UTF8_ENCODING));
+      table.commit(lockid, System.currentTimeMillis());
+
+    } catch (MasterNotRunningException e) {
+      e.printStackTrace();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+
+    try {
+      HTableDescriptor output = new HTableDescriptor(OUTPUT_TABLE);
+      String[] columns = GROUP_COLUMN_FAMILIES.split(" ");
+      for (int i = 0; i < columns.length; i++) {
+        output.addFamily(new HColumnDescriptor(columns[i]));
+      }
+      // create output table
+      HBaseAdmin admin = new HBaseAdmin(this.conf);
+      admin.createTable(output);
+    } catch (MasterNotRunningException e) {
+      e.printStackTrace();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+
+    MiniMRCluster mrCluster = null;
+    try {
+      mrCluster = new MiniMRCluster(2, fs.getUri().toString(), 1);
+
+      JobConf jobConf = new JobConf(conf, TestBooleanTermFilter.class);
+      jobConf.setJobName("process boolean term filter mapreduce");
+      jobConf.setNumMapTasks(2);
+      jobConf.setNumReduceTasks(1);
+
+      IdentityFilterMap.initJob(INPUT_TABLE, GROUP_COLUMN_FAMILIES,
+          BOOLEAN_TERM, IdentityFilterMap.class, jobConf);
+
+      IdentityTableReduce.initJob(OUTPUT_TABLE, IdentityTableReduce.class,
+          jobConf);
+
+      JobClient.runJob(jobConf);
+
+    } catch (IOException e) {
+      e.printStackTrace();
+    } finally {
+      mrCluster.shutdown();
+    }
+
+    try {
+      verify(conf, OUTPUT_TABLE);
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+
+  /**
+   * Check the filtered value
+   * 
+   * @param conf
+   * @param outputTable
+   * @throws IOException
+   */
+  private void verify(HBaseConfiguration conf, String outputTable)
+      throws IOException {
+    HTable table = new HTable(conf, new Text(outputTable));
+    Text[] columns = { COUNT_COLUMNFAMILY, RANDOMINT_COLUMNFAMILY };
+    HScannerInterface scanner = table.obtainScanner(columns,
+        HConstants.EMPTY_START_ROW);
+
+    try {
+      HStoreKey key = new HStoreKey();
+      TreeMap<Text, byte[]> results = new TreeMap<Text, byte[]>();
+
+      int i = 0;
+      while (scanner.next(key, results)) {
+        for (Map.Entry<Text, byte[]> e : results.entrySet()) {
+          if (e.getKey().equals(COUNT_COLUMNFAMILY)) {
+            if (Integer.parseInt(new String(e.getValue())) > 100) {
+              LOG.info("result_table.count: " + new String(e.getValue()));
+            }
+            assertTrue((Integer.parseInt(new String(e.getValue())) <= 100));
+          } else {
+            if (Integer.parseInt(new String(e.getValue())) <= 100
+                || !checkNotInList(Integer.parseInt(new String(e.getValue())))) {
+              LOG.info("result_table.randomInt: " + new String(e.getValue()));
+            }
+            assertTrue((Integer.parseInt(new String(e.getValue())) > 100 && checkNotInList(Integer
+                .parseInt(new String(e.getValue())))));
+          }
+          i++;
+        }
+      }
+
+      assertTrue(i > 0);
+      if (i <= 0) {
+        LOG.info("result_table.rowNumber: " + i);
+      }
+
+    } finally {
+      scanner.close();
+    }
+
+  }
+
+  /**
+   * Check 'NOT IN' filter-list
+   */
+  private boolean checkNotInList(int parseInt) {
+    return (parseInt != 110 && parseInt != 120 && parseInt != 130
+        && parseInt != 140 && parseInt != 150) ? true : false;
+  }
+}

Added: lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestJoinCondition.java
URL: http://svn.apache.org/viewvc/lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestJoinCondition.java?rev=599162&view=auto
==============================================================================
--- lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestJoinCondition.java (added)
+++ lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestJoinCondition.java Wed Nov 28 14:10:21 2007
@@ -0,0 +1,45 @@
+/**
+ * Copyright 2007 The Apache Software Foundation
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.shell.algebra;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import junit.textui.TestRunner;
+
+import org.apache.hadoop.hbase.shell.algebra.generated.ExpressionParser;
+import org.apache.hadoop.hbase.shell.algebra.generated.ParseException;
+
+public class TestJoinCondition extends TestCase {
+  ExpressionParser expressionParser;
+  public static String EXPRESSION = "a.ROW = b.size BOOL a.length = b.length AND a.name = edward";
+  
+  public void testJoinCondition() {
+    expressionParser = new ExpressionParser(EXPRESSION);
+    try {
+      expressionParser.joinExpressionParse();
+    } catch (ParseException e) {
+      e.printStackTrace();
+    }
+  }
+
+  public static void main(String[] args) {
+    TestRunner.run(new TestSuite(TestJoinCondition.class));
+  }
+}

Added: lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestTableJoinMapReduce.java
URL: http://svn.apache.org/viewvc/lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestTableJoinMapReduce.java?rev=599162&view=auto
==============================================================================
--- lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestTableJoinMapReduce.java (added)
+++ lucene/hadoop/trunk/src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/algebra/TestTableJoinMapReduce.java Wed Nov 28 14:10:21 2007
@@ -0,0 +1,238 @@
+/**
+ * Copyright 2007 The Apache Software Foundation
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.shell.algebra;
+
+import java.io.IOException;
+import java.util.TreeMap;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.hadoop.dfs.MiniDFSCluster;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.hbase.HBaseAdmin;
+import org.apache.hadoop.hbase.HBaseConfiguration;
+import org.apache.hadoop.hbase.HColumnDescriptor;
+import org.apache.hadoop.hbase.HConstants;
+import org.apache.hadoop.hbase.HScannerInterface;
+import org.apache.hadoop.hbase.HStoreKey;
+import org.apache.hadoop.hbase.HTable;
+import org.apache.hadoop.hbase.HTableDescriptor;
+import org.apache.hadoop.hbase.MasterNotRunningException;
+import org.apache.hadoop.hbase.MiniHBaseCluster;
+import org.apache.hadoop.hbase.MultiRegionTable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapred.JobClient;
+import org.apache.hadoop.mapred.JobConf;
+import org.apache.hadoop.mapred.MiniMRCluster;
+
+public class TestTableJoinMapReduce extends MultiRegionTable {
+  @SuppressWarnings("hiding")
+  private static final Log LOG = LogFactory.getLog(TestTableJoinMapReduce.class
+      .getName());
+  static final String FIRST_RELATION = "r1";
+  static final String SECOND_RELATION = "r2";
+  static final String JOIN_EXPRESSION = "r1.c: = r2.ROW BOOL ";
+  static final String FIRST_COLUMNS = "a: b: c:";
+  static final String SECOND_COLUMNS = "d: e:";
+  static final String OUTPUT_TABLE = "result_table";
+  private MiniDFSCluster dfsCluster = null;
+  private FileSystem fs;
+  private Path dir;
+  private MiniHBaseCluster hCluster = null;
+
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public void setUp() throws Exception {
+    super.setUp();
+    conf.setLong("hbase.hregion.max.filesize", 256 * 1024);
+    dfsCluster = new MiniDFSCluster(conf, 1, true, (String[]) null);
+    try {
+      fs = dfsCluster.getFileSystem();
+      dir = new Path("/hbase");
+      fs.mkdirs(dir);
+      // Start up HBase cluster
+      hCluster = new MiniHBaseCluster(conf, 1, dfsCluster);
+    } catch (Exception e) {
+      if (dfsCluster != null) {
+        dfsCluster.shutdown();
+        dfsCluster = null;
+      }
+      throw e;
+    }
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public void tearDown() throws Exception {
+    super.tearDown();
+    if (hCluster != null) {
+      hCluster.shutdown();
+    }
+
+    if (dfsCluster != null) {
+      dfsCluster.shutdown();
+    }
+
+    if (fs != null) {
+      try {
+        fs.close();
+      } catch (IOException e) {
+        LOG.info("During tear down got a " + e.getMessage());
+      }
+    }
+  }
+
+  public void testTableJoinMapReduce() {
+    try {
+      HTableDescriptor desc = new HTableDescriptor(FIRST_RELATION);
+      String[] columns = FIRST_COLUMNS.split(" ");
+      for (int i = 0; i < columns.length; i++) {
+        desc.addFamily(new HColumnDescriptor(columns[i]));
+      }
+      HBaseAdmin admin = new HBaseAdmin(this.conf);
+      admin.createTable(desc);
+
+      // insert random data into the input table
+      HTable table = new HTable(conf, new Text(FIRST_RELATION));
+      for (int j = 0; j < 5; j++) {
+        long lockid = table.startUpdate(new Text("rowKey" + j));
+        table.put(lockid, new Text("a:"), Integer.toString(j).getBytes(
+            HConstants.UTF8_ENCODING));
+        table.put(lockid, new Text("b:"), Integer.toString(j).getBytes(
+            HConstants.UTF8_ENCODING));
+        table.put(lockid, new Text("c:"), ("joinKey-" + Integer.toString(j))
+            .getBytes(HConstants.UTF8_ENCODING));
+        table.commit(lockid, System.currentTimeMillis());
+      }
+
+    } catch (MasterNotRunningException e) {
+      e.printStackTrace();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+
+    try {
+      HTableDescriptor desc = new HTableDescriptor(SECOND_RELATION);
+      String[] columns = SECOND_COLUMNS.split(" ");
+      for (int i = 0; i < columns.length; i++) {
+        desc.addFamily(new HColumnDescriptor(columns[i]));
+      }
+      HBaseAdmin admin = new HBaseAdmin(this.conf);
+      admin.createTable(desc);
+
+      // insert random data into the input table
+      HTable table = new HTable(conf, new Text(SECOND_RELATION));
+
+      for (int j = 0; j < 3; j++) {
+        long lockid = table.startUpdate(new Text("joinKey-" + j));
+        table.put(lockid, new Text("d:"), ("s-" + Integer.toString(j))
+            .getBytes(HConstants.UTF8_ENCODING));
+        table.put(lockid, new Text("e:"), ("s-" + Integer.toString(j))
+            .getBytes(HConstants.UTF8_ENCODING));
+        table.commit(lockid, System.currentTimeMillis());
+      }
+
+    } catch (MasterNotRunningException e) {
+      e.printStackTrace();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+
+    try {
+      HTableDescriptor output = new HTableDescriptor(OUTPUT_TABLE);
+      String[] columns = (FIRST_COLUMNS + " " + SECOND_COLUMNS).split(" ");
+      for (int i = 0; i < columns.length; i++) {
+        output.addFamily(new HColumnDescriptor(columns[i]));
+      }
+      // create output table
+      HBaseAdmin admin = new HBaseAdmin(this.conf);
+      admin.createTable(output);
+    } catch (MasterNotRunningException e) {
+      e.printStackTrace();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+
+    MiniMRCluster mrCluster = null;
+    try {
+      mrCluster = new MiniMRCluster(2, fs.getUri().toString(), 1);
+
+      JobConf jobConf = new JobConf(conf, TestTableJoinMapReduce.class);
+      jobConf.setJobName("process table join mapreduce");
+      jobConf.setNumMapTasks(2);
+      jobConf.setNumReduceTasks(1);
+
+      IndexJoinMap.initJob(FIRST_RELATION, SECOND_RELATION, FIRST_COLUMNS,
+          SECOND_COLUMNS, JOIN_EXPRESSION, IndexJoinMap.class, jobConf);
+      IndexJoinReduce.initJob(OUTPUT_TABLE, IndexJoinReduce.class, jobConf);
+
+      JobClient.runJob(jobConf);
+
+    } catch (IOException e) {
+      e.printStackTrace();
+    } finally {
+      mrCluster.shutdown();
+    }
+
+    try {
+      verify(conf, OUTPUT_TABLE);
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+
+  /**
+   * Check the result table lattice size.
+   * 
+   * @param conf
+   * @param outputTable
+   * @throws IOException
+   */
+  private void verify(HBaseConfiguration conf, String outputTable)
+      throws IOException {
+    HTable table = new HTable(conf, new Text(outputTable));
+    Text[] columns = { new Text("a:"), new Text("b:"), new Text("c:"),
+        new Text("d:"), new Text("e:") };
+    HScannerInterface scanner = table.obtainScanner(columns,
+        HConstants.EMPTY_START_ROW);
+
+    try {
+      HStoreKey key = new HStoreKey();
+      TreeMap<Text, byte[]> results = new TreeMap<Text, byte[]>();
+
+      int i = 0;
+      while (scanner.next(key, results)) {
+        assertTrue(results.keySet().size() == 5);
+        LOG.info("result_table.column.size: " + results.keySet().size());
+        i++;
+      }
+      assertTrue(i == 3);
+      LOG.info("result_table.row.count: " + i);
+    } finally {
+      scanner.close();
+    }
+
+  }
+}



Mime
View raw message