You are viewing a plain text version of this content. The canonical link for it is here.
Posted to common-commits@hadoop.apache.org by st...@apache.org on 2007/09/13 06:01:07 UTC
svn commit: r575156 [2/3] - in /lucene/hadoop/trunk/src/contrib/hbase: ./
src/java/org/apache/hadoop/hbase/ src/java/org/apache/hadoop/hbase/shell/
src/java/org/apache/hadoop/hbase/shell/generated/
src/test/org/apache/hadoop/hbase/ src/test/org/apache/...
Modified: lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/SelectCommand.java
URL: http://svn.apache.org/viewvc/lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/SelectCommand.java?rev=575156&r1=575155&r2=575156&view=diff
==============================================================================
--- lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/SelectCommand.java (original)
+++ lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/SelectCommand.java Wed Sep 12 21:01:05 2007
@@ -20,6 +20,7 @@
package org.apache.hadoop.hbase.shell;
import java.io.IOException;
+import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
@@ -35,75 +36,66 @@
import org.apache.hadoop.io.DataInputBuffer;
import org.apache.hadoop.io.Text;
+/**
+ * Selects values from tables.
+ *
+ * TODO: INTO FILE is not yet implemented.
+ */
public class SelectCommand extends BasicCommand {
- private Text table;
+ private Text tableName;
+ private Text rowKey = new Text("");
+ private List<String> columns;
+ private long timestamp;
private int limit;
- private Map<String, List<String>> condition;
+ private int version;
+ private boolean whereClause = false;
public ReturnMsg execute(Configuration conf) {
- if (this.condition != null && this.condition.containsKey("error"))
+ if (this.tableName.equals("") || this.rowKey == null ||
+ this.columns.size() == 0) {
return new ReturnMsg(0, "Syntax error : Please check 'Select' syntax.");
-
+ }
+
try {
- HTable table = new HTable(conf, this.table);
+ HTable table = new HTable(conf, this.tableName);
HBaseAdmin admin = new HBaseAdmin(conf);
-
- switch (getCondition()) {
- case 0:
-
- HTableDescriptor[] tables = admin.listTables();
- Text[] columns = null;
+ if (this.whereClause) {
+ compoundWherePrint(table, admin);
+ } else {
+ scanPrint(table, admin);
+ }
+ return new ReturnMsg(1, "Successfully print out the selected data.");
+ } catch (IOException e) {
+ String[] msg = e.getMessage().split("[,]");
+ return new ReturnMsg(0, msg[0]);
+ }
+ }
- if (this.table.equals(HConstants.ROOT_TABLE_NAME)
- || this.table.equals(HConstants.META_TABLE_NAME)) {
- columns = HConstants.COLUMN_FAMILY_ARRAY;
- } else {
- for (int i = 0; i < tables.length; i++) {
- if (tables[i].getName().equals(this.table)) {
- columns = tables[i].families().keySet().toArray(new Text[] {});
- }
+ private void compoundWherePrint(HTable table, HBaseAdmin admin) {
+ try {
+ if (this.version != 0) {
+ byte[][] result = null;
+ Text[] cols = getColumns(admin);
+ for (int i = 0; i < cols.length; i++) {
+ if (this.timestamp == 0) {
+ result = table.get(this.rowKey, cols[i], this.timestamp, this.version);
+ } else {
+ result = table.get(this.rowKey, cols[i], this.version);
}
- }
-
- HScannerInterface scan = table.obtainScanner(columns, new Text(""));
- HStoreKey key = new HStoreKey();
- TreeMap<Text, byte[]> results = new TreeMap<Text, byte[]>();
-
- ConsoleTable.selectHead();
- int count = 0;
- while (scan.next(key, results)) {
- Text rowKey = key.getRow();
-
- for (Text columnKey : results.keySet()) {
- byte[] value = results.get(columnKey);
- String cellData = new String(value, HConstants.UTF8_ENCODING);
-
- if (columnKey.equals(HConstants.COL_REGIONINFO)) {
- DataInputBuffer inbuf = new DataInputBuffer();
- HRegionInfo info = new HRegionInfo();
- inbuf.reset(value, value.length);
- info.readFields(inbuf);
- cellData = "ID : " + String.valueOf(info.getRegionId());
- }
- ConsoleTable.printLine(count, rowKey.toString(), columnKey.toString(),
- cellData);
- count++;
+ ConsoleTable.selectHead();
+ for (int ii = 0; ii < result.length; ii++) {
+ ConsoleTable.printLine(i, this.rowKey.toString(), cols[i].toString(),
+ new String(result[ii], HConstants.UTF8_ENCODING));
}
- results = new TreeMap<Text, byte[]>();
+ ConsoleTable.selectFoot();
}
- ConsoleTable.selectFoot();
- scan.close();
-
- break;
-
- case 1:
-
- count = 0;
+ } else {
+ int count = 0;
ConsoleTable.selectHead();
- for (Map.Entry<Text, byte[]> entry : table.getRow(new Text(getRow())).entrySet()) {
-
+
+ for (Map.Entry<Text, byte[]> entry : table.getRow(this.rowKey).entrySet()) {
byte[] value = entry.getValue();
String cellData = new String(value, HConstants.UTF8_ENCODING);
@@ -112,138 +104,121 @@
HRegionInfo info = new HRegionInfo();
inbuf.reset(value, value.length);
info.readFields(inbuf);
-
- cellData = "ID : " + String.valueOf(info.getRegionId());
+ cellData = String.valueOf(info.getRegionId());
}
- ConsoleTable.printLine(count, getRow().toString(), entry.getKey().toString(),
- cellData);
- count++;
- }
- ConsoleTable.selectFoot();
-
- break;
-
- case 2:
-
- Text[] column = new Text[] { new Text(getColumn()) };
-
- HScannerInterface scanner = table.obtainScanner(column, new Text(""));
- HStoreKey k = new HStoreKey();
- TreeMap<Text, byte[]> r = new TreeMap<Text, byte[]>();
- ConsoleTable.selectHead();
- count = 0;
- while (scanner.next(k, r)) {
- Text rowKey = k.getRow();
-
- for (Text columnKey : r.keySet()) {
- byte[] value = r.get(columnKey);
- String cellData = new String(value, HConstants.UTF8_ENCODING);
- ConsoleTable.printLine(count, rowKey.toString(), columnKey.toString(),
- cellData);
+ if (columns.contains(entry.getKey().toString()) || columns.contains("*")) {
+ ConsoleTable.printLine(count, this.rowKey.toString(), entry.getKey()
+ .toString(), cellData);
count++;
}
- results = new TreeMap<Text, byte[]>();
}
ConsoleTable.selectFoot();
- scanner.close();
-
- break;
-
- case 3:
-
- byte[] rs1 = table.get(new Text(getRow()), new Text(getColumn()));
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
- ConsoleTable.selectHead();
- ConsoleTable.printLine(0, getRow(), getColumn(),
- new String(rs1, HConstants.UTF8_ENCODING));
- ConsoleTable.selectFoot();
+ private void scanPrint(HTable table, HBaseAdmin admin) {
+ HScannerInterface scan = null;
+ try {
+ if (this.timestamp == 0) {
+ scan = table.obtainScanner(getColumns(admin), this.rowKey);
+ } else {
+ scan = table.obtainScanner(getColumns(admin), this.rowKey, this.timestamp);
+ }
- break;
+ HStoreKey key = new HStoreKey();
+ TreeMap<Text, byte[]> results = new TreeMap<Text, byte[]>();
- case 4:
+ ConsoleTable.selectHead();
+ int count = 0;
- byte[][] rs2 = table.get(new Text(getRow()), new Text(getColumn()), this.limit);
+ while (scan.next(key, results) && checkLimit(count)) {
+ Text rowKey = key.getRow();
- ConsoleTable.selectHead();
- for (int i = 0; i < rs2.length; i++) {
- ConsoleTable.printLine(i, getRow(), getColumn(),
- new String(rs2[i], HConstants.UTF8_ENCODING));
+ for (Text columnKey : results.keySet()) {
+ String cellData = new String(results.get(columnKey), HConstants.UTF8_ENCODING);
+ ConsoleTable.printLine(count, rowKey.toString(), columnKey.toString(), cellData);
}
- ConsoleTable.selectFoot();
-
- break;
-
- case 5:
+ count++;
+ }
+ ConsoleTable.selectFoot();
+ scan.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
- byte[][] rs3 = table.get(new Text(getRow()), new Text(getColumn()), getTime(), this.limit);
+ public Text[] getColumns(HBaseAdmin admin) {
+ Text[] cols = null;
- ConsoleTable.selectHead();
- for (int i = 0; i < rs3.length; i++) {
- ConsoleTable.printLine(i, getRow(), getColumn(), new String(rs3[i], HConstants.UTF8_ENCODING));
+ try {
+ if (this.columns.contains("*")) {
+ HTableDescriptor[] tables = admin.listTables();
+ if (this.tableName.equals(HConstants.ROOT_TABLE_NAME)
+ || this.tableName.equals(HConstants.META_TABLE_NAME)) {
+ cols = HConstants.COLUMN_FAMILY_ARRAY;
+ } else {
+ for (int i = 0; i < tables.length; i++) {
+ if (tables[i].getName().equals(this.tableName)) {
+ cols = tables[i].families().keySet().toArray(new Text[] {});
+ }
+ }
}
- ConsoleTable.selectFoot();
-
- break;
-
+ } else {
+ List<Text> tmpList = new ArrayList<Text>();
+ for (int i = 0; i < this.columns.size(); i++) {
+ Text column = null;
+ if(this.columns.get(i).contains(":"))
+ column = new Text(this.columns.get(i));
+ else
+ column = new Text(this.columns.get(i) + ":");
+
+ tmpList.add(column);
+ }
+ cols = tmpList.toArray(new Text[] {});
}
-
- return new ReturnMsg(1, "Successfully print out the selected data.");
} catch (IOException e) {
- String[] msg = e.getMessage().split("[,]");
- return new ReturnMsg(0, msg[0]);
+ e.printStackTrace();
}
+ return cols;
+ }
+
+ private boolean checkLimit(int count) {
+ return (this.limit == 0)? true: (this.limit > count) ? true : false;
}
public void setTable(String table) {
- this.table = new Text(table);
+ this.tableName = new Text(table);
}
public void setLimit(int limit) {
this.limit = limit;
}
- public void setCondition(Map<String, List<String>> cond) {
- this.condition = cond;
+ public void setWhere(boolean isWhereClause) {
+ if (isWhereClause)
+ this.whereClause = true;
}
- public String getRow() {
- return this.condition.get("row").get(1);
+ public void setTimestamp(String timestamp) {
+ this.timestamp = Long.parseLong(timestamp);
}
- public String getColumn() {
- return this.condition.get("column").get(1);
+ public void setColumns(List<String> columns) {
+ this.columns = columns;
}
- public long getTime() {
- return Long.parseLong(this.condition.get("time").get(1));
+ public void setRowKey(String rowKey) {
+ if(rowKey == null)
+ this.rowKey = null;
+ else
+ this.rowKey = new Text(rowKey);
}
- public int getConditionSize() {
- return this.condition.size();
- }
-
- public int getCondition() {
- int type = 0;
- if (this.condition == null) {
- type = 0;
- } else if (this.condition.containsKey("row")) {
- if (getConditionSize() == 1) {
- type = 1;
- } else if (this.condition.containsKey("column")) {
- if (getConditionSize() == 2) {
- if (this.limit == 0) {
- type = 3;
- } else {
- type = 4;
- }
- } else {
- type = 5;
- }
- }
- } else if (this.condition.containsKey("column")) {
- type = 2;
- }
- return type;
+ public void setVersion(int version) {
+ this.version = version;
}
}
Modified: lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/ShowCommand.java
URL: http://svn.apache.org/viewvc/lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/ShowCommand.java?rev=575156&r1=575155&r2=575156&view=diff
==============================================================================
--- lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/ShowCommand.java (original)
+++ lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/ShowCommand.java Wed Sep 12 21:01:05 2007
@@ -25,6 +25,9 @@
import org.apache.hadoop.hbase.HBaseAdmin;
import org.apache.hadoop.hbase.HTableDescriptor;
+/**
+ * Shows all available tables.
+ */
public class ShowCommand extends BasicCommand {
private String command;
@@ -62,5 +65,4 @@
public void setArgument(String argument) {
this.command = argument;
}
-
}
Modified: lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/Parser.java
URL: http://svn.apache.org/viewvc/lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/Parser.java?rev=575156&r1=575155&r2=575156&view=diff
==============================================================================
--- lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/Parser.java (original)
+++ lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/Parser.java Wed Sep 12 21:01:05 2007
@@ -1,4 +1,6 @@
/* Generated By:JavaCC: Do not edit this line. Parser.java */
+package org.apache.hadoop.hbase.shell.generated;
+
/**
* Copyright 2007 The Apache Software Foundation
*
@@ -18,7 +20,6 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.hadoop.hbase.shell.generated;
import java.util.ArrayList;
import java.util.List;
@@ -51,9 +52,11 @@
Command statement = null;
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case HELP:
+ case ALTER:
case CLEAR:
case SHOW:
case DESCRIBE:
+ case DESC:
case CREATE:
case DROP:
case FS:
@@ -61,12 +64,16 @@
case INSERT:
case DELETE:
case SELECT:
- case 37:
+ case ENABLE:
+ case DISABLE:
+ case 61:
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case HELP:
+ case ALTER:
case CLEAR:
case SHOW:
case DESCRIBE:
+ case DESC:
case CREATE:
case DROP:
case FS:
@@ -74,13 +81,15 @@
case INSERT:
case DELETE:
case SELECT:
+ case ENABLE:
+ case DISABLE:
statement = cmdStatement();
break;
default:
jj_la1[0] = jj_gen;
;
}
- jj_consume_token(37);
+ jj_consume_token(61);
break;
case 0:
jj_consume_token(0);
@@ -107,6 +116,7 @@
cmd = showCommand();
break;
case DESCRIBE:
+ case DESC:
cmd = descCommand();
break;
case CREATE:
@@ -115,6 +125,9 @@
case DROP:
cmd = dropCommand();
break;
+ case ALTER:
+ cmd = alterCommand();
+ break;
case INSERT:
cmd = insertCommand();
break;
@@ -124,6 +137,12 @@
case SELECT:
cmd = selectCommand();
break;
+ case ENABLE:
+ cmd = enableCommand();
+ break;
+ case DISABLE:
+ cmd = disableCommand();
+ break;
case CLEAR:
cmd = clearCommand();
break;
@@ -175,6 +194,7 @@
String argument = "";
jj_consume_token(HELP);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case ALTER:
case CLEAR:
case SHOW:
case DESCRIBE:
@@ -211,6 +231,9 @@
case SELECT:
t = jj_consume_token(SELECT);
break;
+ case ALTER:
+ t = jj_consume_token(ALTER);
+ break;
case CLEAR:
t = jj_consume_token(CLEAR);
break;
@@ -242,8 +265,9 @@
jj_consume_token(SHOW);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case ID:
- case QUOTED_STRING:
- argument = getString();
+ case QUOTED_IDENTIFIER:
+ case STRING_LITERAL:
+ argument = Identifier();
break;
default:
jj_la1[6] = jj_gen;
@@ -257,314 +281,430 @@
final public DescCommand descCommand() throws ParseException {
DescCommand desc = new DescCommand();
String argument = null;
- jj_consume_token(DESCRIBE);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
- case ID:
- case QUOTED_STRING:
- argument = getString();
+ case DESCRIBE:
+ jj_consume_token(DESCRIBE);
+ break;
+ case DESC:
+ jj_consume_token(DESC);
break;
default:
jj_la1[7] = jj_gen;
- ;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ argument = Identifier();
+ desc.setArgument(argument);
+ {if (true) return desc;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public Map<String, Object> ColumnSpec() throws ParseException {
+ Map<String, Object> columnSpec = new HashMap<String, Object>();
+ int n = -1;
+ Token t = null;
+ label_2:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case MAX_VERSIONS:
+ case MAX_LENGTH:
+ case COMPRESSION:
+ case IN_MEMORY:
+ case BLOOMFILTER:
+ case VECTOR_SIZE:
+ case NUM_HASH:
+ case NUM_ENTRIES:
+ ;
+ break;
+ default:
+ jj_la1[8] = jj_gen;
+ break label_2;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case MAX_VERSIONS:
+ jj_consume_token(MAX_VERSIONS);
+ jj_consume_token(EQUALS);
+ n = Number();
+ columnSpec.put("MAX_VERSIONS", n);
+ break;
+ case MAX_LENGTH:
+ jj_consume_token(MAX_LENGTH);
+ jj_consume_token(EQUALS);
+ n = Number();
+ columnSpec.put("MAX_LENGTH", n);
+ break;
+ case COMPRESSION:
+ jj_consume_token(COMPRESSION);
+ jj_consume_token(EQUALS);
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case NONE:
+ t = jj_consume_token(NONE);
+ break;
+ case BLOCK:
+ t = jj_consume_token(BLOCK);
+ break;
+ case RECORD:
+ t = jj_consume_token(RECORD);
+ break;
+ default:
+ jj_la1[9] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ columnSpec.put("COMPRESSION", t.image.toString());
+ break;
+ case IN_MEMORY:
+ jj_consume_token(IN_MEMORY);
+ columnSpec.put("IN_MEMORY", true);
+ break;
+ case BLOOMFILTER:
+ jj_consume_token(BLOOMFILTER);
+ jj_consume_token(EQUALS);
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case BLOOMFILTER:
+ t = jj_consume_token(BLOOMFILTER);
+ break;
+ case COUNTING_BLOOMFILTER:
+ t = jj_consume_token(COUNTING_BLOOMFILTER);
+ break;
+ case RETOUCHED_BLOOMFILTER:
+ t = jj_consume_token(RETOUCHED_BLOOMFILTER);
+ break;
+ default:
+ jj_la1[10] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ columnSpec.put("BLOOMFILTER", t.image.toString());
+ break;
+ case VECTOR_SIZE:
+ jj_consume_token(VECTOR_SIZE);
+ jj_consume_token(EQUALS);
+ n = Number();
+ columnSpec.put("VECTOR_SIZE", n);
+ break;
+ case NUM_HASH:
+ jj_consume_token(NUM_HASH);
+ jj_consume_token(EQUALS);
+ n = Number();
+ columnSpec.put("NUM_HASH", n);
+ break;
+ case NUM_ENTRIES:
+ jj_consume_token(NUM_ENTRIES);
+ jj_consume_token(EQUALS);
+ n = Number();
+ columnSpec.put("NUM_ENTRIES", n);
+ break;
+ default:
+ jj_la1[11] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
}
- desc.setArgument(argument);
- {if (true) return desc;}
+ {if (true) return columnSpec;}
throw new Error("Missing return statement in function");
}
final public CreateCommand createCommand() throws ParseException {
- CreateCommand create = new CreateCommand();
- String argument = null;
- List<String> columnfamilies = null;
- int limit = 1;
+ CreateCommand createCommand = new CreateCommand();
+ String table = null;
+ Map<String, Object> columnSpec = null;
+ String column = null;
jj_consume_token(CREATE);
- argument = getString();
- create.setTable(argument);
- jj_consume_token(COLUMNFAMILIES);
- columnfamilies = getLiteralValues();
- create.setColumnfamilies(columnfamilies);
- switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
- case LIMIT:
- jj_consume_token(LIMIT);
- jj_consume_token(EQUALS);
- limit = getInt();
- try{
- create.setLimit(limit);
- }catch(ClassCastException ce) {
- {if (true) throw generateParseException();}
+ jj_consume_token(TABLE);
+ table = Identifier();
+ createCommand.setTable(table);
+ jj_consume_token(LPAREN);
+ column = Identifier();
+ columnSpec = ColumnSpec();
+ createCommand.addColumnSpec(column, columnSpec);
+ label_3:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case COMMA:
+ ;
+ break;
+ default:
+ jj_la1[12] = jj_gen;
+ break label_3;
+ }
+ jj_consume_token(COMMA);
+ column = Identifier();
+ columnSpec = ColumnSpec();
+ createCommand.addColumnSpec(column, columnSpec);
+ }
+ jj_consume_token(RPAREN);
+ {if (true) return createCommand;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public AlterCommand alterCommand() throws ParseException {
+ AlterCommand alterCommand = new AlterCommand();
+ String table = null;
+ String column = null;
+ Map<String, Object> columnSpec = null;
+ jj_consume_token(ALTER);
+ jj_consume_token(TABLE);
+ table = Identifier();
+ alterCommand.setTable(table);
+ if (jj_2_1(2)) {
+ jj_consume_token(ADD);
+ column = Identifier();
+ columnSpec = ColumnSpec();
+ alterCommand.setOperationType(AlterCommand.OperationType.ADD);
+ alterCommand.addColumnSpec(column, columnSpec);
+ } else {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case ADD:
+ jj_consume_token(ADD);
+ jj_consume_token(LPAREN);
+ alterCommand.setOperationType(AlterCommand.OperationType.ADD);
+ column = Identifier();
+ columnSpec = ColumnSpec();
+ alterCommand.addColumnSpec(column, columnSpec);
+ label_4:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case COMMA:
+ ;
+ break;
+ default:
+ jj_la1[13] = jj_gen;
+ break label_4;
+ }
+ jj_consume_token(COMMA);
+ column = Identifier();
+ columnSpec = ColumnSpec();
+ alterCommand.addColumnSpec(column, columnSpec);
}
- break;
- default:
- jj_la1[8] = jj_gen;
- ;
+ jj_consume_token(RPAREN);
+ break;
+ case DROP:
+ jj_consume_token(DROP);
+ column = Identifier();
+ alterCommand.setOperationType(AlterCommand.OperationType.DROP);
+ alterCommand.setColumn(column);
+ break;
+ case CHANGE:
+ jj_consume_token(CHANGE);
+ column = Identifier();
+ columnSpec = ColumnSpec();
+ alterCommand.setOperationType(AlterCommand.OperationType.CHANGE);
+ alterCommand.addColumnSpec(column, columnSpec);
+ break;
+ default:
+ jj_la1[14] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
}
- {if (true) return create;}
+ {if (true) return alterCommand;}
throw new Error("Missing return statement in function");
}
final public DropCommand dropCommand() throws ParseException {
DropCommand drop = new DropCommand();
- String argument = null;
+ List<String> tableList = null;
jj_consume_token(DROP);
- switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
- case ID:
- case QUOTED_STRING:
- argument = getString();
- break;
- default:
- jj_la1[9] = jj_gen;
- ;
- }
- drop.setArgument(argument);
- {if (true) return drop;}
+ jj_consume_token(TABLE);
+ tableList = TableList();
+ drop.setTableList(tableList);
+ {if (true) return drop;}
throw new Error("Missing return statement in function");
}
final public InsertCommand insertCommand() throws ParseException {
- InsertCommand in = new InsertCommand();
- Map<String, List<String>> cond = null;
- List<String> columnfamilies = null;
- List<String> values = null;
- String table = null;
+ InsertCommand in = new InsertCommand();
+ List<String> columnfamilies = null;
+ List<String> values = null;
+ String table = null;
+ Token t = null;
jj_consume_token(INSERT);
- table = getString();
- in.setTable(table);
- columnfamilies = getLiteralValues();
- in.setColumnfamilies(columnfamilies);
+ jj_consume_token(INTO);
+ table = Identifier();
+ in.setTable(table);
+ columnfamilies = getColumns();
+ in.setColumnfamilies(columnfamilies);
jj_consume_token(VALUES);
values = getLiteralValues();
- in.setValues(values);
+ in.setValues(values);
jj_consume_token(WHERE);
- cond = WhereClause();
- try{
- in.setCondition(cond);
- }catch(ClassCastException ce) {
- {if (true) throw generateParseException();}
- }
- {if (true) return in;}
- throw new Error("Missing return statement in function");
- }
-
- final public DeleteCommand deleteCommand() throws ParseException {
- DeleteCommand del = new DeleteCommand();
- Map<String, List<String>> cond = null;
- String argument = null;
- jj_consume_token(DELETE);
- argument = getString();
- del.setTable(argument);
- jj_consume_token(WHERE);
- cond = WhereClause();
- try{
- del.setCondition(cond);
- }catch(ClassCastException ce) {
- {if (true) throw generateParseException();}
- }
- {if (true) return del;}
- throw new Error("Missing return statement in function");
- }
-
- final public SelectCommand selectCommand() throws ParseException {
- SelectCommand select = new SelectCommand();
- Map<String, List<String>> cond = null;
- String argument = null;
- int limit;
- jj_consume_token(SELECT);
- argument = getString();
- select.setTable(argument);
+ jj_consume_token(ROW);
+ jj_consume_token(EQUALS);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
- case WHERE:
- jj_consume_token(WHERE);
- cond = WhereClause();
- try{
- select.setCondition(cond);
- }catch(ClassCastException ce) {
- {if (true) throw generateParseException();}
- }
+ case STRING_LITERAL:
+ t = jj_consume_token(STRING_LITERAL);
break;
- default:
- jj_la1[10] = jj_gen;
- ;
- }
- switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
- case LIMIT:
- jj_consume_token(LIMIT);
- jj_consume_token(EQUALS);
- limit = getInt();
- try{
- select.setLimit(limit);
- }catch(ClassCastException ce) {
- {if (true) throw generateParseException();}
- }
+ case QUOTED_IDENTIFIER:
+ t = jj_consume_token(QUOTED_IDENTIFIER);
break;
default:
- jj_la1[11] = jj_gen;
- ;
+ jj_la1[15] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
}
- {if (true) return select;}
+ in.setRow(t.image.substring(1, t.image.length()-1));
+ {if (true) return in;}
throw new Error("Missing return statement in function");
}
- final public ClearCommand clearCommand() throws ParseException {
- ClearCommand clear = new ClearCommand();
- jj_consume_token(CLEAR);
- {if (true) return clear;}
- throw new Error("Missing return statement in function");
- }
-
-/**
-* TODO : expressions codes need more love.
-*/
- final public String getString() throws ParseException {
+ final public DeleteCommand deleteCommand() throws ParseException {
+ DeleteCommand deleteCommand = new DeleteCommand();
+ List<String> columnList = null;
Token t = null;
+ String table = null;
+ jj_consume_token(DELETE);
+ columnList = ColumnList();
+ deleteCommand.setColumnList(columnList);
+ jj_consume_token(FROM);
+ table = Identifier();
+ deleteCommand.setTable(table);
+ jj_consume_token(WHERE);
+ jj_consume_token(ROW);
+ jj_consume_token(EQUALS);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
- case ID:
- t = jj_consume_token(ID);
+ case STRING_LITERAL:
+ t = jj_consume_token(STRING_LITERAL);
break;
- case QUOTED_STRING:
- t = jj_consume_token(QUOTED_STRING);
+ case QUOTED_IDENTIFIER:
+ t = jj_consume_token(QUOTED_IDENTIFIER);
break;
default:
- jj_la1[12] = jj_gen;
+ jj_la1[16] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
- {if (true) return t.image.toString();}
- throw new Error("Missing return statement in function");
- }
-
- final public int getInt() throws ParseException {
- Token t = null;
- t = jj_consume_token(NUM);
- {if (true) return Integer.parseInt(t.image.toString());}
+ deleteCommand.setRow(t.image.substring(1, t.image.length()-1));
+ {if (true) return deleteCommand;}
throw new Error("Missing return statement in function");
}
- final public Map<String, List<String>> WhereClause() throws ParseException {
- Map<String, List<String>> result =
- new HashMap<String, List<String>>();
- List<String> exception =
- new ArrayList<String>();
- try{
- result.putAll(ConditionExpression());
- }catch(ParseException pe) {
- exception.add(pe.toString());
- result.put("error", exception);
- }
- label_2:
- while (true) {
+ final public SelectCommand selectCommand() throws ParseException {
+ SelectCommand select = new SelectCommand();
+ List<String> columns = null;
+ String rowKey = "";
+ String timestamp = null;
+ int numVersion = 0;
+ String tableName = null;
+ int limit;
+ jj_consume_token(SELECT);
+ columns = ColumnList();
+ jj_consume_token(FROM);
+ tableName = Identifier();
+ select.setColumns(columns);
+ select.setTable(tableName);
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case STARTING:
+ case WHERE:
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
- case AND:
- ;
+ case WHERE:
+ jj_consume_token(WHERE);
+ jj_consume_token(ROW);
+ jj_consume_token(EQUALS);
+ select.setWhere(true);
+ break;
+ case STARTING:
+ jj_consume_token(STARTING);
+ jj_consume_token(FROM);
break;
default:
- jj_la1[13] = jj_gen;
- break label_2;
- }
- jj_consume_token(AND);
- try{
- result.putAll(ConditionExpression());
- }catch(ParseException pe) {
- exception.add(pe.toString());
- result.put("error", exception);
+ jj_la1[17] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
}
- }
- {if (true) return result;}
- throw new Error("Missing return statement in function");
- }
-
- final public Map<String, List<String>> ConditionExpression() throws ParseException {
- Token tSearchName, tComparator, tComparand;
- Map<String, List<String>> tmp =
- new HashMap<String, List<String>>();
- List<String> values =
- new ArrayList<String>();
- switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
- case ROW:
- tSearchName = jj_consume_token(ROW);
- break;
- case COLUMN:
- tSearchName = jj_consume_token(COLUMN);
- break;
- case TIME:
- tSearchName = jj_consume_token(TIME);
- break;
- case ID:
- tSearchName = jj_consume_token(ID);
- break;
- case VALUES:
- tSearchName = jj_consume_token(VALUES);
- break;
- case COLUMNFAMILIES:
- tSearchName = jj_consume_token(COLUMNFAMILIES);
+ rowKey = getStringLiteral();
+ select.setRowKey(rowKey);
break;
default:
- jj_la1[14] = jj_gen;
- jj_consume_token(-1);
- throw new ParseException();
+ jj_la1[18] = jj_gen;
+ ;
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
- case EQUALS:
- tComparator = jj_consume_token(EQUALS);
- break;
- case NOTEQUAL:
- tComparator = jj_consume_token(NOTEQUAL);
+ case TIMESTAMP:
+ jj_consume_token(TIMESTAMP);
+ timestamp = getStringLiteral();
+ select.setTimestamp(timestamp);
break;
default:
- jj_la1[15] = jj_gen;
- jj_consume_token(-1);
- throw new ParseException();
+ jj_la1[19] = jj_gen;
+ ;
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
- case QUOTED_STRING:
- tComparand = jj_consume_token(QUOTED_STRING);
- values.add("quoted string");
- tmp.put("error", values);
- {if (true) return tmp;}
+ case NUM_VERSIONS:
+ jj_consume_token(NUM_VERSIONS);
+ numVersion = Number();
+ select.setVersion(numVersion);
break;
- case STRING_LITERAL:
- tComparand = jj_consume_token(STRING_LITERAL);
- values.add(tComparator.image);
- values.add(tComparand.image.substring(1,tComparand.image.length() - 1));
-
- if(tSearchName.image.toString().equals("row") ||
- tSearchName.image.toString().equals("column") ||
- tSearchName.image.toString().equals("time"))
- { tmp.put(tSearchName.image, values); }
- else
- {
- values.add(tSearchName.image.toString());
- tmp.put("error", values);
+ default:
+ jj_la1[20] = jj_gen;
+ ;
}
-
- {if (true) return tmp;}
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LIMIT:
+ jj_consume_token(LIMIT);
+ jj_consume_token(EQUALS);
+ limit = Number();
+ try{
+ select.setLimit(limit);
+ }catch(ClassCastException ce) {
+ {if (true) throw generateParseException();}
+ }
break;
default:
- jj_la1[16] = jj_gen;
- jj_consume_token(-1);
- throw new ParseException();
+ jj_la1[21] = jj_gen;
+ ;
}
+ {if (true) return select;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public EnableCommand enableCommand() throws ParseException {
+ EnableCommand enableCommand = new EnableCommand();
+ String table = null;
+ jj_consume_token(ENABLE);
+ table = Identifier();
+ enableCommand.setTable(table);
+ {if (true) return enableCommand;}
throw new Error("Missing return statement in function");
}
+ final public DisableCommand disableCommand() throws ParseException {
+ DisableCommand disableCommand = new DisableCommand();
+ String table = null;
+ jj_consume_token(DISABLE);
+ table = Identifier();
+ disableCommand.setTable(table);
+ {if (true) return disableCommand;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public ClearCommand clearCommand() throws ParseException {
+ ClearCommand clear = new ClearCommand();
+ jj_consume_token(CLEAR);
+ {if (true) return clear;}
+ throw new Error("Missing return statement in function");
+ }
+
+////////////////////////////////////////////////
+// Utility expansion units...
final public List<String> getLiteralValues() throws ParseException {
- List<String> values = new ArrayList<String>();
- String literal = null;
+ List<String> values = new ArrayList<String>();
+ String literal = null;
jj_consume_token(LPAREN);
literal = getStringLiteral();
if(literal != null) values.add(literal);
- label_3:
+ label_5:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case COMMA:
case ID:
- case STRING:
- case QUOTED_STRING:
+ case QUOTED_IDENTIFIER:
case STRING_LITERAL:
;
break;
default:
- jj_la1[17] = jj_gen;
- break label_3;
+ jj_la1[22] = jj_gen;
+ break label_5;
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case COMMA:
@@ -573,8 +713,7 @@
if(literal != null) values.add(literal);
break;
case ID:
- case STRING:
- case QUOTED_STRING:
+ case QUOTED_IDENTIFIER:
case STRING_LITERAL:
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case ID:
@@ -583,21 +722,18 @@
case STRING_LITERAL:
jj_consume_token(STRING_LITERAL);
break;
- case QUOTED_STRING:
- jj_consume_token(QUOTED_STRING);
- break;
- case STRING:
- jj_consume_token(STRING);
+ case QUOTED_IDENTIFIER:
+ jj_consume_token(QUOTED_IDENTIFIER);
break;
default:
- jj_la1[18] = jj_gen;
+ jj_la1[23] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
values.removeAll(values);
break;
default:
- jj_la1[19] = jj_gen;
+ jj_la1[24] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
@@ -608,30 +744,228 @@
}
final public String getStringLiteral() throws ParseException {
- Token stringLiteral;
+ Token s;
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case STRING_LITERAL:
- stringLiteral = jj_consume_token(STRING_LITERAL);
- {if (true) return stringLiteral.image.substring(1,stringLiteral.image.length() - 1);}
+ s = jj_consume_token(STRING_LITERAL);
break;
- case QUOTED_STRING:
- jj_consume_token(QUOTED_STRING);
- {if (true) return null;}
+ case QUOTED_IDENTIFIER:
+ s = jj_consume_token(QUOTED_IDENTIFIER);
break;
default:
- jj_la1[20] = jj_gen;
+ jj_la1[25] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ String value = s.image.toString();
+ {if (true) return value.substring(1,value.length() - 1);}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public List<String> getColumns() throws ParseException {
+ List<String> values = new ArrayList<String>();
+ String literal = null;
+ jj_consume_token(LPAREN);
+ literal = getColumn();
+ if(literal != null) values.add(literal);
+ label_6:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case COMMA:
+ ;
+ break;
+ default:
+ jj_la1[26] = jj_gen;
+ break label_6;
+ }
+ jj_consume_token(COMMA);
+ literal = getColumn();
+ if(literal != null) values.add(literal);
+ }
+ jj_consume_token(RPAREN);
+ {if (true) return values;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public String getColumn() throws ParseException {
+ Token col;
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case ASTERISK:
+ case ID:
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case ID:
+ col = jj_consume_token(ID);
+ break;
+ case ASTERISK:
+ col = jj_consume_token(ASTERISK);
+ break;
+ default:
+ jj_la1[27] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ {if (true) return col.image.toString();}
+ break;
+ case QUOTED_IDENTIFIER:
+ case STRING_LITERAL:
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case QUOTED_IDENTIFIER:
+ col = jj_consume_token(QUOTED_IDENTIFIER);
+ break;
+ case STRING_LITERAL:
+ col = jj_consume_token(STRING_LITERAL);
+ break;
+ default:
+ jj_la1[28] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ {if (true) return col.image.substring(1,col.image.toString().length() - 1);}
+ break;
+ default:
+ jj_la1[29] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
throw new Error("Missing return statement in function");
}
+ final public List<String> TableList() throws ParseException {
+ List<String> tableList = new ArrayList<String>();
+ String table = null;
+ table = Identifier();
+ tableList.add(table);
+ label_7:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case COMMA:
+ ;
+ break;
+ default:
+ jj_la1[30] = jj_gen;
+ break label_7;
+ }
+ jj_consume_token(COMMA);
+ table = Identifier();
+ tableList.add(table);
+ }
+ {if (true) return tableList;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public List<String> ColumnList() throws ParseException {
+ List<String> columnList = new ArrayList<String>();
+ String column = null;
+ column = getColumn();
+ if(column != null) {
+ columnList.add(column);
+ } else {
+ {if (true) return columnList;}
+ }
+ label_8:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case COMMA:
+ ;
+ break;
+ default:
+ jj_la1[31] = jj_gen;
+ break label_8;
+ }
+ jj_consume_token(COMMA);
+ column = getColumn();
+ columnList.add(column);
+ }
+ {if (true) return columnList;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public int Number() throws ParseException {
+ Token t = null;
+ t = jj_consume_token(INTEGER_LITERAL);
+ {if (true) return Integer.parseInt(t.image.toString());}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public String Identifier() throws ParseException {
+ Token t = null;
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case ID:
+ t = jj_consume_token(ID);
+ {if (true) return t.image.toString();}
+ break;
+ case QUOTED_IDENTIFIER:
+ case STRING_LITERAL:
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case QUOTED_IDENTIFIER:
+ t = jj_consume_token(QUOTED_IDENTIFIER);
+ break;
+ case STRING_LITERAL:
+ t = jj_consume_token(STRING_LITERAL);
+ break;
+ default:
+ jj_la1[32] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ {if (true) return t.image.substring(1,t.image.toString().length() - 1);}
+ break;
+ default:
+ jj_la1[33] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+ final private boolean jj_2_1(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_1(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(0, xla); }
+ }
+
+ final private boolean jj_3R_9() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_10()) {
+ jj_scanpos = xsp;
+ if (jj_3R_11()) return true;
+ }
+ return false;
+ }
+
+ final private boolean jj_3_1() {
+ if (jj_scan_token(ADD)) return true;
+ if (jj_3R_9()) return true;
+ return false;
+ }
+
+ final private boolean jj_3R_11() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(59)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(60)) return true;
+ }
+ return false;
+ }
+
+ final private boolean jj_3R_10() {
+ if (jj_scan_token(ID)) return true;
+ return false;
+ }
+
public ParserTokenManager token_source;
SimpleCharStream jj_input_stream;
public Token token, jj_nt;
private int jj_ntk;
+ private Token jj_scanpos, jj_lastpos;
+ private int jj_la;
+ public boolean lookingAhead = false;
+ private boolean jj_semLA;
private int jj_gen;
- final private int[] jj_la1 = new int[21];
+ final private int[] jj_la1 = new int[34];
static private int[] jj_la1_0;
static private int[] jj_la1_1;
static {
@@ -639,11 +973,14 @@
jj_la1_1();
}
private static void jj_la1_0() {
- jj_la1_0 = new int[] {0xffe0,0xffe1,0xffe0,0x0,0xffc0,0xffc0,0x0,0x0,0x400000,0x0,0x200000,0x400000,0x0,0x800000,0x1f0000,0x60000000,0x0,0x2000000,0x0,0x2000000,0x0,};
+ jj_la1_0 = new int[] {0x3cffe0,0x3cffe1,0x3cffe0,0x0,0xcfbc0,0xcfbc0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0xc00000,0xc00000,0x10000000,0x20000000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
}
private static void jj_la1_1() {
- jj_la1_1 = new int[] {0x0,0x20,0x0,0x1,0x1,0x1,0x9,0x9,0x0,0x9,0x0,0x0,0x9,0x0,0x1,0x0,0x18,0x1d,0x1d,0x1d,0x18,};
+ jj_la1_1 = new int[] {0x0,0x20000000,0x0,0x800000,0x800000,0x800000,0x18800000,0x0,0x1cc700,0x3800,0x38000,0x1cc700,0x2,0x2,0x600000,0x18000000,0x18000000,0x0,0x0,0x0,0x0,0x0,0x18800002,0x18800000,0x18800002,0x18000000,0x2,0x800080,0x18000000,0x18800080,0x2,0x2,0x18000000,0x18800000,};
}
+ final private JJCalls[] jj_2_rtns = new JJCalls[1];
+ private boolean jj_rescan = false;
+ private int jj_gc = 0;
public Parser(java.io.InputStream stream) {
this(stream, null);
@@ -654,7 +991,8 @@
token = new Token();
jj_ntk = -1;
jj_gen = 0;
- for (int i = 0; i < 21; i++) jj_la1[i] = -1;
+ for (int i = 0; i < 34; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
}
public void ReInit(java.io.InputStream stream) {
@@ -666,7 +1004,8 @@
token = new Token();
jj_ntk = -1;
jj_gen = 0;
- for (int i = 0; i < 21; i++) jj_la1[i] = -1;
+ for (int i = 0; i < 34; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
}
public Parser(java.io.Reader stream) {
@@ -675,7 +1014,8 @@
token = new Token();
jj_ntk = -1;
jj_gen = 0;
- for (int i = 0; i < 21; i++) jj_la1[i] = -1;
+ for (int i = 0; i < 34; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
}
public void ReInit(java.io.Reader stream) {
@@ -684,7 +1024,8 @@
token = new Token();
jj_ntk = -1;
jj_gen = 0;
- for (int i = 0; i < 21; i++) jj_la1[i] = -1;
+ for (int i = 0; i < 34; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
}
public Parser(ParserTokenManager tm) {
@@ -692,7 +1033,8 @@
token = new Token();
jj_ntk = -1;
jj_gen = 0;
- for (int i = 0; i < 21; i++) jj_la1[i] = -1;
+ for (int i = 0; i < 34; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
}
public void ReInit(ParserTokenManager tm) {
@@ -700,7 +1042,8 @@
token = new Token();
jj_ntk = -1;
jj_gen = 0;
- for (int i = 0; i < 21; i++) jj_la1[i] = -1;
+ for (int i = 0; i < 34; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
}
final private Token jj_consume_token(int kind) throws ParseException {
@@ -710,6 +1053,16 @@
jj_ntk = -1;
if (token.kind == kind) {
jj_gen++;
+ if (++jj_gc > 100) {
+ jj_gc = 0;
+ for (int i = 0; i < jj_2_rtns.length; i++) {
+ JJCalls c = jj_2_rtns[i];
+ while (c != null) {
+ if (c.gen < jj_gen) c.first = null;
+ c = c.next;
+ }
+ }
+ }
return token;
}
token = oldToken;
@@ -717,6 +1070,29 @@
throw generateParseException();
}
+ static private final class LookaheadSuccess extends java.lang.Error { }
+ final private LookaheadSuccess jj_ls = new LookaheadSuccess();
+ final private boolean jj_scan_token(int kind) {
+ if (jj_scanpos == jj_lastpos) {
+ jj_la--;
+ if (jj_scanpos.next == null) {
+ jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
+ } else {
+ jj_lastpos = jj_scanpos = jj_scanpos.next;
+ }
+ } else {
+ jj_scanpos = jj_scanpos.next;
+ }
+ if (jj_rescan) {
+ int i = 0; Token tok = token;
+ while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
+ if (tok != null) jj_add_error_token(kind, i);
+ }
+ if (jj_scanpos.kind != kind) return true;
+ if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
+ return false;
+ }
+
final public Token getNextToken() {
if (token.next != null) token = token.next;
else token = token.next = token_source.getNextToken();
@@ -726,7 +1102,7 @@
}
final public Token getToken(int index) {
- Token t = token;
+ Token t = lookingAhead ? jj_scanpos : token;
for (int i = 0; i < index; i++) {
if (t.next != null) t = t.next;
else t = t.next = token_source.getNextToken();
@@ -744,18 +1120,48 @@
private java.util.Vector jj_expentries = new java.util.Vector();
private int[] jj_expentry;
private int jj_kind = -1;
+ private int[] jj_lasttokens = new int[100];
+ private int jj_endpos;
+
+ private void jj_add_error_token(int kind, int pos) {
+ if (pos >= 100) return;
+ if (pos == jj_endpos + 1) {
+ jj_lasttokens[jj_endpos++] = kind;
+ } else if (jj_endpos != 0) {
+ jj_expentry = new int[jj_endpos];
+ for (int i = 0; i < jj_endpos; i++) {
+ jj_expentry[i] = jj_lasttokens[i];
+ }
+ boolean exists = false;
+ for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
+ int[] oldentry = (int[])(e.nextElement());
+ if (oldentry.length == jj_expentry.length) {
+ exists = true;
+ for (int i = 0; i < jj_expentry.length; i++) {
+ if (oldentry[i] != jj_expentry[i]) {
+ exists = false;
+ break;
+ }
+ }
+ if (exists) break;
+ }
+ }
+ if (!exists) jj_expentries.addElement(jj_expentry);
+ if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
+ }
+ }
public ParseException generateParseException() {
jj_expentries.removeAllElements();
- boolean[] la1tokens = new boolean[38];
- for (int i = 0; i < 38; i++) {
+ boolean[] la1tokens = new boolean[62];
+ for (int i = 0; i < 62; i++) {
la1tokens[i] = false;
}
if (jj_kind >= 0) {
la1tokens[jj_kind] = true;
jj_kind = -1;
}
- for (int i = 0; i < 21; i++) {
+ for (int i = 0; i < 34; i++) {
if (jj_la1[i] == jj_gen) {
for (int j = 0; j < 32; j++) {
if ((jj_la1_0[i] & (1<<j)) != 0) {
@@ -767,13 +1173,16 @@
}
}
}
- for (int i = 0; i < 38; i++) {
+ for (int i = 0; i < 62; i++) {
if (la1tokens[i]) {
jj_expentry = new int[1];
jj_expentry[0] = i;
jj_expentries.addElement(jj_expentry);
}
}
+ jj_endpos = 0;
+ jj_rescan_token();
+ jj_add_error_token(0, 0);
int[][] exptokseq = new int[jj_expentries.size()][];
for (int i = 0; i < jj_expentries.size(); i++) {
exptokseq[i] = (int[])jj_expentries.elementAt(i);
@@ -785,6 +1194,41 @@
}
final public void disable_tracing() {
+ }
+
+ final private void jj_rescan_token() {
+ jj_rescan = true;
+ for (int i = 0; i < 1; i++) {
+ try {
+ JJCalls p = jj_2_rtns[i];
+ do {
+ if (p.gen > jj_gen) {
+ jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
+ switch (i) {
+ case 0: jj_3_1(); break;
+ }
+ }
+ p = p.next;
+ } while (p != null);
+ } catch(LookaheadSuccess ls) { }
+ }
+ jj_rescan = false;
+ }
+
+ final private void jj_save(int index, int xla) {
+ JJCalls p = jj_2_rtns[index];
+ while (p.gen > jj_gen) {
+ if (p.next == null) { p = p.next = new JJCalls(); break; }
+ p = p.next;
+ }
+ p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
+ }
+
+ static final class JJCalls {
+ int gen;
+ Token first;
+ int arg;
+ JJCalls next;
}
}
Modified: lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserConstants.java
URL: http://svn.apache.org/viewvc/lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserConstants.java?rev=575156&r1=575155&r2=575156&view=diff
==============================================================================
--- lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserConstants.java (original)
+++ lucene/hadoop/trunk/src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserConstants.java Wed Sep 12 21:01:05 2007
@@ -1,60 +1,65 @@
/* Generated By:JavaCC: Do not edit this line. ParserConstants.java */
-/**
- * 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.generated;
public interface ParserConstants {
int EOF = 0;
int HELP = 5;
- int CLEAR = 6;
- int SHOW = 7;
- int DESCRIBE = 8;
- int CREATE = 9;
- int DROP = 10;
- int FS = 11;
- int EXIT = 12;
- int INSERT = 13;
- int DELETE = 14;
- int SELECT = 15;
- int ROW = 16;
- int COLUMN = 17;
- int TIME = 18;
- int VALUES = 19;
- int COLUMNFAMILIES = 20;
- int WHERE = 21;
- int LIMIT = 22;
- int AND = 23;
- int OR = 24;
- int COMMA = 25;
- int DOT = 26;
- int LPAREN = 27;
- int RPAREN = 28;
- int EQUALS = 29;
- int NOTEQUAL = 30;
- int OPTIONS = 31;
- int ID = 32;
- int NUM = 33;
- int STRING = 34;
- int QUOTED_STRING = 35;
- int STRING_LITERAL = 36;
+ int ALTER = 6;
+ int CLEAR = 7;
+ int SHOW = 8;
+ int DESCRIBE = 9;
+ int DESC = 10;
+ int CREATE = 11;
+ int DROP = 12;
+ int FS = 13;
+ int EXIT = 14;
+ int INSERT = 15;
+ int INTO = 16;
+ int TABLE = 17;
+ int DELETE = 18;
+ int SELECT = 19;
+ int ENABLE = 20;
+ int DISABLE = 21;
+ int STARTING = 22;
+ int WHERE = 23;
+ int FROM = 24;
+ int ROW = 25;
+ int VALUES = 26;
+ int COLUMNFAMILIES = 27;
+ int TIMESTAMP = 28;
+ int NUM_VERSIONS = 29;
+ int LIMIT = 30;
+ int AND = 31;
+ int OR = 32;
+ int COMMA = 33;
+ int DOT = 34;
+ int LPAREN = 35;
+ int RPAREN = 36;
+ int EQUALS = 37;
+ int NOTEQUAL = 38;
+ int ASTERISK = 39;
+ int MAX_VERSIONS = 40;
+ int MAX_LENGTH = 41;
+ int COMPRESSION = 42;
+ int NONE = 43;
+ int BLOCK = 44;
+ int RECORD = 45;
+ int IN_MEMORY = 46;
+ int BLOOMFILTER = 47;
+ int COUNTING_BLOOMFILTER = 48;
+ int RETOUCHED_BLOOMFILTER = 49;
+ int VECTOR_SIZE = 50;
+ int NUM_HASH = 51;
+ int NUM_ENTRIES = 52;
+ int ADD = 53;
+ int CHANGE = 54;
+ int ID = 55;
+ int INTEGER_LITERAL = 56;
+ int FLOATING_POINT_LITERAL = 57;
+ int EXPONENT = 58;
+ int QUOTED_IDENTIFIER = 59;
+ int STRING_LITERAL = 60;
int DEFAULT = 0;
@@ -65,22 +70,30 @@
"\"\\r\"",
"\"\\n\"",
"\"help\"",
+ "\"alter\"",
"\"clear\"",
"\"show\"",
"\"describe\"",
+ "\"desc\"",
"\"create\"",
"\"drop\"",
"\"fs\"",
"\"exit\"",
"\"insert\"",
+ "\"into\"",
+ "\"table\"",
"\"delete\"",
"\"select\"",
+ "\"enable\"",
+ "\"disable\"",
+ "\"starting\"",
+ "\"where\"",
+ "\"from\"",
"\"row\"",
- "\"column\"",
- "\"time\"",
"\"values\"",
"\"columnfamilies\"",
- "\"where\"",
+ "\"timestamp\"",
+ "\"num_versions\"",
"\"limit\"",
"\"and\"",
"\"or\"",
@@ -90,11 +103,27 @@
"\")\"",
"\"=\"",
"\"<>\"",
- "\"-\"",
+ "\"*\"",
+ "\"max_versions\"",
+ "\"max_length\"",
+ "\"compression\"",
+ "\"none\"",
+ "\"block\"",
+ "\"record\"",
+ "\"in_memory\"",
+ "\"bloomfilter\"",
+ "\"counting_bloomfilter\"",
+ "\"retouched_bloomfilter\"",
+ "\"vector_size\"",
+ "\"num_hash\"",
+ "\"num_entries\"",
+ "\"add\"",
+ "\"change\"",
"<ID>",
- "<NUM>",
- "<STRING>",
- "<QUOTED_STRING>",
+ "<INTEGER_LITERAL>",
+ "<FLOATING_POINT_LITERAL>",
+ "<EXPONENT>",
+ "<QUOTED_IDENTIFIER>",
"<STRING_LITERAL>",
"\";\"",
};