Apache
/
hbase
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

HADOOP-1375 a simple parser for hbase 

M src/contrib/hbase/NOTICE.txt
    Add notice of udanax contributions.
Msrc/contrib/hbase/conf/hbase-default.xml
    (hbaseshell.jline.bell.enabled): Added.
M src/contrib/hbase/CHANGES.txt
    (hadoop-1375) Added.
M src/contrib/hbase/src/java/org/apache/hadoop/hbase/package.html
    Add note on how to start up hbase shell
M src/contrib/hbase/bin/hbase
    Add 'shell'.  Remove 'client' (shell does what it used do and more).
    Removed all reader and logreader until better developed.  Starting
    up a reader or logreader on a running hbase system could do damage).
M src/contrib/hbase/build.xml
    Add a javacc target to generate content of shell/generated subpackage.
A src/contrib/hbase/src/test/org/apache/hadoop/hbase/shell/TestHBaseShell.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/Shell.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/DeleteCommand.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/CreateCommand.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/DropCommand.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/InsertCommand.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/CommandFactory.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/HelpContents.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/ExitCommand.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/ConsoleTable.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/DescCommand.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/SelectCommand.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/Command.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/ShowCommand.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/BasicCommand.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/HelpManager.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/ReturnMsg.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/HelpCommand.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/HBaseShell.jj
    Added.
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/Token.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/TokenMgrError.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/SimpleCharStream.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserTokenManager.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParseException.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/ParserConstants.java
A src/contrib/hbase/src/java/org/apache/hadoop/hbase/shell/generated/Parser.java
    Added javacc generated files.


git-svn-id: https://svn.apache.org/repos/asf/lucene/hadoop/trunk/src/contrib/hbase@555415 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Michael Stack 2007-07-11 21:54:15 +00:00
parent f613907a98
commit 87f5d5dffd
32 changed files with 4543 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGES.txt
View File

@ -56,5 +56,4 @@ Trunk (unreleased changes)
33. HADOOP-1538 Provide capability for client specified time stamps in HBase
HADOOP-1466 Clean up visibility and javadoc issues in HBase.
34. HADOOP-1589 Exception handling in HBase is broken over client server connections
35. HADOOP-1375 a simple parser for hbase (Edward Yoon via Stack)

7
NOTICE.txt
View File

@ -1,5 +1,8 @@
This product includes software developed by The Apache Software
Foundation (http://www.apache.org/).
In addition, this product includes software developed by European Commission
project OneLab (http://www.one-lab.org)
In addition, this product includes software developed by:
European Commission project OneLab (http://www.one-lab.org)
Udanax (http://www.udanax.org)

12
bin/hbase
View File

@ -38,9 +38,7 @@ esac
if [ $# = 0 ]; then
echo "Usage: hbase [--hadoop=hadoopdir] <command>"
echo "where <command> is one of:"
echo " client run a hbase client"
echo " reader run a hbase region directory reader"
echo " logreader output content of a logfile"
echo " shell run the hbase shell"
echo " master run a hbase HMaster node"
echo " regionserver run a hbase HRegionServer node"
echo " or"
@ -181,12 +179,8 @@ fi
unset IFS
# figure out which class to run
if [ "$COMMAND" = "client" ] ; then
CLASS='org.apache.hadoop.hbase.HClient'
elif [ "$COMMAND" = "reader" ] ; then
CLASS='org.apache.hadoop.hbase.HRegiondirReader'
elif [ "$COMMAND" = "logreader" ] ; then
CLASS='org.apache.hadoop.hbase.HLog'
if [ "$COMMAND" = "shell" ] ; then
CLASS='org.apache.hadoop.hbase.Shell'
elif [ "$COMMAND" = "master" ] ; then
CLASS='org.apache.hadoop.hbase.HMaster'
elif [ "$COMMAND" = "regionserver" ] ; then

27
build.xml
View File

@ -5,9 +5,34 @@ Before you can run these subtargets directly, you need
to call at top-level: ant deploy-contrib compile-core-test
-->
<project name="hbase" default="jar">
<import file="../build-contrib.xml"/>
<target name="javacc" if="javacc.home">
<echo message="javacc.home: ${javacc.home}"/>
<property name="hbaseshell.src.dir"
value="${src.dir}/org/apache/hadoop/hbase/shell" />
<mkdir dir="${hbaseshell.src.dir}/generated" />
<javacc
target="${hbaseshell.src.dir}/HBaseShell.jj"
outputdirectory="${hbaseshell.src.dir}/generated"
javacchome="${javacc.home}"
/>
</target>
<target name="compile" depends="init,javacc">
<echo message="contrib: ${name}"/>
<javac
encoding="${build.encoding}"
srcdir="${src.dir}"
includes="**/*.java"
destdir="${build.classes}"
debug="${javac.debug}"
deprecation="${javac.deprecation}">
<classpath refid="classpath"/>
<classpath path="path"/>
</javac>
</target>
<!-- Override jar target to specify main class -->
<target name="jar" depends="compile">
<jar

9
conf/hbase-default.xml
View File

@ -110,4 +110,13 @@
value + (value / 2), the HRegion is split in two. Default: 128M.
</description>
</property>
<!-- HbaseShell Configurations -->
<property>
<name>hbaseshell.jline.bell.enabled</name>
<value>true</value>
<description>
if true, enable audible keyboard bells if an alert is required.
</description>
</property>
</configuration>

95
src/java/org/apache/hadoop/hbase/Shell.java Normal file
View File

@ -0,0 +1,95 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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;
import java.io.IOException;
import jline.ConsoleReader;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.shell.Command;
import org.apache.hadoop.hbase.shell.HelpManager;
import org.apache.hadoop.hbase.shell.ReturnMsg;
import org.apache.hadoop.hbase.shell.generated.ParseException;
import org.apache.hadoop.hbase.shell.generated.Parser;
import org.apache.hadoop.hbase.shell.generated.TokenMgrError;
/**
* An hbase shell.
*
* @see <a href="http://wiki.apache.org/lucene-hadoop/Hbase/HbaseShell">HBaseShell</a>
*/
public class Shell {
/** audible keyboard bells */
public static final boolean DEFAULT_BELL_ENABLED = true;
/** Main method */
public static void main(String args[]) throws IOException {
Configuration conf = new HBaseConfiguration();
HClient client = new HClient(conf);
ConsoleReader reader = new ConsoleReader();
reader.setBellEnabled(conf.getBoolean("hbaseshell.jline.bell.enabled",
DEFAULT_BELL_ENABLED));
HelpManager help = new HelpManager();
help.printVersion();
StringBuilder queryStr = new StringBuilder();
String extendedLine;
while ((extendedLine = reader.readLine(getPrompt(queryStr))) != null) {
if (isEndOfCommand(extendedLine)) {
queryStr.append(" " + extendedLine);
long start = System.currentTimeMillis();
Parser parser = new Parser(queryStr.toString());
ReturnMsg rs = null;
try {
Command cmd = parser.terminatedCommand();
if (cmd != null) {
rs = cmd.execute(client);
}
} catch (ParseException pe) {
String[] msg = pe.getMessage().split("[\n]");
System.out.println("Syntax error : Type 'help' for usage: " + msg[0]);
} catch (TokenMgrError te) {
System.out.println("Lexical error : Type 'help' for usage.");
}
long end = System.currentTimeMillis();
if (rs != null && rs.getType() > -1)
System.out.println(rs.getMsg()
+ executeTime((rs.getType() == 1), start, end));
queryStr = new StringBuilder();
} else {
queryStr.append(" " + extendedLine);
}
}
System.out.println();
}
/** Return the boolean value indicating whether end of command or not */
static boolean isEndOfCommand(String line) {
return (line.lastIndexOf(';') > -1) ? true : false;
}
/** Return the string of prompt start string */
private static String getPrompt(final StringBuilder queryStr) {
return (queryStr.toString().equals("")) ? "HBase > " : " --> ";
}
/** return a string of code execution time. */
public static String executeTime(boolean watch, long start, long end) {
return (watch) ? "(" + String.format("%.2f", (end - start) * 0.001) + " sec)" : "";
}
}

4
src/java/org/apache/hadoop/hbase/package.html
View File

@ -37,6 +37,10 @@ ${HBASE_HOME}/bin/stop-hbase.sh
</pre>
Logs can be found in ${HADOOP_LOG_DIR}.
</p>
<p>To obtain a shell against a running hbase instance, run:
<pre>${HBASE_HOME}/bin/hbase shell</pre>
Once the shell is up, type <code>help;</code> to see list of supported commands.
</p>
<h2>Related Documentation</h2>

32
src/java/org/apache/hadoop/hbase/shell/BasicCommand.java Normal file
View File

@ -0,0 +1,32 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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;
/**
* @see <a href="http://wiki.apache.org/lucene-hadoop/Hbase/HbaseShell">HBaseShell</a>
*/
public abstract class BasicCommand implements Command, CommandFactory {
public BasicCommand getBasicCommand() {
return this;
}
/** basic commands are their own factories. */
public Command getCommand() {
return this;
}
}

26
src/java/org/apache/hadoop/hbase/shell/Command.java Normal file
View File

@ -0,0 +1,26 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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 org.apache.hadoop.hbase.HClient;
public interface Command {
/** family indicator */
public static final String FAMILY_INDICATOR = ":";
/** Execute a command */
public ReturnMsg execute(HClient client);
}

23
src/java/org/apache/hadoop/hbase/shell/CommandFactory.java Normal file
View File

@ -0,0 +1,23 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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;
/**
* Parser uses command factories to create command.
*/
public interface CommandFactory {
Command getCommand();
}

186
src/java/org/apache/hadoop/hbase/shell/ConsoleTable.java Normal file
View File

@ -0,0 +1,186 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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;
/**
* Manufactures console table, but stupid.
*/
public class ConsoleTable {
public static void printHead(String name) {
System.out.println("+------+----------------------+");
System.out.print("| No. | ");
System.out.printf("%-20s", name);
System.out.println(" |");
}
public static void printFoot() {
System.out.println("+------+----------------------+");
System.out.println();
}
public static void printTable(int count, String name) {
System.out.println("+------+----------------------+");
if (name.length() > 20) {
int interval = 20;
System.out.print("| ");
System.out.printf("%-4s", count + 1);
System.out.print(" | ");
System.out.printf("%-20s", name.substring(0, interval));
System.out.println(" |");
for (int i = 0; i < name.length() / interval; i++) {
System.out.print("| ");
System.out.printf("%-4s", "");
System.out.print(" | ");
int end = ((interval * i) + interval + interval);
if (end > name.length()) {
System.out.printf("%-20s", name.substring(end - interval,
name.length()));
} else {
System.out.printf("%-20s", name.substring(end - interval, end));
}
System.out.println(" |");
}
} else {
System.out.print("| ");
System.out.printf("%-4s", count + 1);
System.out.print(" | ");
System.out.printf("%-20s", name);
System.out.println(" |");
}
}
public static void selectHead() {
System.out.println("+------+----------------------+" +
"----------------------+----------------------+");
System.out.print("| No. | ");
System.out.printf("%-20s", "Row");
System.out.printf(" | ");
System.out.printf("%-20s", "Column");
System.out.printf(" | ");
System.out.printf("%-20s", "Cell");
System.out.println(" | ");
}
public static void printLine(int count, String key, String column,
String cellData) {
System.out.println("+------+----------------------+" +
"----------------------+----------------------+");
if (key.length() > 20 || column.length() > 20 || cellData.length() > 20) {
int interval = 20;
System.out.print("| ");
System.out.printf("%-4s", count + 1);
System.out.print(" | ");
if (key.length() > 20)
System.out.printf("%-20s", key.substring(0, interval));
else
System.out.printf("%-20s", key);
System.out.print(" | ");
if (column.length() > 20)
System.out.printf("%-20s", column.substring(0, interval));
else
System.out.printf("%-20s", column);
System.out.print(" | ");
if (cellData.length() > 20)
System.out.printf("%-20s", cellData.substring(0, interval));
else
System.out.printf("%-20s", cellData);
System.out.println(" |");
// System.out.println(getBiggerInt(new int[]{ 3, 1, 9}));
int biggerStrLength = getBiggerInt(new int[] { key.length(),
column.length(), cellData.length() });
for (int i = 0; i < (biggerStrLength / interval); i++) {
System.out.print("| ");
System.out.printf("%-4s", "");
System.out.print(" | ");
int end = ((interval * i) + interval + interval);
if (end > key.length()) {
if (key.length() > interval && end - interval < key.length()) {
System.out.printf("%-20s", key.substring(end - interval,
key.length()));
} else {
System.out.printf("%-20s", "");
}
} else {
System.out.printf("%-20s", key.substring(end - interval, end));
}
System.out.print(" | ");
if (end > column.length()) {
if (column.length() > interval && end - interval < column.length()) {
System.out.printf("%-20s", column.substring(end - interval,
column.length()));
} else {
System.out.printf("%-20s", "");
}
} else {
System.out.printf("%-20s", column.substring(end - interval, end));
}
System.out.print(" | ");
if (end > cellData.length()) {
if (cellData.length() > interval &&
end - interval < cellData.length()) {
System.out.printf("%-20s",
cellData.substring(end - interval, cellData.length()));
} else {
System.out.printf("%-20s", "");
}
} else {
System.out.printf("%-20s", cellData.substring(end - interval, end));
}
System.out.println(" |");
}
} else {
System.out.print("| ");
System.out.printf("%-4s", count + 1);
System.out.print(" | ");
System.out.printf("%-20s", key);
System.out.print(" | ");
System.out.printf("%-20s", column);
System.out.print(" | ");
System.out.printf("%-20s", cellData);
System.out.println(" |");
}
}
public static int getBiggerInt(int[] integers) {
int result = -1;
for (int i = 0; i < integers.length; i++) {
if (integers[i] > result) {
result = integers[i];
}
}
return result;
}
public static void selectFoot() {
System.out.println("+------+----------------------+" +
"----------------------+----------------------+");
System.out.println();
}
}

68
src/java/org/apache/hadoop/hbase/shell/CreateCommand.java Normal file
View File

@ -0,0 +1,68 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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.IOException;
import java.util.List;
import org.apache.hadoop.hbase.HClient;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
public class CreateCommand extends BasicCommand {
String table;
List<String> columnfamilies;
int limit;
public ReturnMsg execute(HClient client) {
if (this.table == null || this.columnfamilies == null)
return new ReturnMsg(0, "Syntax error : Please check 'Create' syntax.");
try {
HTableDescriptor desc = new HTableDescriptor(this.table);
for (int i = 0; i < this.columnfamilies.size(); i++) {
String columnFamily = columnfamilies.get(i);
if (columnFamily.lastIndexOf(':') == (columnFamily.length() - 1)) {
columnFamily = columnFamily.substring(0, columnFamily.length() - 1);
}
desc.addFamily(new HColumnDescriptor(columnFamily + FAMILY_INDICATOR));
}
client.createTable(desc);
return new ReturnMsg(1, "Table created successfully.");
} catch (IOException e) {
return new ReturnMsg(0, "error msg : " + e.toString());
}
}
public void setTable(String table) {
this.table = table;
}
public void setColumnfamilies(List<String> columnfamilies) {
this.columnfamilies = columnfamilies;
}
public void setLimit(int limit) {
this.limit = limit;
}
}

79
src/java/org/apache/hadoop/hbase/shell/DeleteCommand.java Normal file
View File

@ -0,0 +1,79 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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.IOException;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.hadoop.hbase.HClient;
import org.apache.hadoop.io.Text;
public class DeleteCommand extends BasicCommand {
String table;
Map<String, List<String>> condition;
public ReturnMsg execute(HClient client) {
if (this.table == null || condition == null)
return new ReturnMsg(0, "Syntax error : Please check 'Delete' syntax.");
try {
client.openTable(new Text(this.table));
long lockId = client.startUpdate(getRow());
if (getColumn() != null) {
client.delete(lockId, getColumn());
} else {
Set<Text> keySet = client.getRow(getRow()).keySet();
Text[] columnKey = keySet.toArray(new Text[keySet.size()]);
for (int i = 0; i < columnKey.length; i++) {
client.delete(lockId, columnKey[i]);
}
}
client.commit(lockId);
return new ReturnMsg(1, "1 deleted successfully. ");
} catch (IOException e) {
return new ReturnMsg(0, "error msg : " + e.toString());
}
}
public void setTable(String table) {
this.table = table;
}
public void setCondition(Map<String, List<String>> cond) {
this.condition = cond;
}
public Text getRow() {
return new Text(this.condition.get("row").get(1));
}
public Text getColumn() {
if (this.condition.containsKey("column")) {
return new Text(this.condition.get("column").get(1));
} else {
return null;
}
}
}

61
src/java/org/apache/hadoop/hbase/shell/DescCommand.java Normal file
View File

@ -0,0 +1,61 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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.IOException;
import org.apache.hadoop.hbase.HClient;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.io.Text;
public class DescCommand extends BasicCommand {
String argument;
public ReturnMsg execute(HClient client) {
if (this.argument == null)
return new ReturnMsg(0, "Syntax error : Please check 'Describe' syntax.");
try {
HTableDescriptor[] tables = client.listTables();
Text[] columns = null;
for (int i = 0; i < tables.length; i++) {
if (tables[i].getName().toString().equals(this.argument)) {
columns = tables[i].families().keySet().toArray(new Text[] {});
}
}
if (columns == null) {
return new ReturnMsg(0, "Table not found.");
}
ConsoleTable.printHead("ColumnFamily Name");
for (int ii = 0; ii < columns.length; ii++) {
String familyName = columns[ii].toString().replace(FAMILY_INDICATOR, "");
ConsoleTable.printTable(ii, familyName);
}
ConsoleTable.printFoot();
return new ReturnMsg(1, columns.length + " columnfamilie(s) found.");
} catch (IOException e) {
return new ReturnMsg(0, "error msg : " + e.toString());
}
}
public void setArgument(String argument) {
this.argument = argument;
}
}

42
src/java/org/apache/hadoop/hbase/shell/DropCommand.java Normal file
View File

@ -0,0 +1,42 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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.IOException;
import org.apache.hadoop.hbase.HClient;
import org.apache.hadoop.io.Text;
public class DropCommand extends BasicCommand {
String argument;
public ReturnMsg execute(HClient client) {
if (this.argument == null)
return new ReturnMsg(0, "Syntax error : Please check 'Drop' syntax.");
try {
client.deleteTable(new Text(this.argument));
return new ReturnMsg(1, "Table droped successfully.");
} catch (IOException e) {
return new ReturnMsg(0, "error msg : " + e.toString());
}
}
public void setArgument(String argument) {
this.argument = argument;
}
}

27
src/java/org/apache/hadoop/hbase/shell/ExitCommand.java Normal file
View File

@ -0,0 +1,27 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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 org.apache.hadoop.hbase.HClient;
public class ExitCommand extends BasicCommand {
public ReturnMsg execute(HClient client) {
System.exit(1);
return null;
}
}

474
src/java/org/apache/hadoop/hbase/shell/HBaseShell.jj Normal file
View File

@ -0,0 +1,474 @@
options {
STATIC = false;
IGNORE_CASE = true;
}
PARSER_BEGIN(Parser)
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.io.StringReader;
import java.io.Reader;
import org.apache.hadoop.hbase.shell.*;
/**
* Parsing command line.
*/
public class Parser {
private static String QueryString;
public Parser(String query) {
this((Reader)(new StringReader(query)));
this.QueryString = query;
}
public String getQueryStr() {
return this.QueryString;
}
}
PARSER_END(Parser)
SKIP :
{
" "
| "\t"
| "\r"
| "\n"
}
TOKEN:
{
<HELP: "help">
| <SHOW: "show">
| <DESCRIBE: "describe">
| <CREATE: "create">
| <DROP: "drop">
| <EXIT: "exit">
| <INSERT: "insert">
| <DELETE: "delete">
| <SELECT: "select">
| <ROW: "row">
| <COLUMN: "column">
| <TIME: "time">
| <VALUES: "values">
| <COLUMNFAMILIES: "columnfamilies">
| <WHERE: "where">
| <LIMIT: "limit">
| <AND: "and">
| <OR: "or">
| <COMMA: ",">
| <DOT: ".">
| <LPAREN: "(">
| <RPAREN: ")">
| <EQUALS: "=">
| <NOTEQUAL: "<>">
| <OPTIONS: "-">
}
TOKEN :
{
<ID: ["a"-"z","A"-"Z","_","-"] ( ["a"-"z","A"-"Z","_","0"-"9","-"] )* >
| <NUM: ( ["0"-"9"] )+ >
| <STRING: (["A"-"Z","a"-"z","0"-"9"])+ >
| <QUOTED_STRING: "\"" (~["\""])+ "\"" >
| <STRING_LITERAL: "'" (~["'"])* ( "''" (~["'"])* )* "'" >
}
/**
* Parses the given array of command line arguments.
*/
Command terminatedCommand() :
{
Command statement = null;
}
{
([statement = cmdStatement()] ";" | <EOF>)
{
return statement;
}
}
Command cmdStatement() :
{
Command cmd = null;
}
{
(
cmd = exitCommand()
| cmd = helpCommand()
| cmd = showCommand()
| cmd = descCommand()
| cmd = createCommand()
| cmd = dropCommand()
| cmd = insertCommand()
| cmd = deleteCommand()
| cmd = selectCommand()
)
{
return cmd;
}
}
ExitCommand exitCommand() :
{
ExitCommand exit = new ExitCommand();
}
{
<EXIT> { return exit; }
}
HelpCommand helpCommand() :
{
Token t = null;
HelpCommand help = new HelpCommand();
String argument = "";
}
{
<HELP>
[
(
t=<SHOW>
| t=<DESCRIBE>
| t=<CREATE>
| t=<DROP>
| t=<EXIT>
| t=<INSERT>
| t=<DELETE>
| t=<SELECT>
| t=<ID>
) { argument = t.image.toString(); }
]
{
help.setArgument(argument);
return help;
}
}
ShowCommand showCommand() :
{
ShowCommand show = new ShowCommand();
String argument = null;
}
{
<SHOW>
[
argument = getString()
]
{
show.setArgument(argument);
return show;
}
}
DescCommand descCommand() :
{
DescCommand desc = new DescCommand();
String argument = null;
}
{
<DESCRIBE>
[
argument = getString()
]
{
desc.setArgument(argument);
return desc;
}
}
CreateCommand createCommand() :
{
CreateCommand create = new CreateCommand();
String argument = null;
List<String> columnfamilies = null;
int limit = 1;
}
{
<CREATE>
argument = getString()
{
create.setTable(argument);
}
<COLUMNFAMILIES>
columnfamilies = getLiteralValues()
{
create.setColumnfamilies(columnfamilies);
}
[ <LIMIT><EQUALS> limit = getInt() {
try{
create.setLimit(limit);
}catch(ClassCastException ce) {
throw generateParseException();
}
} ]
{ return create; }
}
DropCommand dropCommand() :
{
DropCommand drop = new DropCommand();
String argument = null;
}
{
<DROP>
[
argument = getString()
]
{
drop.setArgument(argument);
return drop;
}
}
InsertCommand insertCommand() :
{
InsertCommand in = new InsertCommand();
Map<String, List<String>> cond = null;
List<String> columnfamilies = null;
List<String> values = null;
String table = null;
}
{
<INSERT>
table = getString()
{
in.setTable(table);
}
columnfamilies = getLiteralValues()
{
in.setColumnfamilies(columnfamilies);
}
<VALUES> values = getLiteralValues()
{
in.setValues(values);
}
<WHERE> cond = WhereClause()
{
try{
in.setCondition(cond);
}catch(ClassCastException ce) {
throw generateParseException();
}
}
{
return in;
}
}
DeleteCommand deleteCommand() :
{
DeleteCommand del = new DeleteCommand();
Map<String, List<String>> cond = null;
String argument = null;
}
{
<DELETE>
argument = getString()
{
del.setTable(argument);
}
<WHERE> cond = WhereClause() {
try{
del.setCondition(cond);
}catch(ClassCastException ce) {
throw generateParseException();
}
}
{
return del;
}
}
SelectCommand selectCommand() :
{
SelectCommand select = new SelectCommand();
Map<String, List<String>> cond = null;
String argument = null;
int limit;
}
{
<SELECT>
argument = getString()
{
select.setTable(argument);
}
[ <WHERE> cond = WhereClause() {
try{
select.setCondition(cond);
}catch(ClassCastException ce) {
throw generateParseException();
}
} ]
[ <LIMIT><EQUALS> limit = getInt() {
try{
select.setLimit(limit);
}catch(ClassCastException ce) {
throw generateParseException();
}
} ]
{ return select; }
}
/**
* TODO : expressions codes need more love.
*/
String getString():
{ Token t = null; }
{
( t=<ID>
| t=<QUOTED_STRING>
)
{ return t.image.toString(); }
}
int getInt():
{ Token t = null; }
{
t = <NUM>
{ return Integer.parseInt(t.image.toString()); }
}
Map<String, List<String>> WhereClause() :
{
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);
}
}
(
<AND> {
try{
result.putAll(ConditionExpression());
}catch(ParseException pe) {
exception.add(pe.toString());
result.put("error", exception);
}
}
)*
{ return result; }
}
Map<String, List<String>> ConditionExpression() :
{
Token tSearchName, tComparator, tComparand;
Map<String, List<String>> tmp =
new HashMap<String, List<String>>();
List<String> values =
new ArrayList<String>();
}
{
(
tSearchName=<ROW>
| tSearchName=<COLUMN>
| tSearchName=<TIME>
| tSearchName=<ID>
| tSearchName=<VALUES>
| tSearchName=<COLUMNFAMILIES>
)
( tComparator=<EQUALS> | tComparator=<NOTEQUAL> )
( tComparand=<QUOTED_STRING>
{
values.add("quoted string");
tmp.put("error", values);
return tmp;
}
| tComparand=<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);
}
return tmp;
} )
}
List<String> getLiteralValues() :
{
List<String> values = new ArrayList<String>();
String literal = null;
}
{
<LPAREN>
{ literal = getStringLiteral();
if(literal != null) values.add(literal);
}
(
<COMMA> {
literal = getStringLiteral();
if(literal != null) values.add(literal);
}
| (
<ID>
| <STRING_LITERAL>
| <QUOTED_STRING>
| <STRING>
) { values.removeAll(values); }
)*
<RPAREN>
{
return values;
}
}
String getStringLiteral() :
{
Token stringLiteral;
}
{
stringLiteral=<STRING_LITERAL>
{ return stringLiteral.image.substring(1,stringLiteral.image.length() - 1); }
| <QUOTED_STRING> { return null; }
}

31
src/java/org/apache/hadoop/hbase/shell/HelpCommand.java Normal file
View File

@ -0,0 +1,31 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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 org.apache.hadoop.hbase.HClient;
public class HelpCommand extends BasicCommand {
String argument;
public ReturnMsg execute(HClient client) {
HelpManager.printHelp(this.argument);
return null;
}
public void setArgument(String argument) {
this.argument = argument;
}
}

61
src/java/org/apache/hadoop/hbase/shell/HelpContents.java Normal file
View File

@ -0,0 +1,61 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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.util.HashMap;
import java.util.Map;
public class HelpContents {
/**
* add help contents
*/
public static Map<? extends String, ? extends String[]> Load() {
Map<String, String[]> load = new HashMap<String, String[]>();
load.put("SHOW", new String[] { "List all tables.", "SHOW TABLES;" });
load.put("DESCRIBE", new String[] { "Describe a table's columnfamilies.",
"DESCRIBE <table_name>;" });
load.put("CREATE", new String[] {
"Create a table",
"CREATE <table_name>"
+ "\n\t COLUMNFAMILIES('cf_name1'[, 'cf_name2', ...]);"
+ "\n [LIMIT=versions_limit];" });
load.put("DROP", new String[] {
"Drop columnfamilie(s) from a table or drop table(s)",
"DROP table_name1[, table_name2, ...] | cf_name1[, cf_name2, ...];" });
load.put("INSERT", new String[] {
"Insert row into table",
"INSERT <table_name>" + "\n\t('column_name1'[, 'column_name2', ...])"
+ "\n\t VALUES('entry1'[, 'entry2', ...])"
+ "\n WHERE row='row_key';" });
load.put("DELETE", new String[] {
"Delete cell or row in table.",
"DELETE <table_name>" + "\n\t WHERE row='row_key;"
+ "\n [AND column='column_name'];" });
load.put("SELECT",
new String[] {
"Select values from a table",
"SELECT <table_name>" + "\n\t [WHERE row='row_key']"
+ "\n [AND column='column_name'];"
+ "\n [AND time='timestamp'];"
+ "\n [LIMIT=versions_limit];" });
load.put("EXIT", new String[] { "Exit shell", "EXIT;" });
return load;
}
}

78
src/java/org/apache/hadoop/hbase/shell/HelpManager.java Normal file
View File

@ -0,0 +1,78 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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.util.HashMap;
import java.util.Map;
/**
* Prints a usage message for the program to the given stream.
*/
public class HelpManager {
/** application name */
public static final String APP_NAME = "HBase Shell";
/** version of the code */
public static final String APP_VERSION = "0.0.1";
/** help contents map */
public static final Map<String, String[]> help = new HashMap<String, String[]>();
public HelpManager() {
help.putAll(HelpContents.Load());
}
/** Print out the program version. */
public void printVersion() {
System.out.println("\n" + APP_NAME + ", " + APP_VERSION + " version.\n"
+ "Copyright (c) 2007 by udanax, "
+ "licensed to Apache Software Foundation.\n"
+ "Type 'help;' for usage.\n");
}
public static void printHelp(String cmd) {
if (cmd.equals("")) {
System.out.println("\nType 'help <command>;' to see command-specific "
+ "usage.\n");
for (Map.Entry<String, String[]> helpMap : help.entrySet()) {
wrapping(helpMap.getKey(), helpMap.getValue(), false);
}
System.out.println();
} else {
if (help.containsKey(cmd.toUpperCase())) {
System.out.println();
String[] msg = help.get(cmd.toUpperCase());
wrapping(cmd.toUpperCase(), msg, true);
} else {
System.out.println("Unknown Command : Type 'help' for usage.");
}
}
}
public static void wrapping(String cmd, String[] cmdType, boolean example) {
System.out.printf("%-10s", cmd);
if (cmdType[0].length() > 55) {
System.out.println(cmdType[0].substring(0, 55));
System.out.printf("%13s", "");
System.out.println(cmdType[0].substring(55, cmdType[1].length()));
} else {
System.out.println(cmdType[0]);
}
if (example)
System.out.println("\n>>> " + cmdType[1] + "\n");
}
}

86
src/java/org/apache/hadoop/hbase/shell/InsertCommand.java Normal file
View File

@ -0,0 +1,86 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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.IOException;
import java.util.List;
import java.util.Map;
import org.apache.hadoop.hbase.HClient;
import org.apache.hadoop.io.Text;
public class InsertCommand extends BasicCommand {
String table;
List<String> columnfamilies;
List<String> values;
Map<String, List<String>> condition;
public ReturnMsg execute(HClient client) {
if (this.table == null || this.values == null || this.condition == null)
return new ReturnMsg(0, "Syntax error : Please check 'Insert' syntax.");
if (this.columnfamilies.size() != this.values.size())
return new ReturnMsg(0,
"Mismatch between values list and columnfamilies list");
try {
client.openTable(new Text(this.table));
long lockId = client.startUpdate(new Text(getRow()));
for (int i = 0; i < this.values.size(); i++) {
client.put(lockId, getColumn(i), getValue(i));
}
client.commit(lockId);
return new ReturnMsg(1, "1 row inserted successfully.");
} catch (IOException e) {
String[] msg = e.getMessage().split("[\n]");
return new ReturnMsg(0, msg[0]);
}
}
public void setTable(String table) {
this.table = table;
}
public void setColumnfamilies(List<String> columnfamilies) {
this.columnfamilies = columnfamilies;
}
public void setValues(List<String> values) {
this.values = values;
}
public void setCondition(Map<String, List<String>> cond) {
this.condition = cond;
}
public Text getRow() {
return new Text(this.condition.get("row").get(1));
}
public Text getColumn(int i) {
return new Text(this.columnfamilies.get(i));
}
public byte[] getValue(int i) {
return this.values.get(i).getBytes();
}
}

40
src/java/org/apache/hadoop/hbase/shell/ReturnMsg.java Normal file
View File

@ -0,0 +1,40 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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;
public class ReturnMsg {
private String msg;
private int type;
public ReturnMsg(int i, String string) {
this.type = i;
this.msg = string;
}
public ReturnMsg(int i) {
this.type = i;
this.msg = "";
}
public String getMsg() {
return this.msg;
}
public int getType() {
return this.type;
}
}

243
src/java/org/apache/hadoop/hbase/shell/SelectCommand.java Normal file
View File

@ -0,0 +1,243 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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.IOException;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.apache.hadoop.hbase.HClient;
import org.apache.hadoop.hbase.HConstants;
import org.apache.hadoop.hbase.HRegionInfo;
import org.apache.hadoop.hbase.HScannerInterface;
import org.apache.hadoop.hbase.HStoreKey;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.io.DataInputBuffer;
import org.apache.hadoop.io.Text;
public class SelectCommand extends BasicCommand {
String table;
int limit;
Map<String, List<String>> condition;
public ReturnMsg execute(HClient client) {
if (this.condition != null && this.condition.containsKey("error"))
return new ReturnMsg(0, "Syntax error : Please check 'Select' syntax.");
try {
client.openTable(new Text(this.table));
switch (getCondition()) {
case 0:
HTableDescriptor[] tables = client.listTables();
Text[] columns = null;
if (this.table.equals(HConstants.ROOT_TABLE_NAME.toString())
|| this.table.equals(HConstants.META_TABLE_NAME.toString())) {
columns = HConstants.COLUMN_FAMILY_ARRAY;
} else {
for (int i = 0; i < tables.length; i++) {
if (tables[i].getName().toString().equals(this.table)) {
columns = tables[i].families().keySet().toArray(new Text[] {});
}
}
}
HScannerInterface scan = client.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);
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++;
}
results = new TreeMap<Text, byte[]>();
}
ConsoleTable.selectFoot();
scan.close();
break;
case 1:
count = 0;
ConsoleTable.selectHead();
for (Map.Entry<Text, byte[]> entry : client.getRow(new Text(getRow())).entrySet()) {
byte[] value = entry.getValue();
String cellData = new String(value);
if (entry.getKey().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, getRow().toString(), entry.getKey().toString(),
cellData);
count++;
}
ConsoleTable.selectFoot();
break;
case 2:
Text[] column = new Text[] { new Text(getColumn()) };
HScannerInterface scanner = client.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);
ConsoleTable.printLine(count, rowKey.toString(), columnKey.toString(),
cellData);
count++;
}
results = new TreeMap<Text, byte[]>();
}
ConsoleTable.selectFoot();
scanner.close();
break;
case 3:
byte[] rs1 = client.get(new Text(getRow()), new Text(getColumn()));
ConsoleTable.selectHead();
ConsoleTable.printLine(0, getRow(), getColumn(),
new String(rs1, HConstants.UTF8_ENCODING));
ConsoleTable.selectFoot();
break;
case 4:
byte[][] rs2 = client.get(new Text(getRow()), new Text(getColumn()), this.limit);
ConsoleTable.selectHead();
for (int i = 0; i < rs2.length; i++) {
ConsoleTable.printLine(i, getRow(), getColumn(),
new String(rs2[i], HConstants.UTF8_ENCODING));
}
ConsoleTable.selectFoot();
break;
case 5:
byte[][] rs3 = client.get(new Text(getRow()), new Text(getColumn()), getTime(), this.limit);
ConsoleTable.selectHead();
for (int i = 0; i < rs3.length; i++) {
ConsoleTable.printLine(i, getRow(), getColumn(), new String(rs3[i]));
}
ConsoleTable.selectFoot();
break;
}
return new ReturnMsg(1, "Successfully print out the selected data.");
} catch (IOException e) {
String[] msg = e.getMessage().split("[,]");
return new ReturnMsg(0, msg[0]);
}
}
public void setTable(String table) {
this.table = table;
}
public void setLimit(int limit) {
this.limit = limit;
}
public void setCondition(Map<String, List<String>> cond) {
this.condition = cond;
}
public String getRow() {
return this.condition.get("row").get(1);
}
public String getColumn() {
return this.condition.get("column").get(1);
}
public long getTime() {
return Long.parseLong(this.condition.get("time").get(1));
}
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;
}
}

58
src/java/org/apache/hadoop/hbase/shell/ShowCommand.java Normal file
View File

@ -0,0 +1,58 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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.IOException;
import org.apache.hadoop.hbase.HClient;
import org.apache.hadoop.hbase.HTableDescriptor;
public class ShowCommand extends BasicCommand {
String argument;
public ReturnMsg execute(HClient client) {
if (this.argument == null)
return new ReturnMsg(0, "Syntax error : Please check 'Show' syntax.");
try {
int tableLength = 0;
if ("tables".equals(this.argument)) {
HTableDescriptor[] tables = client.listTables();
tableLength = tables.length;
if (tableLength == 0) {
return new ReturnMsg(0, "Table not found.");
}
ConsoleTable.printHead("Table Name");
for (int i = 0; i < tableLength; i++) {
String tableName = tables[i].getName().toString();
ConsoleTable.printTable(i, tableName);
}
ConsoleTable.printFoot();
return new ReturnMsg(1, tableLength + " table(s) found.");
}
return new ReturnMsg(0, "Missing parameters. Please check 'Show' syntax.");
} catch (IOException e) {
return new ReturnMsg(0, "error msg : " + e.toString());
}
}
public void setArgument(String argument) {
this.argument = argument;
}
}

207
src/java/org/apache/hadoop/hbase/shell/generated/ParseException.java Normal file
View File

@ -0,0 +1,207 @@
/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 3.0 */
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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;
/**
* This exception is thrown when parse errors are encountered.
* You can explicitly create objects of this exception type by
* calling the method generateParseException in the generated
* parser.
*
* You can modify this class to customize your error reporting
* mechanisms so long as you retain the public fields.
*/
public class ParseException extends Exception {
/**
* This constructor is used by the method "generateParseException"
* in the generated parser. Calling this constructor generates
* a new object of this type with the fields "currentToken",
* "expectedTokenSequences", and "tokenImage" set. The boolean
* flag "specialConstructor" is also set to true to indicate that
* this constructor was used to create this object.
* This constructor calls its super class with the empty string
* to force the "toString" method of parent class "Throwable" to
* print the error message in the form:
* ParseException: <result of getMessage>
*/
public ParseException(Token currentTokenVal,
int[][] expectedTokenSequencesVal,
String[] tokenImageVal
)
{
super("");
specialConstructor = true;
currentToken = currentTokenVal;
expectedTokenSequences = expectedTokenSequencesVal;
tokenImage = tokenImageVal;
}
/**
* The following constructors are for use by you for whatever
* purpose you can think of. Constructing the exception in this
* manner makes the exception behave in the normal way - i.e., as
* documented in the class "Throwable". The fields "errorToken",
* "expectedTokenSequences", and "tokenImage" do not contain
* relevant information. The JavaCC generated code does not use
* these constructors.
*/
public ParseException() {
super();
specialConstructor = false;
}
public ParseException(String message) {
super(message);
specialConstructor = false;
}
/**
* This variable determines which constructor was used to create
* this object and thereby affects the semantics of the
* "getMessage" method (see below).
*/
protected boolean specialConstructor;
/**
* This is the last token that has been consumed successfully. If
* this object has been created due to a parse error, the token
* followng this token will (therefore) be the first error token.
*/
public Token currentToken;
/**
* Each entry in this array is an array of integers. Each array
* of integers represents a sequence of tokens (by their ordinal
* values) that is expected at this point of the parse.
*/
public int[][] expectedTokenSequences;
/**
* This is a reference to the "tokenImage" array of the generated
* parser within which the parse error occurred. This array is
* defined in the generated ...Constants interface.
*/
public String[] tokenImage;
/**
* This method has the standard behavior when this object has been
* created using the standard constructors. Otherwise, it uses
* "currentToken" and "expectedTokenSequences" to generate a parse
* error message and returns it. If this object has been created
* due to a parse error, and you do not catch it (it gets thrown
* from the parser), then this method is called during the printing
* of the final stack trace, and hence the correct error message
* gets displayed.
*/
public String getMessage() {
if (!specialConstructor) {
return super.getMessage();
}
StringBuffer expected = new StringBuffer();
int maxSize = 0;
for (int i = 0; i < expectedTokenSequences.length; i++) {
if (maxSize < expectedTokenSequences[i].length) {
maxSize = expectedTokenSequences[i].length;
}
for (int j = 0; j < expectedTokenSequences[i].length; j++) {
expected.append(tokenImage[expectedTokenSequences[i][j]]).append(" ");
}
if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {
expected.append("...");
}
expected.append(eol).append(" ");
}
String retval = "Encountered \"";
Token tok = currentToken.next;
for (int i = 0; i < maxSize; i++) {
if (i != 0) retval += " ";
if (tok.kind == 0) {
retval += tokenImage[0];
break;
}
retval += add_escapes(tok.image);
tok = tok.next;
}
retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn;
retval += "." + eol;
if (expectedTokenSequences.length == 1) {
retval += "Was expecting:" + eol + " ";
} else {
retval += "Was expecting one of:" + eol + " ";
}
retval += expected.toString();
return retval;
}
/**
* The end of line string for this machine.
*/
protected String eol = System.getProperty("line.separator", "\n");
/**
* Used to convert raw characters to their escaped version
* when these raw version cannot be used as part of an ASCII
* string literal.
*/
protected String add_escapes(String str) {
StringBuffer retval = new StringBuffer();
char ch;
for (int i = 0; i < str.length(); i++) {
switch (str.charAt(i))
{
case 0 :
continue;
case '\b':
retval.append("\\b");
continue;
case '\t':
retval.append("\\t");
continue;
case '\n':
retval.append("\\n");
continue;
case '\f':
retval.append("\\f");
continue;
case '\r':
retval.append("\\r");
continue;
case '\"':
retval.append("\\\"");
continue;
case '\'':
retval.append("\\\'");
continue;
case '\\':
retval.append("\\\\");
continue;
default:
if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
String s = "0000" + Integer.toString(ch, 16);
retval.append("\\u" + s.substring(s.length() - 4, s.length()));
} else {
retval.append(ch);
}
continue;
}
}
return retval.toString();
}
}

738
src/java/org/apache/hadoop/hbase/shell/generated/Parser.java Normal file
View File

@ -0,0 +1,738 @@
/* Generated By:JavaCC: Do not edit this line. Parser.java */
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.io.StringReader;
import java.io.Reader;
import org.apache.hadoop.hbase.shell.*;
/**
* Parsing command line.
*/
public class Parser implements ParserConstants {
private static String QueryString;
public Parser(String query) {
this((Reader)(new StringReader(query)));
this.QueryString = query;
}
public String getQueryStr() {
return this.QueryString;
}
/**
* Parses the given array of command line arguments.
*/
final public Command terminatedCommand() throws ParseException {
Command statement = null;
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case HELP:
case SHOW:
case DESCRIBE:
case CREATE:
case DROP:
case EXIT:
case INSERT:
case DELETE:
case SELECT:
case 35:
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case HELP:
case SHOW:
case DESCRIBE:
case CREATE:
case DROP:
case EXIT:
case INSERT:
case DELETE:
case SELECT:
statement = cmdStatement();
break;
default:
jj_la1[0] = jj_gen;
;
}
jj_consume_token(35);
break;
case 0:
jj_consume_token(0);
break;
default:
jj_la1[1] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
{if (true) return statement;}
throw new Error("Missing return statement in function");
}
final public Command cmdStatement() throws ParseException {
Command cmd = null;
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case EXIT:
cmd = exitCommand();
break;
case HELP:
cmd = helpCommand();
break;
case SHOW:
cmd = showCommand();
break;
case DESCRIBE:
cmd = descCommand();
break;
case CREATE:
cmd = createCommand();
break;
case DROP:
cmd = dropCommand();
break;
case INSERT:
cmd = insertCommand();
break;
case DELETE:
cmd = deleteCommand();
break;
case SELECT:
cmd = selectCommand();
break;
default:
jj_la1[2] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
{if (true) return cmd;}
throw new Error("Missing return statement in function");
}
final public ExitCommand exitCommand() throws ParseException {
ExitCommand exit = new ExitCommand();
jj_consume_token(EXIT);
{if (true) return exit;}
throw new Error("Missing return statement in function");
}
final public HelpCommand helpCommand() throws ParseException {
Token t = null;
HelpCommand help = new HelpCommand();
String argument = "";
jj_consume_token(HELP);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case SHOW:
case DESCRIBE:
case CREATE:
case DROP:
case EXIT:
case INSERT:
case DELETE:
case SELECT:
case ID:
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case SHOW:
t = jj_consume_token(SHOW);
break;
case DESCRIBE:
t = jj_consume_token(DESCRIBE);
break;
case CREATE:
t = jj_consume_token(CREATE);
break;
case DROP:
t = jj_consume_token(DROP);
break;
case EXIT:
t = jj_consume_token(EXIT);
break;
case INSERT:
t = jj_consume_token(INSERT);
break;
case DELETE:
t = jj_consume_token(DELETE);
break;
case SELECT:
t = jj_consume_token(SELECT);
break;
case ID:
t = jj_consume_token(ID);
break;
default:
jj_la1[3] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
argument = t.image.toString();
break;
default:
jj_la1[4] = jj_gen;
;
}
help.setArgument(argument);
{if (true) return help;}
throw new Error("Missing return statement in function");
}
final public ShowCommand showCommand() throws ParseException {
ShowCommand show = new ShowCommand();
String argument = null;
jj_consume_token(SHOW);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case ID:
case QUOTED_STRING:
argument = getString();
break;
default:
jj_la1[5] = jj_gen;
;
}
show.setArgument(argument);
{if (true) return show;}
throw new Error("Missing return statement in function");
}
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();
break;
default:
jj_la1[6] = jj_gen;
;
}
desc.setArgument(argument);
{if (true) return desc;}
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;
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();}
}
break;
default:
jj_la1[7] = jj_gen;
;
}
{if (true) return create;}
throw new Error("Missing return statement in function");
}
final public DropCommand dropCommand() throws ParseException {
DropCommand drop = new DropCommand();
String argument = null;
jj_consume_token(DROP);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case ID:
case QUOTED_STRING:
argument = getString();
break;
default:
jj_la1[8] = jj_gen;
;
}
drop.setArgument(argument);
{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;
jj_consume_token(INSERT);
table = getString();
in.setTable(table);
columnfamilies = getLiteralValues();
in.setColumnfamilies(columnfamilies);
jj_consume_token(VALUES);
values = getLiteralValues();
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);
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();}
}
break;
default:
jj_la1[9] = 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();}
}
break;
default:
jj_la1[10] = jj_gen;
;
}
{if (true) return select;}
throw new Error("Missing return statement in function");
}
/**
* TODO : expressions codes need more love.
*/
final public String getString() throws ParseException {
Token t = null;
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case ID:
t = jj_consume_token(ID);
break;
case QUOTED_STRING:
t = jj_consume_token(QUOTED_STRING);
break;
default:
jj_la1[11] = 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());}
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_1:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case AND:
;
break;
default:
jj_la1[12] = jj_gen;
break label_1;
}
jj_consume_token(AND);
try{
result.putAll(ConditionExpression());
}catch(ParseException pe) {
exception.add(pe.toString());
result.put("error", exception);
}
}
{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);
break;
default:
jj_la1[13] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case EQUALS:
tComparator = jj_consume_token(EQUALS);
break;
case NOTEQUAL:
tComparator = jj_consume_token(NOTEQUAL);
break;
default:
jj_la1[14] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
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;}
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);
}
{if (true) return tmp;}
break;
default:
jj_la1[15] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
throw new Error("Missing return statement in function");
}
final public List<String> getLiteralValues() throws ParseException {
List<String> values = new ArrayList<String>();
String literal = null;
jj_consume_token(LPAREN);
literal = getStringLiteral();
if(literal != null) values.add(literal);
label_2:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case COMMA:
case ID:
case STRING:
case QUOTED_STRING:
case STRING_LITERAL:
;
break;
default:
jj_la1[16] = jj_gen;
break label_2;
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case COMMA:
jj_consume_token(COMMA);
literal = getStringLiteral();
if(literal != null) values.add(literal);
break;
case ID:
case STRING:
case QUOTED_STRING:
case STRING_LITERAL:
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case ID:
jj_consume_token(ID);
break;
case STRING_LITERAL:
jj_consume_token(STRING_LITERAL);
break;
case QUOTED_STRING:
jj_consume_token(QUOTED_STRING);
break;
case STRING:
jj_consume_token(STRING);
break;
default:
jj_la1[17] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
values.removeAll(values);
break;
default:
jj_la1[18] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
}
jj_consume_token(RPAREN);
{if (true) return values;}
throw new Error("Missing return statement in function");
}
final public String getStringLiteral() throws ParseException {
Token stringLiteral;
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);}
break;
case QUOTED_STRING:
jj_consume_token(QUOTED_STRING);
{if (true) return null;}
break;
default:
jj_la1[19] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
throw new Error("Missing return statement in function");
}
public ParserTokenManager token_source;
SimpleCharStream jj_input_stream;
public Token token, jj_nt;
private int jj_ntk;
private int jj_gen;
final private int[] jj_la1 = new int[20];
static private int[] jj_la1_0;
static private int[] jj_la1_1;
static {
jj_la1_0();
jj_la1_1();
}
private static void jj_la1_0() {
jj_la1_0 = new int[] {0x3fe0,0x3fe1,0x3fe0,0x40003fc0,0x40003fc0,0x40000000,0x40000000,0x100000,0x40000000,0x80000,0x100000,0x40000000,0x200000,0x4007c000,0x18000000,0x0,0x40800000,0x40000000,0x40800000,0x0,};
}
private static void jj_la1_1() {
jj_la1_1 = new int[] {0x0,0x8,0x0,0x0,0x0,0x2,0x2,0x0,0x2,0x0,0x0,0x2,0x0,0x0,0x0,0x6,0x7,0x7,0x7,0x6,};
}
public Parser(java.io.InputStream stream) {
this(stream, null);
}
public Parser(java.io.InputStream stream, String encoding) {
try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
token_source = new ParserTokenManager(jj_input_stream);
token = new Token();
jj_ntk = -1;
jj_gen = 0;
for (int i = 0; i < 20; i++) jj_la1[i] = -1;
}
public void ReInit(java.io.InputStream stream) {
ReInit(stream, null);
}
public void ReInit(java.io.InputStream stream, String encoding) {
try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
token_source.ReInit(jj_input_stream);
token = new Token();
jj_ntk = -1;
jj_gen = 0;
for (int i = 0; i < 20; i++) jj_la1[i] = -1;
}
public Parser(java.io.Reader stream) {
jj_input_stream = new SimpleCharStream(stream, 1, 1);
token_source = new ParserTokenManager(jj_input_stream);
token = new Token();
jj_ntk = -1;
jj_gen = 0;
for (int i = 0; i < 20; i++) jj_la1[i] = -1;
}
public void ReInit(java.io.Reader stream) {
jj_input_stream.ReInit(stream, 1, 1);
token_source.ReInit(jj_input_stream);
token = new Token();
jj_ntk = -1;
jj_gen = 0;
for (int i = 0; i < 20; i++) jj_la1[i] = -1;
}
public Parser(ParserTokenManager tm) {
token_source = tm;
token = new Token();
jj_ntk = -1;
jj_gen = 0;
for (int i = 0; i < 20; i++) jj_la1[i] = -1;
}
public void ReInit(ParserTokenManager tm) {
token_source = tm;
token = new Token();
jj_ntk = -1;
jj_gen = 0;
for (int i = 0; i < 20; i++) jj_la1[i] = -1;
}
final private Token jj_consume_token(int kind) throws ParseException {
Token oldToken;
if ((oldToken = token).next != null) token = token.next;
else token = token.next = token_source.getNextToken();
jj_ntk = -1;
if (token.kind == kind) {
jj_gen++;
return token;
}
token = oldToken;
jj_kind = kind;
throw generateParseException();
}
final public Token getNextToken() {
if (token.next != null) token = token.next;
else token = token.next = token_source.getNextToken();
jj_ntk = -1;
jj_gen++;
return token;
}
final public Token getToken(int index) {
Token t = token;
for (int i = 0; i < index; i++) {
if (t.next != null) t = t.next;
else t = t.next = token_source.getNextToken();
}
return t;
}
final private int jj_ntk() {
if ((jj_nt=token.next) == null)
return (jj_ntk = (token.next=token_source.getNextToken()).kind);
else
return (jj_ntk = jj_nt.kind);
}
private java.util.Vector jj_expentries = new java.util.Vector();
private int[] jj_expentry;
private int jj_kind = -1;
public ParseException generateParseException() {
jj_expentries.removeAllElements();
boolean[] la1tokens = new boolean[36];
for (int i = 0; i < 36; i++) {
la1tokens[i] = false;
}
if (jj_kind >= 0) {
la1tokens[jj_kind] = true;
jj_kind = -1;
}
for (int i = 0; i < 20; i++) {
if (jj_la1[i] == jj_gen) {
for (int j = 0; j < 32; j++) {
if ((jj_la1_0[i] & (1<<j)) != 0) {
la1tokens[j] = true;
}
if ((jj_la1_1[i] & (1<<j)) != 0) {
la1tokens[32+j] = true;
}
}
}
}
for (int i = 0; i < 36; i++) {
if (la1tokens[i]) {
jj_expentry = new int[1];
jj_expentry[0] = i;
jj_expentries.addElement(jj_expentry);
}
}
int[][] exptokseq = new int[jj_expentries.size()][];
for (int i = 0; i < jj_expentries.size(); i++) {
exptokseq[i] = (int[])jj_expentries.elementAt(i);
}
return new ParseException(token, exptokseq, tokenImage);
}
final public void enable_tracing() {
}
final public void disable_tracing() {
}
}

94
src/java/org/apache/hadoop/hbase/shell/generated/ParserConstants.java Normal file
View File

@ -0,0 +1,94 @@
/* Generated By:JavaCC: Do not edit this line. ParserConstants.java */
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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 SHOW = 6;
int DESCRIBE = 7;
int CREATE = 8;
int DROP = 9;
int EXIT = 10;
int INSERT = 11;
int DELETE = 12;
int SELECT = 13;
int ROW = 14;
int COLUMN = 15;
int TIME = 16;
int VALUES = 17;
int COLUMNFAMILIES = 18;
int WHERE = 19;
int LIMIT = 20;
int AND = 21;
int OR = 22;
int COMMA = 23;
int DOT = 24;
int LPAREN = 25;
int RPAREN = 26;
int EQUALS = 27;
int NOTEQUAL = 28;
int OPTIONS = 29;
int ID = 30;
int NUM = 31;
int STRING = 32;
int QUOTED_STRING = 33;
int STRING_LITERAL = 34;
int DEFAULT = 0;
String[] tokenImage = {
"<EOF>",
"\" \"",
"\"\\t\"",
"\"\\r\"",
"\"\\n\"",
"\"help\"",
"\"show\"",
"\"describe\"",
"\"create\"",
"\"drop\"",
"\"exit\"",
"\"insert\"",
"\"delete\"",
"\"select\"",
"\"row\"",
"\"column\"",
"\"time\"",
"\"values\"",
"\"columnfamilies\"",
"\"where\"",
"\"limit\"",
"\"and\"",
"\"or\"",
"\",\"",
"\".\"",
"\"(\"",
"\")\"",
"\"=\"",
"\"<>\"",
"\"-\"",
"<ID>",
"<NUM>",
"<STRING>",
"<QUOTED_STRING>",
"<STRING_LITERAL>",
"\";\"",
};
}

1015
src/java/org/apache/hadoop/hbase/shell/generated/ParserTokenManager.java Normal file
View File

File diff suppressed because it is too large Load Diff

454
src/java/org/apache/hadoop/hbase/shell/generated/SimpleCharStream.java Normal file
View File

@ -0,0 +1,454 @@
/* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 4.0 */
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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;
/**
* An implementation of interface CharStream, where the stream is assumed to
* contain only ASCII characters (without unicode processing).
*/
public class SimpleCharStream
{
public static final boolean staticFlag = false;
int bufsize;
int available;
int tokenBegin;
public int bufpos = -1;
protected int bufline[];
protected int bufcolumn[];
protected int column = 0;
protected int line = 1;
protected boolean prevCharIsCR = false;
protected boolean prevCharIsLF = false;
protected java.io.Reader inputStream;
protected char[] buffer;
protected int maxNextCharInd = 0;
protected int inBuf = 0;
protected int tabSize = 8;
protected void setTabSize(int i) { tabSize = i; }
protected int getTabSize(int i) { return tabSize; }
protected void ExpandBuff(boolean wrapAround)
{
char[] newbuffer = new char[bufsize + 2048];
int newbufline[] = new int[bufsize + 2048];
int newbufcolumn[] = new int[bufsize + 2048];
try
{
if (wrapAround)
{
System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
System.arraycopy(buffer, 0, newbuffer,
bufsize - tokenBegin, bufpos);
buffer = newbuffer;
System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
bufline = newbufline;
System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
bufcolumn = newbufcolumn;
maxNextCharInd = (bufpos += (bufsize - tokenBegin));
}
else
{
System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
buffer = newbuffer;
System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
bufline = newbufline;
System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
bufcolumn = newbufcolumn;
maxNextCharInd = (bufpos -= tokenBegin);
}
}
catch (Throwable t)
{
throw new Error(t.getMessage());
}
bufsize += 2048;
available = bufsize;
tokenBegin = 0;
}
protected void FillBuff() throws java.io.IOException
{
if (maxNextCharInd == available)
{
if (available == bufsize)
{
if (tokenBegin > 2048)
{
bufpos = maxNextCharInd = 0;
available = tokenBegin;
}
else if (tokenBegin < 0)
bufpos = maxNextCharInd = 0;
else
ExpandBuff(false);
}
else if (available > tokenBegin)
available = bufsize;
else if ((tokenBegin - available) < 2048)
ExpandBuff(true);
else
available = tokenBegin;
}
int i;
try {
if ((i = inputStream.read(buffer, maxNextCharInd,
available - maxNextCharInd)) == -1)
{
inputStream.close();
throw new java.io.IOException();
}
else
maxNextCharInd += i;
return;
}
catch(java.io.IOException e) {
--bufpos;
backup(0);
if (tokenBegin == -1)
tokenBegin = bufpos;
throw e;
}
}
public char BeginToken() throws java.io.IOException
{
tokenBegin = -1;
char c = readChar();
tokenBegin = bufpos;
return c;
}
protected void UpdateLineColumn(char c)
{
column++;
if (prevCharIsLF)
{
prevCharIsLF = false;
line += (column = 1);
}
else if (prevCharIsCR)
{
prevCharIsCR = false;
if (c == '\n')
{
prevCharIsLF = true;
}
else
line += (column = 1);
}
switch (c)
{
case '\r' :
prevCharIsCR = true;
break;
case '\n' :
prevCharIsLF = true;
break;
case '\t' :
column--;
column += (tabSize - (column % tabSize));
break;
default :
break;
}
bufline[bufpos] = line;
bufcolumn[bufpos] = column;
}
public char readChar() throws java.io.IOException
{
if (inBuf > 0)
{
--inBuf;
if (++bufpos == bufsize)
bufpos = 0;
return buffer[bufpos];
}
if (++bufpos >= maxNextCharInd)
FillBuff();
char c = buffer[bufpos];
UpdateLineColumn(c);
return (c);
}
/**
* @deprecated
* @see #getEndColumn
*/
public int getColumn() {
return bufcolumn[bufpos];
}
/**
* @deprecated
* @see #getEndLine
*/
public int getLine() {
return bufline[bufpos];
}
public int getEndColumn() {
return bufcolumn[bufpos];
}
public int getEndLine() {
return bufline[bufpos];
}
public int getBeginColumn() {
return bufcolumn[tokenBegin];
}
public int getBeginLine() {
return bufline[tokenBegin];
}
public void backup(int amount) {
inBuf += amount;
if ((bufpos -= amount) < 0)
bufpos += bufsize;
}
public SimpleCharStream(java.io.Reader dstream, int startline,
int startcolumn, int buffersize)
{
inputStream = dstream;
line = startline;
column = startcolumn - 1;
available = bufsize = buffersize;
buffer = new char[buffersize];
bufline = new int[buffersize];
bufcolumn = new int[buffersize];
}
public SimpleCharStream(java.io.Reader dstream, int startline,
int startcolumn)
{
this(dstream, startline, startcolumn, 4096);
}
public SimpleCharStream(java.io.Reader dstream)
{
this(dstream, 1, 1, 4096);
}
public void ReInit(java.io.Reader dstream, int startline,
int startcolumn, int buffersize)
{
inputStream = dstream;
line = startline;
column = startcolumn - 1;
if (buffer == null || buffersize != buffer.length)
{
available = bufsize = buffersize;
buffer = new char[buffersize];
bufline = new int[buffersize];
bufcolumn = new int[buffersize];
}
prevCharIsLF = prevCharIsCR = false;
tokenBegin = inBuf = maxNextCharInd = 0;
bufpos = -1;
}
public void ReInit(java.io.Reader dstream, int startline,
int startcolumn)
{
ReInit(dstream, startline, startcolumn, 4096);
}
public void ReInit(java.io.Reader dstream)
{
ReInit(dstream, 1, 1, 4096);
}
public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,
int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
{
this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
}
public SimpleCharStream(java.io.InputStream dstream, int startline,
int startcolumn, int buffersize)
{
this(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
}
public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,
int startcolumn) throws java.io.UnsupportedEncodingException
{
this(dstream, encoding, startline, startcolumn, 4096);
}
public SimpleCharStream(java.io.InputStream dstream, int startline,
int startcolumn)
{
this(dstream, startline, startcolumn, 4096);
}
public SimpleCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
{
this(dstream, encoding, 1, 1, 4096);
}
public SimpleCharStream(java.io.InputStream dstream)
{
this(dstream, 1, 1, 4096);
}
public void ReInit(java.io.InputStream dstream, String encoding, int startline,
int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
{
ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
}
public void ReInit(java.io.InputStream dstream, int startline,
int startcolumn, int buffersize)
{
ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
}
public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
{
ReInit(dstream, encoding, 1, 1, 4096);
}
public void ReInit(java.io.InputStream dstream)
{
ReInit(dstream, 1, 1, 4096);
}
public void ReInit(java.io.InputStream dstream, String encoding, int startline,
int startcolumn) throws java.io.UnsupportedEncodingException
{
ReInit(dstream, encoding, startline, startcolumn, 4096);
}
public void ReInit(java.io.InputStream dstream, int startline,
int startcolumn)
{
ReInit(dstream, startline, startcolumn, 4096);
}
public String GetImage()
{
if (bufpos >= tokenBegin)
return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
else
return new String(buffer, tokenBegin, bufsize - tokenBegin) +
new String(buffer, 0, bufpos + 1);
}
public char[] GetSuffix(int len)
{
char[] ret = new char[len];
if ((bufpos + 1) >= len)
System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
else
{
System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
len - bufpos - 1);
System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
}
return ret;
}
public void Done()
{
buffer = null;
bufline = null;
bufcolumn = null;
}
/**
* Method to adjust line and column numbers for the start of a token.
*/
public void adjustBeginLineColumn(int newLine, int newCol)
{
int start = tokenBegin;
int len;
if (bufpos >= tokenBegin)
{
len = bufpos - tokenBegin + inBuf + 1;
}
else
{
len = bufsize - tokenBegin + bufpos + 1 + inBuf;
}
int i = 0, j = 0, k = 0;
int nextColDiff = 0, columnDiff = 0;
while (i < len &&
bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
{
bufline[j] = newLine;
nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
bufcolumn[j] = newCol + columnDiff;
columnDiff = nextColDiff;
i++;
}
if (i < len)
{
bufline[j] = newLine++;
bufcolumn[j] = newCol + columnDiff;
while (i++ < len)
{
if (bufline[j = start % bufsize] != bufline[++start % bufsize])
bufline[j] = newLine++;
else
bufline[j] = newLine;
}
}
line = bufline[j];
column = bufcolumn[j];
}
}

96
src/java/org/apache/hadoop/hbase/shell/generated/Token.java Normal file
View File

@ -0,0 +1,96 @@
/* Generated By:JavaCC: Do not edit this line. Token.java Version 3.0 */
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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;
/**
* Describes the input token stream.
*/
public class Token {
/**
* An integer that describes the kind of this token. This numbering
* system is determined by JavaCCParser, and a table of these numbers is
* stored in the file ...Constants.java.
*/
public int kind;
/**
* beginLine and beginColumn describe the position of the first character
* of this token; endLine and endColumn describe the position of the
* last character of this token.
*/
public int beginLine, beginColumn, endLine, endColumn;
/**
* The string image of the token.
*/
public String image;
/**
* A reference to the next regular (non-special) token from the input
* stream. If this is the last token from the input stream, or if the
* token manager has not read tokens beyond this one, this field is
* set to null. This is true only if this token is also a regular
* token. Otherwise, see below for a description of the contents of
* this field.
*/
public Token next;
/**
* This field is used to access special tokens that occur prior to this
* token, but after the immediately preceding regular (non-special) token.
* If there are no such special tokens, this field is set to null.
* When there are more than one such special token, this field refers
* to the last of these special tokens, which in turn refers to the next
* previous special token through its specialToken field, and so on
* until the first special token (whose specialToken field is null).
* The next fields of special tokens refer to other special tokens that
* immediately follow it (without an intervening regular token). If there
* is no such token, this field is null.
*/
public Token specialToken;
/**
* Returns the image.
*/
public String toString()
{
return image;
}
/**
* Returns a new Token object, by default. However, if you want, you
* can create and return subclass objects based on the value of ofKind.
* Simply add the cases to the switch for all those special cases.
* For example, if you have a subclass of Token called IDToken that
* you want to create if ofKind is ID, simlpy add something like :
*
* case MyParserConstants.ID : return new IDToken();
*
* to the following switch statement. Then you can cast matchedToken
* variable to the appropriate type and use it in your lexical actions.
*/
public static final Token newToken(int ofKind)
{
switch(ofKind)
{
default : return new Token();
}
}
}

148
src/java/org/apache/hadoop/hbase/shell/generated/TokenMgrError.java Normal file
View File

@ -0,0 +1,148 @@
/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 3.0 */
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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 class TokenMgrError extends Error
{
/*
* Ordinals for various reasons why an Error of this type can be thrown.
*/
/**
* Lexical error occured.
*/
static final int LEXICAL_ERROR = 0;
/**
* An attempt wass made to create a second instance of a static token manager.
*/
static final int STATIC_LEXER_ERROR = 1;
/**
* Tried to change to an invalid lexical state.
*/
static final int INVALID_LEXICAL_STATE = 2;
/**
* Detected (and bailed out of) an infinite loop in the token manager.
*/
static final int LOOP_DETECTED = 3;
/**
* Indicates the reason why the exception is thrown. It will have
* one of the above 4 values.
*/
int errorCode;
/**
* Replaces unprintable characters by their espaced (or unicode escaped)
* equivalents in the given string
*/
protected static final String addEscapes(String str) {
StringBuffer retval = new StringBuffer();
char ch;
for (int i = 0; i < str.length(); i++) {
switch (str.charAt(i))
{
case 0 :
continue;
case '\b':
retval.append("\\b");
continue;
case '\t':
retval.append("\\t");
continue;
case '\n':
retval.append("\\n");
continue;
case '\f':
retval.append("\\f");
continue;
case '\r':
retval.append("\\r");
continue;
case '\"':
retval.append("\\\"");
continue;
case '\'':
retval.append("\\\'");
continue;
case '\\':
retval.append("\\\\");
continue;
default:
if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
String s = "0000" + Integer.toString(ch, 16);
retval.append("\\u" + s.substring(s.length() - 4, s.length()));
} else {
retval.append(ch);
}
continue;
}
}
return retval.toString();
}
/**
* Returns a detailed message for the Error when it is thrown by the
* token manager to indicate a lexical error.
* Parameters :
* EOFSeen : indicates if EOF caused the lexicl error
* curLexState : lexical state in which this error occured
* errorLine : line number when the error occured
* errorColumn : column number when the error occured
* errorAfter : prefix that was seen before this error occured
* curchar : the offending character
* Note: You can customize the lexical error message by modifying this method.
*/
protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) {
return("Lexical error at line " +
errorLine + ", column " +
errorColumn + ". Encountered: " +
(EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") +
"after : \"" + addEscapes(errorAfter) + "\"");
}
/**
* You can also modify the body of this method to customize your error messages.
* For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not
* of end-users concern, so you can return something like :
*
* "Internal Error : Please file a bug report .... "
*
* from this method for such cases in the release version of your parser.
*/
public String getMessage() {
return super.getMessage();
}
/*
* Constructors of various flavors follow.
*/
public TokenMgrError() {
}
public TokenMgrError(String message, int reason) {
super(message);
errorCode = reason;
}
public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) {
this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason);
}
}

33
src/test/org/apache/hadoop/hbase/shell/TestHBaseShell.java Normal file
View File

@ -0,0 +1,33 @@
/**
* Copyright 2007 The Apache Software Foundation
*
* Licensed 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 junit.framework.TestCase;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HClient;
import org.apache.hadoop.hbase.shell.generated.ParseException;
import org.apache.hadoop.hbase.shell.generated.Parser;
public class TestHBaseShell extends TestCase {
public void testParse() {
String queryString1 = "SELECT test_table WHERE row='row_key' and " +
"column='column_key';";
new Parser(queryString1);
}
}