diff --git a/.classpath b/.classpath deleted file mode 100644 index be515aac..00000000 --- a/.classpath +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - - - - - diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..4ca48ca5 --- /dev/null +++ b/.gitignore @@ -0,0 +1,12 @@ +#general java +*.class +*.war +*.jar + +# eclipse stuffs +.settings/* +.classpath +.project + +#maven stuffs +target/ diff --git a/.project b/.project deleted file mode 100644 index 543d11df..00000000 --- a/.project +++ /dev/null @@ -1,18 +0,0 @@ - - - phoenix - - - hbase - - - - org.eclipse.jdt.core.javabuilder - - - - - - org.eclipse.jdt.core.javanature - - diff --git a/README.md b/README.md index 25bfecf8..81b0985c 100644 --- a/README.md +++ b/README.md @@ -36,10 +36,10 @@ To install a pre-built phoenix, use these directions * [phoenix.jar](http://forcedotcom.github.com/Phoenix/lib/phoenix.jar) * [phoenix-client.jar](http://forcedotcom.github.com/Phoenix/lib/phoenix-client.jar) * Add the phoenix.jar to the classpath of every HBase region server. An easy way to do this is to copy it into the HBase lib directory. +* Restart all region servers. * Add the phoenix-client.jar to the classpath of any Phoenix client. This jar includes the minimum set of required HBase jars, along with the following required phoenix jars * phoenix.jar * antlr-3.2.jar - * opencsv-2.3.jar Alternatively, you can build it yourself by following these [build instructions](https://github.com/forcedotcom/Phoenix/wiki#building). @@ -51,7 +51,7 @@ One way to experiment with Phoenix is to download and install a SQL client such 3. In Add Driver dialog box, set Name to Phoenix 4. Press List Drivers button and jdbc.PhoenixProdEmbeddedDriver should be automatically populated in Class Name textbox. Press OK to close this dialog. 5. Switch to Alias tab and create new Alias (Aliases -> New Aliases) -6. In the dialog box, Name: , Driver: Phoenix, User Name: , Password: +6. In the dialog box, Name: , Driver: Phoenix, User Name: _anything_, Password: _anything_ 7. Construct URL as follows: jdbc:phoenix:. For example, to connect to a local HBase use: jdbc:phoenix:localhost 8. Press Test (which should succeed if everything is setup correctly) and press OK to close. 9. Now double click on your newly created Phoenix alias and click Connect. Now you are ready to run SQL queries against Phoenix. @@ -67,5 +67,7 @@ In addition, several basic shell scripts are provided to allow for direct SQL ex The best place to see samples are in our unit tests under test/func/java. These are end-to-end tests demonstrating how to use all aspects of the Phoenix JDBC driver. ##Mailing List## -Join our [Phoenix HBase](https://groups.google.com/forum/#!forum/phoenix-hbase) Google group and let us know if you have ideas or run into problems. +Join one or both of our Google groups: +* [Phoenix HBase User](https://groups.google.com/forum/#!forum/phoenix-hbase-user) for users of Phoenix. +* [Phoenix HBase Dev](https://groups.google.com/forum/#!forum/phoenix-hbase-dev) for developers of Phoenix. diff --git a/build.txt b/build.txt new file mode 100644 index 00000000..3d19bc7e --- /dev/null +++ b/build.txt @@ -0,0 +1,29 @@ +# Building Phoenix +================ + +Phoenix uses Maven (3.X) to build all its necessary resources. + +## Building from source +======================= + +1. To re-generate the antrl based files: + $ mvn generate-sources + +2. To build the jars + $ mvn package +and optionally, to just skip all the tests and build the jars: + $ mvn package -DskipTests + +3. + +## Importing into eclipse +========================= + +Use the m2e eclipse plugin and do Import->Maven Project and just pick the root 'phoenix' directory. + +## Running the tests +==================== + +1. All tests + $ mvn clean test + diff --git a/build/default.properties b/build/default.properties index 7829909b..4012aed2 100644 --- a/build/default.properties +++ b/build/default.properties @@ -32,25 +32,23 @@ # production needs alternate values. # -# Phoenix install location. Example /tmp/phoenix -devhome.dir = SPECIFY_YOUR_PHOENIX_SOURCE_ROOT_LOCATION_HERE +# Match following with your ANT install location. +# You can set ANT_HOME location here by uncommenting the following line or +# setting environment variable. Example: export ANT_HOME=/home/user/apache-ant-1.8.0 +# ANT_HOME = SPECIFY_YOUR_ANT_HOME_LOCATION_HERE -# Match following with your ANT install location -ANT_HOME = /YOUR_ANT_LOCATION_HERE/apache-ant-1.8.0 - -# Location of your m2_repo excluding your home folder +# Location of your m2_repo excluding your home folder path M2_REPO = .m2/repository -# The java implementation to use. Java 1.6 required. -# JAVA_HOME=/usr/java/jdk1.6.0/ +# The java implementation to use. Java 1.6 or higher required. +# You can set JAVA_HOME location here by uncommenting the following line or +# setting environment variable. Example: export JAVA_HOME=/usr/java/jdk1.6.0/ +# JAVA_HOME = SPECIFY_YOUR_JAVA_HOME_LOCATION_HERE # HBase specific variables. You should not need to modify the following. hbase-revision = 1395367 hbase.version = hbase-0.94.2 hbase.url = http://svn.apache.org/repos/asf/hbase/branches/0.94 -hbase.root = ${devhome.dir}/../hbase -hbase.home = ${hbase.root}/target/${hbase.version}/${hbase.version} -hbase.lib = ${hbase.home}/lib ANT_GC_ARGS = -Xmx2048m diff --git a/java/src/phoenix/compile/DeleteCompiler.java b/java/src/phoenix/compile/DeleteCompiler.java index 5d7b6906..eb889960 100644 --- a/java/src/phoenix/compile/DeleteCompiler.java +++ b/java/src/phoenix/compile/DeleteCompiler.java @@ -44,7 +44,10 @@ import phoenix.iterate.ResultIterator; import phoenix.jdbc.PhoenixConnection; import phoenix.parse.*; -import phoenix.query.*; +import phoenix.query.ConnectionQueryServices; +import phoenix.query.QueryConstants; +import phoenix.query.QueryServices; +import phoenix.query.QueryServicesOptions; import phoenix.query.Scanner; import phoenix.schema.*; import phoenix.schema.tuple.Tuple; diff --git a/java/src/phoenix/compile/UpsertCompiler.java b/java/src/phoenix/compile/UpsertCompiler.java index 5d1cd4a7..306ca5d4 100644 --- a/java/src/phoenix/compile/UpsertCompiler.java +++ b/java/src/phoenix/compile/UpsertCompiler.java @@ -44,7 +44,9 @@ import phoenix.iterate.ResultIterator; import phoenix.jdbc.*; import phoenix.parse.*; -import phoenix.query.*; +import phoenix.query.ConnectionQueryServices; +import phoenix.query.QueryServices; +import phoenix.query.QueryServicesOptions; import phoenix.query.Scanner; import phoenix.schema.*; import phoenix.schema.tuple.Tuple; diff --git a/java/src/phoenix/execute/AggregatePlan.java b/java/src/phoenix/execute/AggregatePlan.java index fcda6822..dea64533 100644 --- a/java/src/phoenix/execute/AggregatePlan.java +++ b/java/src/phoenix/execute/AggregatePlan.java @@ -36,7 +36,9 @@ import phoenix.expression.Expression; import phoenix.expression.aggregator.Aggregators; import phoenix.iterate.*; -import phoenix.query.*; +import phoenix.query.ConnectionQueryServices; +import phoenix.query.Scanner; +import phoenix.query.WrappedScanner; import phoenix.schema.TableRef; diff --git a/java/src/phoenix/execute/BasicQueryPlan.java b/java/src/phoenix/execute/BasicQueryPlan.java index ba8bbb1a..947871ed 100644 --- a/java/src/phoenix/execute/BasicQueryPlan.java +++ b/java/src/phoenix/execute/BasicQueryPlan.java @@ -36,7 +36,9 @@ import phoenix.compile.*; import phoenix.compile.OrderByCompiler.OrderBy; import phoenix.jdbc.PhoenixConnection; -import phoenix.query.*; +import phoenix.query.ConnectionQueryServices; +import phoenix.query.DegenerateScanner; +import phoenix.query.Scanner; import phoenix.schema.TableRef; import phoenix.util.ScanUtil; diff --git a/java/src/phoenix/execute/ScanPlan.java b/java/src/phoenix/execute/ScanPlan.java index eb1f53cf..b3437d79 100644 --- a/java/src/phoenix/execute/ScanPlan.java +++ b/java/src/phoenix/execute/ScanPlan.java @@ -34,7 +34,10 @@ import phoenix.compile.*; import phoenix.coprocessor.ScanRegionObserver; import phoenix.iterate.*; -import phoenix.query.*; +import phoenix.query.ConnectionQueryServices; +import phoenix.query.QueryConstants; +import phoenix.query.Scanner; +import phoenix.query.WrappedScanner; import phoenix.schema.TableRef; diff --git a/java/src/phoenix/iterate/ParallelIterators.java b/java/src/phoenix/iterate/ParallelIterators.java index 7bdceb64..79145631 100644 --- a/java/src/phoenix/iterate/ParallelIterators.java +++ b/java/src/phoenix/iterate/ParallelIterators.java @@ -43,7 +43,10 @@ import phoenix.execute.RowCounter; import phoenix.job.JobManager.JobCallable; import phoenix.memory.MemoryManager; -import phoenix.query.*; +import phoenix.query.ConnectionQueryServices; +import phoenix.query.KeyRange; +import phoenix.query.QueryServices; +import phoenix.query.QueryServicesOptions; import phoenix.schema.TableRef; import phoenix.util.SQLCloseables; import phoenix.util.ScanUtil; diff --git a/java/src/phoenix/jdbc/PhoenixConnection.java b/java/src/phoenix/jdbc/PhoenixConnection.java index db37867d..8a219f72 100644 --- a/java/src/phoenix/jdbc/PhoenixConnection.java +++ b/java/src/phoenix/jdbc/PhoenixConnection.java @@ -35,7 +35,11 @@ import phoenix.execute.MutationState; import phoenix.jdbc.PhoenixStatement.PhoenixStatementParser; -import phoenix.query.*; +import phoenix.query.ConnectionQueryServices; +import phoenix.query.MetaDataMutated; +import phoenix.query.QueryConstants; +import phoenix.query.QueryServices; +import phoenix.query.QueryServicesOptions; import phoenix.schema.*; import phoenix.util.*; diff --git a/java/src/phoenix/jdbc/PhoenixDatabaseMetaData.java b/java/src/phoenix/jdbc/PhoenixDatabaseMetaData.java index 9f9d0487..43a0cf83 100644 --- a/java/src/phoenix/jdbc/PhoenixDatabaseMetaData.java +++ b/java/src/phoenix/jdbc/PhoenixDatabaseMetaData.java @@ -39,8 +39,10 @@ import phoenix.expression.RowKeyColumnExpression; import phoenix.expression.function.SqlTypeNameFunction; import phoenix.iterate.*; -import phoenix.query.*; +import phoenix.query.DelegateScanner; +import phoenix.query.QueryConstants; import phoenix.query.Scanner; +import phoenix.query.WrappedScanner; import phoenix.schema.*; import phoenix.schema.tuple.SingleKeyValueTuple; import phoenix.schema.tuple.Tuple; diff --git a/java/src/phoenix/jdbc/PhoenixEmbeddedDriver.java b/java/src/phoenix/jdbc/PhoenixEmbeddedDriver.java index d6a25958..6e4fdf5d 100644 --- a/java/src/phoenix/jdbc/PhoenixEmbeddedDriver.java +++ b/java/src/phoenix/jdbc/PhoenixEmbeddedDriver.java @@ -31,7 +31,8 @@ import java.util.Properties; import java.util.logging.Logger; -import phoenix.query.*; +import phoenix.query.ConnectionQueryServices; +import phoenix.query.QueryServices; import phoenix.util.PhoenixRuntime; import phoenix.util.SQLCloseable; diff --git a/java/src/phoenix/jdbc/PhoenixProdEmbeddedDriver.java b/java/src/phoenix/jdbc/PhoenixProdEmbeddedDriver.java index 5c7670c5..5464a92f 100644 --- a/java/src/phoenix/jdbc/PhoenixProdEmbeddedDriver.java +++ b/java/src/phoenix/jdbc/PhoenixProdEmbeddedDriver.java @@ -38,7 +38,10 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseConfiguration; -import phoenix.query.*; +import phoenix.query.ConnectionQueryServices; +import phoenix.query.ConnectionQueryServicesImpl; +import phoenix.query.ConnectionlessQueryServicesImpl; +import phoenix.query.QueryServicesImpl; import phoenix.util.SQLCloseables; /** diff --git a/java/src/phoenix/jdbc/PhoenixStatement.java b/java/src/phoenix/jdbc/PhoenixStatement.java index 8b52f886..c3925875 100644 --- a/java/src/phoenix/jdbc/PhoenixStatement.java +++ b/java/src/phoenix/jdbc/PhoenixStatement.java @@ -39,8 +39,10 @@ import phoenix.expression.RowKeyColumnExpression; import phoenix.iterate.MaterializedResultIterator; import phoenix.parse.*; -import phoenix.query.*; +import phoenix.query.QueryConstants; +import phoenix.query.QueryServices; import phoenix.query.Scanner; +import phoenix.query.WrappedScanner; import phoenix.schema.*; import phoenix.schema.tuple.SingleKeyValueTuple; import phoenix.schema.tuple.Tuple; diff --git a/java/src/phoenix/join/HashCacheClient.java b/java/src/phoenix/join/HashCacheClient.java index 590d5b6c..52c287eb 100644 --- a/java/src/phoenix/join/HashCacheClient.java +++ b/java/src/phoenix/join/HashCacheClient.java @@ -46,7 +46,8 @@ import phoenix.iterate.ResultIterator; import phoenix.job.JobManager.JobCallable; import phoenix.memory.MemoryManager.MemoryChunk; -import phoenix.query.*; +import phoenix.query.ConnectionQueryServices; +import phoenix.query.QueryServices; import phoenix.query.Scanner; import phoenix.schema.tuple.Tuple; import phoenix.util.*; diff --git a/java/src/phoenix/query/StatsManagerImpl.java b/java/src/phoenix/query/StatsManagerImpl.java index 02c63e78..f1cfa536 100644 --- a/java/src/phoenix/query/StatsManagerImpl.java +++ b/java/src/phoenix/query/StatsManagerImpl.java @@ -67,14 +67,14 @@ public StatsManagerImpl(ConnectionQueryServices services, int statsUpdateFrequen this(services, statsUpdateFrequencyMs, maxStatsAgeMs, TimeKeeper.SYSTEM); } - StatsManagerImpl(ConnectionQueryServices services, int statsUpdateFrequencyMs, int maxStatsAgeMs, TimeKeeper timeKeeper) { + public StatsManagerImpl(ConnectionQueryServices services, int statsUpdateFrequencyMs, int maxStatsAgeMs, TimeKeeper timeKeeper) { this.services = services; this.statsUpdateFrequencyMs = statsUpdateFrequencyMs; this.maxStatsAgeMs = maxStatsAgeMs; this.timeKeeper = timeKeeper; } - static interface TimeKeeper { + public static interface TimeKeeper { static final TimeKeeper SYSTEM = new TimeKeeper() { @Override public long currentTimeMillis() { diff --git a/pom.xml b/pom.xml new file mode 100644 index 00000000..c722ed9b --- /dev/null +++ b/pom.xml @@ -0,0 +1,379 @@ + + 4.0.0 + com.salesforce + phoenix + 0.0.1-SNAPSHOT + Phoenix + Phoenix JDBC driver for HBase + + + + codehaus + Codehaus Public + http://repository.codehaus.org/ + + false + + + true + + + + apache release + https://repository.apache.org/content/repositories/releases/ + + + apache non-releases + Apache non-releases + http://people.apache.org/~stack/m2/repository + + false + + + true + + + + + + + src/main/antlr + target/generated-sources/antlr + ${antlr-output.dir}/phoenix/parse + + + 0.94.2 + 1.2 + 1.0.4 + 4.10 + 1.8.8 + 3.2 + 2.3 + 1.2.16 + 1.4.3.jar + 1.4.3 + 2.4.0a + 1.6 + 2.1 + 2.5 + 1.1.1 + + + 1.0 + 2.8 + 1.6 + 1.7 + + + + + java/src + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.0 + + 1.6 + 1.6 + + + + + org.eclipse.m2e + lifecycle-mapping + 1.0.0 + + + + + + + org.apache.maven.plugins + maven-antrun-plugin + [1.6,) + + run + + + + + + + + + + + + + + + + + + maven-antrun-plugin + 1.6 + + + generateParser + generate-sources + + run + + + + + + + + + + + + + + org.codehaus.mojo + build-helper-maven-plugin + ${maven-build-helper-plugin.version} + + + add-generated-sources + process-resources + + add-source + + + + ${antlr-output.dir} + src/main/antlr + + + + + + + + org.apache.maven.plugins + maven-jar-plugin + 2.4 + + + prepare-package + + + test-jar + + + + + + + org/apache/jute/** + org/apache/zookeeper/** + **/*.jsp + log4j.properties + + + + + org.apache.maven.plugins + maven-source-plugin + 2.2.1 + + + attach-sources + prepare-package + + jar-no-fork + + + + + + + org.apache.maven.plugins + maven-eclipse-plugin + ${maven-eclipse-plugin.version} + + + org.jamon.project.templateBuilder + org.eclipse.jdt.core.javabuilder + + + + + + maven-assembly-plugin + + + client + package + + single + + + + true + + true + phoenix.util.PhoenixRuntime + true + true + + + + src/build/client.xml + + + + + + package-to-tar + package + + single + + + false + gnu + false + + src/build/all.xml + + + + + + + + + + + + org.antlr + antlr + ${antlr.version} + + + org.antlr + antlr-runtime + ${antlr.version} + + + org.antlr + stringtemplate + ${antlr.version} + + + net.sf.opencsv + opencsv + ${opencsv.version} + + + org.apache.hadoop + hadoop-core + ${hadoop.version} + true + + + hsqldb + hsqldb + + + net.sf.kosmosfs + kfs + + + org.eclipse.jdt + core + + + net.java.dev.jets3t + jets3t + + + oro + oro + + + + + org.apache.hbase + hbase + ${hbase.version} + + + + + org.apache.hbase + hbase + ${hbase.version} + test-jar + test + + + + org.codehaus.jackson + jackson-core-asl + ${jackson.version} + test + + + org.codehaus.jackson + jackson-mapper-asl + ${jackson.version} + test + + + org.codehaus.jackson + jackson-jaxrs + ${jackson.version} + test + + + org.codehaus.jackson + jackson-xc + ${jackson.version} + test + + + org.apache.hadoop + hadoop-test + ${hadoop.version} + true + test + + + junit + junit + ${junit.version} + test + + + + + + + org.codehaus.mojo + antlr-maven-plugin + 2.2 + + + *.g + + + + + + diff --git a/src/build/all.xml b/src/build/all.xml new file mode 100644 index 00000000..c4452a5f --- /dev/null +++ b/src/build/all.xml @@ -0,0 +1,118 @@ + + + all + + tar.gz + + true + + + + pom.xml + / + 0644 + + + + + + + ${project.basedir} + / + + *.txt + *.md + + + + + target + / + + ${project.build.finalName}.jar + ${project.build.finalName}-tests.jar + ${project.build.finalName}-client.jar + ${project.build.finalName}-sources.jar + + 0644 + 0755 + + + + java + 0644 + 0755 + + + src + 0644 + 0755 + + + docs + 0644 + 0755 + + + conf + 0644 + 0755 + + + conf + 0644 + 0755 + + + examples + 0644 + 0755 + + + bin + 0755 + 0755 + + + + + + + + false + /lib + + commons-configuration:commons-configuration + commons-io:commons-io + commons-lang:commons-lang + commons-logging:commons-logging + com.google.guava:guava + org.apache.hadoop:hadoop-core + + com.google.protobuf:protobuf-java + org.slf4j:slf4j-api + org.slf4j:slf4j-log4j12 + org.apache.zookeeper:zookeeper + log4j:log4j + org.apache.hbase:hbase* + net.sf.opencsv:opencsv + org.antlr:antlr + + + + + false + test + + /lib + + org.codehaus.jackson:jackson-core-asl + org.codehaus.jackson:jackson-mapper-asl + + + + \ No newline at end of file diff --git a/src/build/build.xml b/src/build/build.xml new file mode 100644 index 00000000..c25026ea --- /dev/null +++ b/src/build/build.xml @@ -0,0 +1,38 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/build/client.xml b/src/build/client.xml new file mode 100644 index 00000000..3e4b1815 --- /dev/null +++ b/src/build/client.xml @@ -0,0 +1,74 @@ + + client + + jar + + false + + + + true + + / + + + commons-configuration:commons-configuration + commons-io:commons-io + commons-lang:commons-lang + commons-logging:commons-logging + com.google.guava:guava + org.apache.hadoop:hadoop-core + com.google.protobuf:protobuf-java + org.slf4j:slf4j-api + org.slf4j:slf4j-log4j12 + org.apache.zookeeper:zookeeper + log4j:log4j + org.apache.hbase:hbase* + net.sf.opencsv:opencsv + org.antlr:antlr + + + + + + test + / + + org.codehaus.jackson:jackson-core-asl + org.codehaus.jackson:jackson-mapper-asl + + + + + + + + ${project.build.directory}/classes/phoenix + /phoenix + 0755 + 0755 + + + + src/main/resources + conf + + + + ${project.basedir} + / + + *.txt* + *.md + NOTICE* + + + build.txt + + + + \ No newline at end of file diff --git a/src/main/antlr/PhoenixSQL.g b/src/main/antlr/PhoenixSQL.g new file mode 100644 index 00000000..84346199 --- /dev/null +++ b/src/main/antlr/PhoenixSQL.g @@ -0,0 +1,902 @@ + +/** + * Oracle SQL Grammar for Phoenix + * Adapted from Vampire SQL grammar + * http://www.antlr.org/grammar/1209225566284/PLSQL3.g + * + * @author jtaylor + * @since 0.1 +*/ + +grammar PhoenixSQL; + +tokens +{ + SELECT='select'; + FROM='from'; + USING='using'; + WHERE='where'; + NOT='not'; + AND='and'; + OR='or'; + NULL='null'; + TRUE='true'; + FALSE='false'; + LIKE='like'; + AS='as'; + OUTER='outer'; + ON='on'; + IN='in'; + GROUP='group'; + HAVING='having'; + ORDER='order'; + BY='by'; + ASC='asc'; + DESC='desc'; + NULLS='nulls'; + LIMIT='limit'; + FIRST='first'; + LAST='last'; + DATA='data'; + CASE='case'; + WHEN='when'; + THEN='then'; + ELSE='else'; + END='end'; + EXISTS='exists'; + IS='is'; + FIRST='first'; + DISTINCT='distinct'; + JOIN='join'; + INNER='inner'; + LEFT='left'; + RIGHT='right'; + FULL='full'; + BETWEEN='between'; + UPSERT='upsert'; + INTO='into'; + VALUES='values'; + DELETE='delete'; + CREATE='create'; + DROP='drop'; + PRIMARY='primary'; + KEY='key'; + ALTER='alter'; + COLUMN='column'; + TABLE='table'; + ADD='add'; + SPLIT='split'; + EXPLAIN='explain'; + VIEW='view'; + IF='if'; +} + + +@parser::header { +/* + * Copyright, 1999-2003, SALESFORCE.com + * All Rights Reserved + * Company Confidential + */ +package phoenix.parse; + +///CLOVER:OFF +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; +import java.math.BigDecimal; +import phoenix.util.SchemaUtil; +import phoenix.expression.function.CountAggregateFunction; +} + +@lexer::header { +/* + * Copyright, 1999-2003, SALESFORCE.com + * All Rights Reserved + * Company Confidential + */ +package phoenix.parse; +///CLOVER:OFF +} + +// -------------------------------------- +// The Parser + +@parser::members +{ + + /** + * used to turn '?' binds into : binds. + */ + private int anonBindNum; + private ParseNodeFactory factory; + + public void setParseNodeFactory(ParseNodeFactory factory) { + this.factory = factory; + } + + public boolean isCountFunction(String field) { + return CountAggregateFunction.NORMALIZED_NAME.equals(SchemaUtil.normalizeIdentifier(field)); + } + + public int line(Token t) { + return t.getLine(); + } + + public int column(Token t) { + return t.getCharPositionInLine() + 1; + } + + private void throwRecognitionException(Token t) throws RecognitionException { + RecognitionException e = new RecognitionException(); + e.token = t; + e.line = t.getLine(); + e.charPositionInLine = t.getCharPositionInLine(); + e.input = input; + throw e; + } + + public int getBindCount() { + return anonBindNum; + } + + public void resetBindCount() { + anonBindNum = 0; + } + + public String nextBind() { + return Integer.toString(anonBindNum++); + } + + protected Object recoverFromMismatchedToken(IntStream input, int ttype, BitSet follow) throws RecognitionException { + throw new MismatchedTokenException(ttype, input); + } + + public Object recoverFromMismatchedSet(IntStream input, RecognitionException e, BitSet follow) + throws RecognitionException + { + throw e; + } + + @Override + public String getErrorMessage(RecognitionException e, String[] tokenNames) { + if (e instanceof MismatchedTokenException) { + MismatchedTokenException mte = (MismatchedTokenException)e; + String txt = mte.token.getText(); + String p = mte.token.getType() == -1 ? "EOF" : PARAPHRASE[mte.token.getType()]; + String expecting = (mte.expecting < PARAPHRASE.length && mte.expecting >= 0) ? PARAPHRASE[mte.expecting] : null; + if (expecting == null) { + return "unexpected token (" + line(mte.token) + "," + column(mte.token) + "): " + (txt != null ? txt : p); + } else { + return "expecting " + expecting + + ", found '" + (txt != null ? txt : p) + "'"; + } + } else if (e instanceof NoViableAltException) { + //NoViableAltException nvae = (NoViableAltException)e; + return "unexpected token: (" + line(e.token) + "," + column(e.token) + ")" + getTokenErrorDisplay(e.token); + } + return super.getErrorMessage(e, tokenNames); + } + + public String getTokenErrorDisplay(int t) { + String ret = PARAPHRASE[t]; + if (ret == null) ret = ""; + return ret; + } + + + private String[] PARAPHRASE = new String[getTokenNames().length]; + { + PARAPHRASE[NAME] = "a field or entity name"; + PARAPHRASE[NUMBER] = "a number"; + PARAPHRASE[EQ] = "an equals sign"; + PARAPHRASE[LT] = "a left angle bracket"; + PARAPHRASE[GT] = "a right angle bracket"; + PARAPHRASE[COMMA] = "a comma"; + PARAPHRASE[LPAREN] = "a left parentheses"; + PARAPHRASE[RPAREN] = "a right parentheses"; + PARAPHRASE[SEMICOLON] = "a semi-colon"; + PARAPHRASE[COLON] = "a colon"; + PARAPHRASE[LSQUARE] = "left square bracket"; + PARAPHRASE[RSQUARE] = "right square bracket"; + PARAPHRASE[LCURLY] = "left curly bracket"; + PARAPHRASE[RCURLY] = "right curly bracket"; + PARAPHRASE[AT] = "at"; + PARAPHRASE[MINUS] = "a subtraction"; + PARAPHRASE[TILDE] = "a tilde"; + PARAPHRASE[PLUS] = "an addition"; + PARAPHRASE[ASTERISK] = "an asterisk"; + PARAPHRASE[DIVIDE] = "a division"; + PARAPHRASE[FIELDCHAR] = "a field character"; + PARAPHRASE[LETTER] = "an ansi letter"; + PARAPHRASE[POSINTEGER] = "a positive integer"; + PARAPHRASE[DIGIT] = "a number from 0 to 9"; + } +} + +@rulecatch { + catch (RecognitionException re) { + throw re; + } +} + +@lexer::members { + +} + +// Used to incrementally parse a series of semicolon-terminated SQL statement +// Note than unlike the rule below an EOF is not expected at the end. +nextStatement returns [SQLStatement ret] + : s=oneStatement {$ret = s;} SEMICOLON + | EOF + ; + +// Parses a single SQL statement (expects an EOF after the select statement). +statement returns [SQLStatement ret] + : s=oneStatement {$ret = s;} EOF + ; + +// Parses a single SQL statement (expects an EOF after the select statement). +oneStatement returns [SQLStatement ret] + : (q=select_node {$ret=q;} + | u=upsert_node {$ret=u;} + | d=delete_node {$ret=d;} + | ct=create_table {$ret=ct;} + | dt=drop_table {$ret=dt;} + | at=alter_table {$ret=at;} + | e=explain_plan {$ret=e;} + ) + ; + +// Parses a select statement which must be the only statement (expects an EOF after the statement). +query returns [SelectStatement ret] + : q=select_node EOF {$ret=q;} + ; + +// Parses a select statement which must be the only statement (expects an EOF after the statement). +explain_plan returns [SQLStatement ret] + : EXPLAIN q=statement EOF {$ret=factory.explain(q);} + ; + +// Parses an upsert statement which must be the only statement (expects an EOF after the statement). +upsert returns [UpsertStatement ret] + : u=upsert_node EOF {$ret=u;} + ; + +// Parses a delete statement which must be the only statement (expects an EOF after the statement). +delete returns [DeleteStatement ret] + : d=delete_node EOF {$ret=d;} + ; + +// Parses a create table statement which must be the only statement (expects an EOF after the statement). +createTable returns [CreateTableStatement ret] + : ct=create_table EOF {$ret=ct;} + ; + +// Parses a drop table statement which must be the only statement (expects an EOF after the statement). +dropTable returns [DropTableStatement ret] + : dt=drop_table EOF {$ret=dt;} + ; + +// Parses an alter table statement which must be the only statement (expects an EOF after the statement). +alterTable returns [AlterTableStatement ret] + : at=alter_table EOF {$ret=at;} + ; + +// Parse a create table statement. +create_table returns [CreateTableStatement ret] + : CREATE (ro=VIEW | TABLE) (IF NOT ex=EXISTS)? t=from_table_name + (LPAREN pk=key_column_defs RPAREN) + (p=properties)? + cfs = cf_defs + (SPLIT ON v=values)? + {ret = factory.createTable(t, p, pk, cfs, v, ro!=null, ex!=null, getBindCount()); } + ; + +// Parse a drop table statement. +drop_table returns [DropTableStatement ret] + : DROP (ro=VIEW | TABLE) (IF ex=EXISTS)? t=from_table_name + {ret = factory.dropTable(t, ex!=null, ro!=null); } + ; + +// Parse an alter table statement. +alter_table returns [AlterTableStatement ret] + : ALTER TABLE t=from_table_name + ( (DROP COLUMN (IF ex=EXISTS)? c=column_ref) | (ADD (IF NOT ex=EXISTS)? (cf=cf_def | d=key_column_def) ) ) + {ret = ( c == null ? cf == null ? factory.addColumn(t, d, ex!=null) : factory.addColumnFamily(t,cf, ex!=null) : factory.dropColumn(t, c, ex!=null) ); } + ; + +cf_defs returns [List ret] +@init{ret = new ArrayList(); } + : (v = cf_def {$ret.add(v);} )* +; + +cf_def returns [ColumnFamilyDef ret] + : cf=identifier (LPAREN c=column_defs RPAREN) + (p=properties)? + {$ret = factory.columnFamilyDef(cf, c, p); } + ; + +properties returns [Map ret] +@init{ret = new HashMap(); } + : k=prop_name EQ v=prop_value {$ret.put(k,v);} (COMMA k=prop_name EQ v=prop_value {$ret.put(k,v);} )* + ; + +prop_name returns [String ret] + : s=identifier { $ret = s; } + ; + +prop_value returns [Object ret] + : l=literal { $ret = l.getValue(); } + ; + +column_defs returns [List ret] +@init{ret = new ArrayList(); } + : v = column_def {$ret.add(v);} (COMMA v = column_def {$ret.add(v);} )* +; + +column_def returns [ColumnDef ret] + : field=identifier dt=identifier (LPAREN l=NUMBER RPAREN)? + {$ret = factory.columnDef(field, dt, true, l == null ? null : Integer.parseInt( l.getText() ) ); } + ; + +key_column_defs returns [List ret] +@init{ret = new ArrayList(); } + : v = key_column_def {$ret.add(v);} (COMMA v = key_column_def {$ret.add(v);} )* +; +key_column_def returns [ColumnDef ret] + : field=identifier dt=identifier (LPAREN l=NUMBER RPAREN)? (n=NOT? NULL)? + {$ret = factory.columnDef(field, dt, n==null, l == null ? null : Integer.parseInt( l.getText() ) ); } + ; + +// Parses a select statement which must be the only statement (expects an EOF after the statement). +select_expression returns [ParseNode ret] + : s=select_node {$ret = factory.subquery(s);} + ; + +// Parse a full select expression structure. +select_node returns [SelectStatement ret] + : SELECT (hint=hintClause)? sel=select_list + FROM from=parseFrom + (WHERE where=condition)? + (GROUP BY group=group_by)? + (HAVING having=condition)? + (ORDER BY order=order_by)? + (LIMIT l=limit)? + {$ret = factory.select(from, hint, sel, where, group, having, order, l, getBindCount()); } + ; + +// Parse a full upsert expression structure. +upsert_node returns [UpsertStatement ret] + : UPSERT INTO t=from_table_name + (LPAREN c=column_refs RPAREN)? + ((VALUES LPAREN v=expression_terms RPAREN) | s=select_node) + {ret = factory.upsert(t, c, v, s, getBindCount()); } + ; + +// Parses a select statement which must be the only statement (expects an EOF after the statement). +upsert_select_node returns [SelectStatement ret] + : s=select_node {$ret = s;} + ; + +// Parse a full delete expression structure. +delete_node returns [DeleteStatement ret] + : DELETE FROM t=from_table_name + (WHERE v=condition)? + {ret = factory.delete(t, v, getBindCount()); } + ; + +limit returns [LimitNode ret] + : b=bind_expression { $ret = factory.limit(b); } + | l=int_literal { $ret = factory.limit(l); } + ; + +hintClause returns [HintNode ret] + : c=ML_HINT { $ret = factory.hint(c.getText()); } + ; + +// Parse the column/expression select list part of a select. +select_list returns [List ret] +@init{ret = new ArrayList();} + : n=selectable {ret.add(n);} (COMMA n=selectable {ret.add(n);})* + ; + +// Parse either a select field or a sub select. +selectable returns [AliasedParseNode ret] + : field=expression (a=parseAlias)? { $ret = factory.aliasedNode(a, field); } + | ASTERISK { $ret = factory.aliasedNode(null, factory.wildcard());} // i.e. the '*' in 'select * from' + ; + +// Parse a group by statement +group_by returns [List ret] +@init{ret = new ArrayList();} + : expr=expression { ret.add(expr); } + (COMMA expr = expression {ret.add(expr); })* + ; + +// Parse an order by statement +order_by returns [List ret] +@init{ret = new ArrayList();} + : field=parseOrderByField { ret.add(field); } + (COMMA field = parseOrderByField {ret.add(field); })* + ; + +//parse the individual field for an order by clause +parseOrderByField returns [OrderByNode ret] +@init{boolean isAscending = true; boolean nullsLast = false;} + : (expr = expression) + (ASC {isAscending = true;} | DESC {isAscending = false;})? + (NULLS (FIRST {nullsLast = false;} | LAST {nullsLast = true;}))? + { $ret = factory.orderBy(expr, nullsLast, isAscending); } + ; + +parseFrom returns [List ret] + : l=table_refs { $ret = l; } + | l=join_specs { $ret = l; } + ; + +table_refs returns [List ret] +@init{ret = new ArrayList(4); } + : t=table_ref {$ret.add(t);} + (COMMA t=table_ref {$ret.add(t);} )* + ; + +// parse a field, if it might be a bind name. +named_table returns [NamedTableNode ret] + : t=from_table_name { $ret = factory.namedTable(null, t); } + ; + + +table_ref returns [TableNode ret] + : n=bind_name ((AS)? alias=identifier)? { $ret = factory.bindTable(alias, factory.table(null,n)); } // TODO: review + | t=from_table_name ((AS)? alias=identifier)? { $ret = factory.namedTable(alias, t); } + | LPAREN s=select_node RPAREN ((AS)? alias=identifier)? { $ret = factory.subselect(alias, s); } + ; + +join_specs returns [List ret] + : t=named_table {$ret.add(t);} (s=join_spec { $ret.add(s); })+ + ; + +join_spec returns [JoinTableNode ret] + : j=join_type JOIN t=named_table ON e=condition { $ret = factory.join(null, t, e, j); } + ; + +join_type returns [JoinTableNode.JoinType ret] + : INNER { $ret = JoinTableNode.JoinType.Inner; } + | LEFT OUTER? { $ret = JoinTableNode.JoinType.Left; } + | RIGHT OUTER? { $ret = JoinTableNode.JoinType.Right; } + | FULL OUTER? { $ret = JoinTableNode.JoinType.Full; } + ; + +parseAlias returns [String ret] + : AS? alias=parseNoReserved { $ret = alias; } + ; + +// Parse a condition, such as used in a where clause - either a basic one, or an OR of (Single or AND) expressions +condition returns [ParseNode ret] + : e=condition_or { $ret = e; } + ; + +// A set of OR'd simple expressions +condition_or returns [ParseNode ret] +@init{List l = new ArrayList(4); } + : i=condition_and {l.add(i);} (OR i=condition_and {l.add(i);})* { $ret = l.size() == 1 ? l.get(0) : factory.or(l); } + ; + +// A set of AND'd simple expressions +condition_and returns [ParseNode ret] +@init{List l = new ArrayList(4); } + : i=condition_not {l.add(i);} (AND i=condition_not {l.add(i);})* { $ret = l.size() == 1 ? l.get(0) : factory.and(l); } + ; + +// NOT or parenthesis +condition_not returns [ParseNode ret] + : ( boolean_expr ) => e=boolean_expr { $ret = e; } + | NOT e=boolean_expr { $ret = factory.not(e); } + | LPAREN e=condition RPAREN { $ret = e; } + ; + +boolean_expr returns [ParseNode ret] + : (l=expression ((EQ r=expression {$ret = factory.equal(l,r); } ) + | ((NOEQ1 | NOEQ2) r=expression {$ret = factory.notEqual(l,r); } ) + | (LT r=expression {$ret = factory.lt(l,r); } ) + | (GT r=expression {$ret = factory.gt(l,r); } ) + | (LT EQ r=expression {$ret = factory.lte(l,r); } ) + | (GT EQ r=expression {$ret = factory.gte(l,r); } ) + | (IS n=NOT? NULL {$ret = factory.isNull(l,n!=null); } ) + | ( n=NOT? ((LIKE r=expression {$ret = factory.like(l,r,n!=null); } ) + | (EXISTS LPAREN r=select_expression RPAREN {$ret = factory.exists(l,r,n!=null);} ) + | (BETWEEN r1=expression AND r2=expression {$ret = factory.between(l,r1,r2,n!=null); } ) + | ((IN ((r=bind_expression {$ret = factory.inList(Arrays.asList(l,r),n!=null);} ) + | (LPAREN r=select_expression RPAREN {$ret = factory.in(l,r,n!=null);} ) + | (v=values {List il = new ArrayList(v.size() + 1); il.add(l); il.addAll(v); $ret = factory.inList(il,n!=null);}) + ))) + )))) + ; + +bind_expression returns [BindParseNode ret] + : b=bind_name { $ret = factory.bind(b); } + ; + +expression returns [ParseNode ret] + : i=expression_add { $ret = i; } + ; + +expression_add returns [ParseNode ret] +@init{List l = new ArrayList(4); } + : i=expression_sub {l.add(i);} (PLUS i=expression_sub {l.add(i);})* { $ret = l.size() == 1 ? l.get(0) : factory.add(l); } + ; + +expression_sub returns [ParseNode ret] +@init{List l = new ArrayList(4); } + : i=expression_concat {l.add(i);} (MINUS i=expression_concat {l.add(i);})* { $ret = l.size() == 1 ? l.get(0) : factory.subtract(l); } + ; + +expression_concat returns [ParseNode ret] +@init{List l = new ArrayList(4); } + : i=expression_mult {l.add(i);} (CONCAT i=expression_mult {l.add(i);})* { $ret = l.size() == 1 ? l.get(0) : factory.concat(l); } + ; + +expression_mult returns [ParseNode ret] +@init{List l = new ArrayList(4); } + : i=expression_div {l.add(i);} (ASTERISK i=expression_div {l.add(i);})* { $ret = l.size() == 1 ? l.get(0) : factory.multiply(l); } + ; + +expression_div returns [ParseNode ret] +@init{List l = new ArrayList(4); } + : i=expression_negate {l.add(i);} (DIVIDE i=expression_negate {l.add(i);})* { $ret = l.size() == 1 ? l.get(0) : factory.divide(l); } + ; + +expression_negate returns [ParseNode ret] + : m=MINUS? e=expression_term { $ret = m==null ? e : factory.negate(e); } + ; + +// The lowest level function, which includes literals, binds, but also parenthesized expressions, functions, and case statements. +expression_term returns [ParseNode ret] +@init{ParseNode n;} + : field=identifier oj=OUTER_JOIN? {n = factory.column(field); $ret = oj==null ? n : factory.outer(n); } + | tableName=table_name DOT field=identifier oj=OUTER_JOIN? {n = factory.column(tableName, field); $ret = oj==null ? n : factory.outer(n); } + | field=identifier LPAREN l=expression_list RPAREN { $ret = factory.function(field, l);} + | field=identifier LPAREN t=ASTERISK RPAREN { if (!isCountFunction(field)) { throwRecognitionException(t); } $ret = factory.function(field, LiteralParseNode.STAR);} + | field=identifier LPAREN t=DISTINCT l=expression_list RPAREN { $ret = factory.functionDistinct(field, l);} + | e=expression_literal_bind oj=OUTER_JOIN? { n = e; $ret = oj==null ? n : factory.outer(n); } + | e=case_statement { $ret = e; } + | LPAREN e=expression RPAREN { $ret = e; } + ; + +expression_terms returns [List ret] +@init{ret = new ArrayList(); } + : v = expression {$ret.add(v);} (COMMA v = expression {$ret.add(v);} )* +; + +column_refs returns [List ret] +@init{ret = new ArrayList(); } + : v = column_ref {$ret.add(v);} (COMMA v = column_ref {$ret.add(v);} )* +; +column_ref returns [ParseNode ret] + : field=identifier {$ret = factory.column(field); } + | tableName=column_table_name DOT field=identifier {$ret = factory.column(tableName, field); } + ; + +// TODO: figure out how not repeat this three times +table_name returns [TableName ret] + : t=identifier {$ret = factory.table(null, t); } + | s=identifier DOT t=identifier {$ret = factory.table(s, t); } + ; + +// TODO: figure out how not repeat this three times +from_table_name returns [TableName ret] + : t=identifier {$ret = factory.table(null, t); } + | s=identifier DOT t=identifier {$ret = factory.table(s, t); } + ; + +// TODO: figure out how not repeat this three times +column_table_name returns [TableName ret] + : t=identifier {$ret = factory.table(null, t); } + | s=identifier DOT t=identifier {$ret = factory.table(s, t); } + ; + +// The lowest level function, which includes literals, binds, but also parenthesized expressions, functions, and case statements. +expression_literal_bind returns [ParseNode ret] + : e=literal { $ret = e; } + | b=bind_name { $ret = factory.bind(b); } + ; + +// Get a string, integer, double, date, boolean, or NULL value. +literal returns [LiteralParseNode ret] + : s=STRING_LITERAL { ret = factory.literal(s.getText()); } + | n=int_literal { ret = n; } + | d=DECIMAL { + try { + ret = factory.literal(new BigDecimal(d.getText())); + } catch (NumberFormatException e) { // Shouldn't happen since we just parsed a decimal + throwRecognitionException(d); + } + } + | NULL {ret = factory.literal(null);} + | TRUE {ret = factory.literal(Boolean.TRUE);} + | FALSE {ret = factory.literal(Boolean.FALSE);} + ; + +int_literal returns [LiteralParseNode ret] + : n=NUMBER { + try { + Long v = Long.valueOf(n.getText()); + if (v >= Integer.MIN_VALUE && v <= Integer.MAX_VALUE) { + ret = factory.literal(v.intValue()); + } else { + ret = factory.literal(v); + } + } catch (NumberFormatException e) { // Shouldn't happen since we just parsed a number + throwRecognitionException(n); + } + } + ; + +values returns [List ret] +@init{ret = new ArrayList(); } + : LPAREN v = expression_literal_bind {$ret.add(v);} (COMMA v = expression_literal_bind {$ret.add(v);} )* RPAREN +; + +// parse a field, if it might be a bind name. +table returns [String ret] + : b=bind_name { $ret = b; } + | n=parseNoReserved { $ret = n; } + ; + +// Bind names are a colon followed by 1+ letter/digits/underscores, or '?' (unclear how Oracle acutally deals with this, but we'll just treat it as a special bind) +bind_name returns [String ret] + : bname=BIND_NAME { $ret = bname.getText().substring(1); } + | QUESTION { $ret = nextBind(); } // TODO: only support this? + ; + +// Parse a field, includes line and column information. +identifier returns [String ret] + : c=parseNoReserved { $ret = c; } + ; + +parseNoReserved returns [String ret] + : n=NAME { $ret = n.getText(); } + ; + +expression_list returns [List ret] +@init{$ret = new ArrayList();} + : (e=expression {ret.add(e);})? ( COMMA e=expression {ret.add(e);} )* + ; + +case_statement returns [ParseNode ret] +@init{List w = new ArrayList(4);} + : CASE e1=expression (WHEN e2=expression THEN t=expression {w.add(t);w.add(factory.equal(e1,e2));})+ (ELSE el=expression {w.add(el);})? END {$ret = factory.caseWhen(w);} + | CASE (WHEN c=condition THEN t=expression {w.add(t);w.add(c);})+ (ELSE el=expression {w.add(el);})? END {$ret = factory.caseWhen(w);} + ; + +// -------------------------------------- +// The Lexer + +HINT_START: '/*+' ; +COMMENT_START: '/*'; +COMMENT_AND_HINT_END: '*/' ; +SL_COMMENT1: '//'; +SL_COMMENT2: '--'; + +// Bind names start with a colon and followed by 1 or more letter/digit/underscores +BIND_NAME + : COLON (LETTER|DIGIT|'_')+ + ; + +// Valid names can have a single underscore, but not multiple +// Turn back on literal testing, all names are literals. +NAME + : LETTER (FIELDCHAR)* ('\"' (DBL_QUOTE_CHAR)* '\"')? + | '\"' (DBL_QUOTE_CHAR)* '\"' + ; + +// An integer number, positive or negative +NUMBER + : POSINTEGER + ; + +LONG + : POSINTEGER ('L'|'l') + ; + +// Exponential format is not supported. +DECIMAL + : POSINTEGER? '.' POSINTEGER + ; + +DOUBLE + : DECIMAL ('D'|'d') + ; + +DOUBLE_QUOTE + : '"' + ; + +EQ + : '=' + ; + +LT + : '<' + ; + +GT + : '>' + ; + +DOUBLE_EQ + : '=''=' + ; + +NOEQ1 + : '!''=' + ; + +NOEQ2 + : '<''>' + ; + +CONCAT + : '|''|' + ; + +COMMA + : ',' + ; + +LPAREN + : '(' + ; + +RPAREN + : ')' + ; + +SEMICOLON + : ';' + ; + +COLON + : ':' + ; + +QUESTION + : '?' + ; + +LSQUARE + : '[' + ; + +RSQUARE + : ']' + ; + +LCURLY + : '{' + ; + +RCURLY + : '}' + ; + +AT + : '@' + ; + +TILDE + : '~' + ; + +PLUS + : '+' + ; + +MINUS + : '-' + ; + +ASTERISK + : '*' + ; + +DIVIDE + : '/' + ; + +OUTER_JOIN + : '(' '+' ')' + ; +// A FieldCharacter is a letter, digit, underscore, or a certain unicode section. +fragment +FIELDCHAR + : LETTER + | DIGIT + | '_' + | '\u0080'..'\ufffe' + ; + +// A Letter is a lower or upper case ascii character. +fragment +LETTER + : 'a'..'z' + | 'A'..'Z' + ; + +fragment +POSINTEGER + : DIGIT+ + ; + +fragment +DIGIT + : '0'..'9' + ; + +// string literals +STRING_LITERAL +@init{ StringBuilder sb = new StringBuilder(); } + : '\'' + ( t=CHAR { sb.append(t.getText()); } + | t=CHAR_ESC { sb.append(getText()); } + )* '\'' { setText(sb.toString()); } + ; + +fragment +CHAR + : ( ~('\'' | '\\') )+ + ; + +fragment +DBL_QUOTE_CHAR + : ( ~('\"') )+ + ; + +// escape sequence inside a string literal +fragment +CHAR_ESC + : '\\' + ( 'n' { setText("\n"); } + | 'r' { setText("\r"); } + | 't' { setText("\t"); } + | 'b' { setText("\b"); } + | 'f' { setText("\f"); } + | '\"' { setText("\""); } + | '\'' { setText("\'"); } + | '\\' { setText("\\"); } + | '_' { setText("\\_"); } + | '%' { setText("\\\%"); } + ) + | '\'\'' { setText("\'"); } + ; + +// whitespace (skip) +WS + : ( ' ' | '\t' ) { $channel=HIDDEN; } + ; + +EOL + : ('\r' | '\n') + { skip(); } + ; + +ML_HINT +@init{ StringBuilder sb = new StringBuilder(); } + : HINT_START ( options {greedy=false;} : t=. { sb.append((char)t); } )* COMMENT_AND_HINT_END + { setText(sb.toString()); } + ; + +ML_COMMENT + : COMMENT_START (~PLUS) ( options {greedy=false;} : . )* COMMENT_AND_HINT_END + { skip(); } + ; + +SL_COMMENT + : (SL_COMMENT1 | SL_COMMENT2) ( options {greedy=false;} : . )* EOL + { skip(); } + ; + +DOT + : '.' + ; diff --git a/test/unit/java/src/phoenix/compile/HavingClauseTest.java b/src/test/java/phoenix/compile/HavingClauseTest.java similarity index 100% rename from test/unit/java/src/phoenix/compile/HavingClauseTest.java rename to src/test/java/phoenix/compile/HavingClauseTest.java diff --git a/test/unit/java/src/phoenix/compile/LimitClauseTest.java b/src/test/java/phoenix/compile/LimitClauseTest.java similarity index 100% rename from test/unit/java/src/phoenix/compile/LimitClauseTest.java rename to src/test/java/phoenix/compile/LimitClauseTest.java diff --git a/test/unit/java/src/phoenix/compile/QueryCompileTest.java b/src/test/java/phoenix/compile/QueryCompileTest.java similarity index 100% rename from test/unit/java/src/phoenix/compile/QueryCompileTest.java rename to src/test/java/phoenix/compile/QueryCompileTest.java diff --git a/test/unit/java/src/phoenix/compile/QueryMetaDataTest.java b/src/test/java/phoenix/compile/QueryMetaDataTest.java similarity index 100% rename from test/unit/java/src/phoenix/compile/QueryMetaDataTest.java rename to src/test/java/phoenix/compile/QueryMetaDataTest.java diff --git a/test/unit/java/src/phoenix/compile/SelectStatementRewriterTest.java b/src/test/java/phoenix/compile/SelectStatementRewriterTest.java similarity index 100% rename from test/unit/java/src/phoenix/compile/SelectStatementRewriterTest.java rename to src/test/java/phoenix/compile/SelectStatementRewriterTest.java diff --git a/test/unit/java/src/phoenix/compile/WhereClauseFilterTest.java b/src/test/java/phoenix/compile/WhereClauseFilterTest.java similarity index 100% rename from test/unit/java/src/phoenix/compile/WhereClauseFilterTest.java rename to src/test/java/phoenix/compile/WhereClauseFilterTest.java diff --git a/test/unit/java/src/phoenix/compile/WhereClauseScanKeyTest.java b/src/test/java/phoenix/compile/WhereClauseScanKeyTest.java similarity index 100% rename from test/unit/java/src/phoenix/compile/WhereClauseScanKeyTest.java rename to src/test/java/phoenix/compile/WhereClauseScanKeyTest.java diff --git a/test/unit/java/src/phoenix/expression/LikeExpressionTest.java b/src/test/java/phoenix/expression/LikeExpressionTest.java similarity index 100% rename from test/unit/java/src/phoenix/expression/LikeExpressionTest.java rename to src/test/java/phoenix/expression/LikeExpressionTest.java diff --git a/test/unit/java/src/phoenix/iterate/AggregateResultScannerTest.java b/src/test/java/phoenix/iterate/AggregateResultScannerTest.java similarity index 100% rename from test/unit/java/src/phoenix/iterate/AggregateResultScannerTest.java rename to src/test/java/phoenix/iterate/AggregateResultScannerTest.java diff --git a/test/unit/java/src/phoenix/iterate/ConcatResultIteratorTest.java b/src/test/java/phoenix/iterate/ConcatResultIteratorTest.java similarity index 100% rename from test/unit/java/src/phoenix/iterate/ConcatResultIteratorTest.java rename to src/test/java/phoenix/iterate/ConcatResultIteratorTest.java diff --git a/test/unit/java/src/phoenix/iterate/MergeSortResultIteratorTest.java b/src/test/java/phoenix/iterate/MergeSortResultIteratorTest.java similarity index 100% rename from test/unit/java/src/phoenix/iterate/MergeSortResultIteratorTest.java rename to src/test/java/phoenix/iterate/MergeSortResultIteratorTest.java diff --git a/test/unit/java/src/phoenix/iterate/SpoolingResultIteratorTest.java b/src/test/java/phoenix/iterate/SpoolingResultIteratorTest.java similarity index 100% rename from test/unit/java/src/phoenix/iterate/SpoolingResultIteratorTest.java rename to src/test/java/phoenix/iterate/SpoolingResultIteratorTest.java diff --git a/test/unit/java/src/phoenix/jdbc/PhoenixTestEmbeddedDriver.java b/src/test/java/phoenix/jdbc/PhoenixTestEmbeddedDriver.java similarity index 95% rename from test/unit/java/src/phoenix/jdbc/PhoenixTestEmbeddedDriver.java rename to src/test/java/phoenix/jdbc/PhoenixTestEmbeddedDriver.java index 75ec413b..eb1154d8 100644 --- a/test/unit/java/src/phoenix/jdbc/PhoenixTestEmbeddedDriver.java +++ b/src/test/java/phoenix/jdbc/PhoenixTestEmbeddedDriver.java @@ -30,7 +30,10 @@ import java.sql.SQLException; import java.util.Properties; -import phoenix.query.*; +import phoenix.query.ConnectionQueryServices; +import phoenix.query.ConnectionlessQueryServicesImpl; +import phoenix.query.QueryServices; +import phoenix.query.functional.*; /** diff --git a/test/unit/java/src/phoenix/logging/PerformanceLog.java b/src/test/java/phoenix/logging/PerformanceLog.java similarity index 100% rename from test/unit/java/src/phoenix/logging/PerformanceLog.java rename to src/test/java/phoenix/logging/PerformanceLog.java diff --git a/test/unit/java/src/phoenix/memory/MemoryManagerTest.java b/src/test/java/phoenix/memory/MemoryManagerTest.java similarity index 100% rename from test/unit/java/src/phoenix/memory/MemoryManagerTest.java rename to src/test/java/phoenix/memory/MemoryManagerTest.java diff --git a/test/unit/java/src/phoenix/parse/QueryParserTest.java b/src/test/java/phoenix/parse/QueryParserTest.java similarity index 100% rename from test/unit/java/src/phoenix/parse/QueryParserTest.java rename to src/test/java/phoenix/parse/QueryParserTest.java diff --git a/test/unit/java/src/phoenix/query/BaseConnectionlessQueryTest.java b/src/test/java/phoenix/query/BaseConnectionlessQueryTest.java similarity index 100% rename from test/unit/java/src/phoenix/query/BaseConnectionlessQueryTest.java rename to src/test/java/phoenix/query/BaseConnectionlessQueryTest.java diff --git a/test/unit/java/src/phoenix/query/BaseTest.java b/src/test/java/phoenix/query/BaseTest.java similarity index 100% rename from test/unit/java/src/phoenix/query/BaseTest.java rename to src/test/java/phoenix/query/BaseTest.java diff --git a/test/unit/java/src/phoenix/query/ConnectionlessUpsertTest.java b/src/test/java/phoenix/query/ConnectionlessUpsertTest.java similarity index 100% rename from test/unit/java/src/phoenix/query/ConnectionlessUpsertTest.java rename to src/test/java/phoenix/query/ConnectionlessUpsertTest.java diff --git a/test/unit/java/src/phoenix/query/QueryServicesTestImpl.java b/src/test/java/phoenix/query/QueryServicesTestImpl.java similarity index 100% rename from test/unit/java/src/phoenix/query/QueryServicesTestImpl.java rename to src/test/java/phoenix/query/QueryServicesTestImpl.java diff --git a/test/func/java/src/phoenix/query/BaseClientMangedTimeTest.java b/src/test/java/phoenix/query/functional/BaseClientMangedTimeTest.java similarity index 98% rename from test/func/java/src/phoenix/query/BaseClientMangedTimeTest.java rename to src/test/java/phoenix/query/functional/BaseClientMangedTimeTest.java index f8e59c6d..44063e22 100644 --- a/test/func/java/src/phoenix/query/BaseClientMangedTimeTest.java +++ b/src/test/java/phoenix/query/functional/BaseClientMangedTimeTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import org.junit.Before; diff --git a/test/func/java/src/phoenix/query/BaseConnectedQueryTest.java b/src/test/java/phoenix/query/functional/BaseConnectedQueryTest.java similarity index 99% rename from test/func/java/src/phoenix/query/BaseConnectedQueryTest.java rename to src/test/java/phoenix/query/functional/BaseConnectedQueryTest.java index 190ea3e5..9a041b54 100644 --- a/test/func/java/src/phoenix/query/BaseConnectedQueryTest.java +++ b/src/test/java/phoenix/query/functional/BaseConnectedQueryTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static phoenix.util.TestUtil.*; @@ -38,6 +38,7 @@ import org.junit.BeforeClass; import phoenix.jdbc.PhoenixDatabaseMetaData; +import phoenix.query.BaseTest; import phoenix.schema.PTableType; import phoenix.util.*; diff --git a/test/func/java/src/phoenix/query/BaseHBaseManagedTimeTest.java b/src/test/java/phoenix/query/functional/BaseHBaseManagedTimeTest.java similarity index 98% rename from test/func/java/src/phoenix/query/BaseHBaseManagedTimeTest.java rename to src/test/java/phoenix/query/functional/BaseHBaseManagedTimeTest.java index 4f8a73bc..9534f1fb 100644 --- a/test/func/java/src/phoenix/query/BaseHBaseManagedTimeTest.java +++ b/src/test/java/phoenix/query/functional/BaseHBaseManagedTimeTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import org.apache.hadoop.hbase.HConstants; import org.junit.Before; diff --git a/test/func/java/src/phoenix/query/CSVUpsertTest.java b/src/test/java/phoenix/query/functional/CSVUpsertTest.java similarity index 99% rename from test/func/java/src/phoenix/query/CSVUpsertTest.java rename to src/test/java/phoenix/query/functional/CSVUpsertTest.java index 6fc3546d..e254b608 100644 --- a/test/func/java/src/phoenix/query/CSVUpsertTest.java +++ b/src/test/java/phoenix/query/functional/CSVUpsertTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; diff --git a/test/func/java/src/phoenix/query/CoalesceFunctionTest.java b/src/test/java/phoenix/query/functional/CoalesceFunctionTest.java similarity index 98% rename from test/func/java/src/phoenix/query/CoalesceFunctionTest.java rename to src/test/java/phoenix/query/functional/CoalesceFunctionTest.java index 20d62722..0e11781c 100644 --- a/test/func/java/src/phoenix/query/CoalesceFunctionTest.java +++ b/src/test/java/phoenix/query/functional/CoalesceFunctionTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.*; diff --git a/test/func/java/src/phoenix/query/CompareDecimalToLongTest.java b/src/test/java/phoenix/query/functional/CompareDecimalToLongTest.java similarity index 99% rename from test/func/java/src/phoenix/query/CompareDecimalToLongTest.java rename to src/test/java/phoenix/query/functional/CompareDecimalToLongTest.java index 7b8be725..e63bfa40 100644 --- a/test/func/java/src/phoenix/query/CompareDecimalToLongTest.java +++ b/src/test/java/phoenix/query/functional/CompareDecimalToLongTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.PHOENIX_JDBC_URL; diff --git a/test/func/java/src/phoenix/query/ConnectionQueryServicesTestImpl.java b/src/test/java/phoenix/query/functional/ConnectionQueryServicesTestImpl.java similarity index 97% rename from test/func/java/src/phoenix/query/ConnectionQueryServicesTestImpl.java rename to src/test/java/phoenix/query/functional/ConnectionQueryServicesTestImpl.java index b1ab9e8c..0ee26d12 100644 --- a/test/func/java/src/phoenix/query/ConnectionQueryServicesTestImpl.java +++ b/src/test/java/phoenix/query/functional/ConnectionQueryServicesTestImpl.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import java.io.IOException; import java.sql.SQLException; @@ -39,6 +39,9 @@ import phoenix.coprocessor.MetaDataProtocol; import phoenix.jdbc.PhoenixDatabaseMetaData; +import phoenix.query.ConnectionQueryServicesImpl; +import phoenix.query.QueryServices; +import phoenix.query.QueryServicesTestImpl; /** * diff --git a/test/func/java/src/phoenix/query/CustomEntityDataTest.java b/src/test/java/phoenix/query/functional/CustomEntityDataTest.java similarity index 99% rename from test/func/java/src/phoenix/query/CustomEntityDataTest.java rename to src/test/java/phoenix/query/functional/CustomEntityDataTest.java index e4453353..6d3878fe 100644 --- a/test/func/java/src/phoenix/query/CustomEntityDataTest.java +++ b/src/test/java/phoenix/query/functional/CustomEntityDataTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.*; diff --git a/test/func/java/src/phoenix/query/DeleteRangeTest.java b/src/test/java/phoenix/query/functional/DeleteRangeTest.java similarity index 99% rename from test/func/java/src/phoenix/query/DeleteRangeTest.java rename to src/test/java/phoenix/query/functional/DeleteRangeTest.java index b194ced7..099d4415 100644 --- a/test/func/java/src/phoenix/query/DeleteRangeTest.java +++ b/src/test/java/phoenix/query/functional/DeleteRangeTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; diff --git a/test/func/java/src/phoenix/query/ExecuteStatementsTest.java b/src/test/java/phoenix/query/functional/ExecuteStatementsTest.java similarity index 98% rename from test/func/java/src/phoenix/query/ExecuteStatementsTest.java rename to src/test/java/phoenix/query/functional/ExecuteStatementsTest.java index 250e0453..048ba59f 100644 --- a/test/func/java/src/phoenix/query/ExecuteStatementsTest.java +++ b/src/test/java/phoenix/query/functional/ExecuteStatementsTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.*; @@ -38,6 +38,7 @@ import org.junit.Test; +import phoenix.query.QueryConstants; import phoenix.util.PhoenixRuntime; public class ExecuteStatementsTest extends BaseHBaseManagedTimeTest { diff --git a/test/func/java/src/phoenix/query/ExtendedQueryExecTest.java b/src/test/java/phoenix/query/functional/ExtendedQueryExecTest.java similarity index 99% rename from test/func/java/src/phoenix/query/ExtendedQueryExecTest.java rename to src/test/java/phoenix/query/functional/ExtendedQueryExecTest.java index dea061a6..96e23c14 100644 --- a/test/func/java/src/phoenix/query/ExtendedQueryExecTest.java +++ b/src/test/java/phoenix/query/functional/ExtendedQueryExecTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.PHOENIX_JDBC_URL; diff --git a/test/func/java/src/phoenix/query/FunkyNamesTest.java b/src/test/java/phoenix/query/functional/FunkyNamesTest.java similarity index 99% rename from test/func/java/src/phoenix/query/FunkyNamesTest.java rename to src/test/java/phoenix/query/functional/FunkyNamesTest.java index 9a2a2cf0..8062ae29 100644 --- a/test/func/java/src/phoenix/query/FunkyNamesTest.java +++ b/src/test/java/phoenix/query/functional/FunkyNamesTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.*; diff --git a/test/func/java/src/phoenix/query/GroupByCaseTest.java b/src/test/java/phoenix/query/functional/GroupByCaseTest.java similarity index 99% rename from test/func/java/src/phoenix/query/GroupByCaseTest.java rename to src/test/java/phoenix/query/functional/GroupByCaseTest.java index a712a573..c76e4ff2 100644 --- a/test/func/java/src/phoenix/query/GroupByCaseTest.java +++ b/src/test/java/phoenix/query/functional/GroupByCaseTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.*; diff --git a/test/func/java/src/phoenix/query/IsNullTest.java b/src/test/java/phoenix/query/functional/IsNullTest.java similarity index 99% rename from test/func/java/src/phoenix/query/IsNullTest.java rename to src/test/java/phoenix/query/functional/IsNullTest.java index 89e98304..3d9a240b 100644 --- a/test/func/java/src/phoenix/query/IsNullTest.java +++ b/src/test/java/phoenix/query/functional/IsNullTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.PHOENIX_JDBC_URL; diff --git a/test/func/java/src/phoenix/query/KeyOnlyTest.java b/src/test/java/phoenix/query/functional/KeyOnlyTest.java similarity index 99% rename from test/func/java/src/phoenix/query/KeyOnlyTest.java rename to src/test/java/phoenix/query/functional/KeyOnlyTest.java index d364312e..5124798c 100644 --- a/test/func/java/src/phoenix/query/KeyOnlyTest.java +++ b/src/test/java/phoenix/query/functional/KeyOnlyTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.*; diff --git a/test/func/java/src/phoenix/query/MultiCfQueryExecTest.java b/src/test/java/phoenix/query/functional/MultiCfQueryExecTest.java similarity index 99% rename from test/func/java/src/phoenix/query/MultiCfQueryExecTest.java rename to src/test/java/phoenix/query/functional/MultiCfQueryExecTest.java index fad6cf01..e268f17b 100644 --- a/test/func/java/src/phoenix/query/MultiCfQueryExecTest.java +++ b/src/test/java/phoenix/query/functional/MultiCfQueryExecTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.PHOENIX_JDBC_URL; diff --git a/test/func/java/src/phoenix/query/NativeHBaseTypesTest.java b/src/test/java/phoenix/query/functional/NativeHBaseTypesTest.java similarity index 99% rename from test/func/java/src/phoenix/query/NativeHBaseTypesTest.java rename to src/test/java/phoenix/query/functional/NativeHBaseTypesTest.java index c0a0430b..37e952ca 100644 --- a/test/func/java/src/phoenix/query/NativeHBaseTypesTest.java +++ b/src/test/java/phoenix/query/functional/NativeHBaseTypesTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.*; @@ -41,6 +41,7 @@ import org.junit.Test; import phoenix.jdbc.PhoenixConnection; +import phoenix.query.ConnectionQueryServices; import phoenix.util.*; /** diff --git a/test/func/java/src/phoenix/query/ParallelIteratorsTest.java b/src/test/java/phoenix/query/functional/ParallelIteratorsTest.java similarity index 98% rename from test/func/java/src/phoenix/query/ParallelIteratorsTest.java rename to src/test/java/phoenix/query/functional/ParallelIteratorsTest.java index e1b28df3..5be71b38 100644 --- a/test/func/java/src/phoenix/query/ParallelIteratorsTest.java +++ b/src/test/java/phoenix/query/functional/ParallelIteratorsTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.*; @@ -44,6 +44,11 @@ import phoenix.iterate.ParallelIterators; import phoenix.jdbc.PhoenixConnection; +import phoenix.query.ConnectionQueryServices; +import phoenix.query.KeyRange; +import phoenix.query.QueryServices; +import phoenix.query.StatsManager; +import phoenix.query.StatsManagerImpl; import phoenix.query.StatsManagerImpl.TimeKeeper; import phoenix.schema.PSchema; import phoenix.schema.TableRef; diff --git a/test/func/java/src/phoenix/query/ProductMetricsTest.java b/src/test/java/phoenix/query/functional/ProductMetricsTest.java similarity index 99% rename from test/func/java/src/phoenix/query/ProductMetricsTest.java rename to src/test/java/phoenix/query/functional/ProductMetricsTest.java index 9ca29eb1..5d9d3795 100644 --- a/test/func/java/src/phoenix/query/ProductMetricsTest.java +++ b/src/test/java/phoenix/query/functional/ProductMetricsTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.PHOENIX_JDBC_URL; @@ -42,6 +42,7 @@ import org.apache.hadoop.hbase.util.Bytes; import org.junit.Test; +import phoenix.query.QueryConstants; import phoenix.schema.PDataType; import phoenix.util.*; diff --git a/test/func/java/src/phoenix/query/QueryDatabaseMetaDataTest.java b/src/test/java/phoenix/query/functional/QueryDatabaseMetaDataTest.java similarity index 99% rename from test/func/java/src/phoenix/query/QueryDatabaseMetaDataTest.java rename to src/test/java/phoenix/query/functional/QueryDatabaseMetaDataTest.java index ba3c3c48..6062010a 100644 --- a/test/func/java/src/phoenix/query/QueryDatabaseMetaDataTest.java +++ b/src/test/java/phoenix/query/functional/QueryDatabaseMetaDataTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.jdbc.PhoenixDatabaseMetaData.TYPE_SCHEMA; diff --git a/test/func/java/src/phoenix/query/QueryExecTest.java b/src/test/java/phoenix/query/functional/QueryExecTest.java similarity index 99% rename from test/func/java/src/phoenix/query/QueryExecTest.java rename to src/test/java/phoenix/query/functional/QueryExecTest.java index d7ce86a5..b0c2bb25 100644 --- a/test/func/java/src/phoenix/query/QueryExecTest.java +++ b/src/test/java/phoenix/query/functional/QueryExecTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.*; diff --git a/test/func/java/src/phoenix/query/QueryExecWithoutSCNTest.java b/src/test/java/phoenix/query/functional/QueryExecWithoutSCNTest.java similarity index 98% rename from test/func/java/src/phoenix/query/QueryExecWithoutSCNTest.java rename to src/test/java/phoenix/query/functional/QueryExecWithoutSCNTest.java index 0f6f3841..d1ea74e0 100644 --- a/test/func/java/src/phoenix/query/QueryExecWithoutSCNTest.java +++ b/src/test/java/phoenix/query/functional/QueryExecWithoutSCNTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.*; diff --git a/test/func/java/src/phoenix/query/QueryPlanTest.java b/src/test/java/phoenix/query/functional/QueryPlanTest.java similarity index 99% rename from test/func/java/src/phoenix/query/QueryPlanTest.java rename to src/test/java/phoenix/query/functional/QueryPlanTest.java index e7511fc4..43a30d18 100644 --- a/test/func/java/src/phoenix/query/QueryPlanTest.java +++ b/src/test/java/phoenix/query/functional/QueryPlanTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.assertEquals; import static phoenix.util.TestUtil.*; diff --git a/test/func/java/src/phoenix/query/ReadIsolationLevelTest.java b/src/test/java/phoenix/query/functional/ReadIsolationLevelTest.java similarity index 99% rename from test/func/java/src/phoenix/query/ReadIsolationLevelTest.java rename to src/test/java/phoenix/query/functional/ReadIsolationLevelTest.java index 74443e68..b9991db3 100644 --- a/test/func/java/src/phoenix/query/ReadIsolationLevelTest.java +++ b/src/test/java/phoenix/query/functional/ReadIsolationLevelTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.*; diff --git a/test/func/java/src/phoenix/query/UpsertBigValuesTest.java b/src/test/java/phoenix/query/functional/UpsertBigValuesTest.java similarity index 99% rename from test/func/java/src/phoenix/query/UpsertBigValuesTest.java rename to src/test/java/phoenix/query/functional/UpsertBigValuesTest.java index 39775f22..9f0b70ea 100644 --- a/test/func/java/src/phoenix/query/UpsertBigValuesTest.java +++ b/src/test/java/phoenix/query/functional/UpsertBigValuesTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.PHOENIX_JDBC_URL; diff --git a/test/func/java/src/phoenix/query/UpsertSelectTest.java b/src/test/java/phoenix/query/functional/UpsertSelectTest.java similarity index 99% rename from test/func/java/src/phoenix/query/UpsertSelectTest.java rename to src/test/java/phoenix/query/functional/UpsertSelectTest.java index 15a1b214..dd9b1b74 100644 --- a/test/func/java/src/phoenix/query/UpsertSelectTest.java +++ b/src/test/java/phoenix/query/functional/UpsertSelectTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.PhoenixRuntime.UPSERT_BATCH_SIZE_ATTRIB; @@ -37,6 +37,7 @@ import org.junit.Test; +import phoenix.query.QueryConstants; import phoenix.util.PhoenixRuntime; public class UpsertSelectTest extends BaseClientMangedTimeTest { diff --git a/test/func/java/src/phoenix/query/UpsertValuesTest.java b/src/test/java/phoenix/query/functional/UpsertValuesTest.java similarity index 99% rename from test/func/java/src/phoenix/query/UpsertValuesTest.java rename to src/test/java/phoenix/query/functional/UpsertValuesTest.java index de8e49a7..5036330b 100644 --- a/test/func/java/src/phoenix/query/UpsertValuesTest.java +++ b/src/test/java/phoenix/query/functional/UpsertValuesTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.PHOENIX_JDBC_URL; diff --git a/test/func/java/src/phoenix/query/VariableLengthPKTest.java b/src/test/java/phoenix/query/functional/VariableLengthPKTest.java similarity index 99% rename from test/func/java/src/phoenix/query/VariableLengthPKTest.java rename to src/test/java/phoenix/query/functional/VariableLengthPKTest.java index a17d7d5b..05cd85a0 100644 --- a/test/func/java/src/phoenix/query/VariableLengthPKTest.java +++ b/src/test/java/phoenix/query/functional/VariableLengthPKTest.java @@ -25,7 +25,7 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ******************************************************************************/ -package phoenix.query; +package phoenix.query.functional; import static org.junit.Assert.*; import static phoenix.util.TestUtil.*; diff --git a/test/unit/java/src/phoenix/schema/PDataTypeTest.java b/src/test/java/phoenix/schema/PDataTypeTest.java similarity index 100% rename from test/unit/java/src/phoenix/schema/PDataTypeTest.java rename to src/test/java/phoenix/schema/PDataTypeTest.java diff --git a/test/unit/java/src/phoenix/schema/ValueBitSetTest.java b/src/test/java/phoenix/schema/ValueBitSetTest.java similarity index 100% rename from test/unit/java/src/phoenix/schema/ValueBitSetTest.java rename to src/test/java/phoenix/schema/ValueBitSetTest.java diff --git a/test/unit/java/src/phoenix/util/AssertResults.java b/src/test/java/phoenix/util/AssertResults.java similarity index 100% rename from test/unit/java/src/phoenix/util/AssertResults.java rename to src/test/java/phoenix/util/AssertResults.java diff --git a/test/unit/java/src/phoenix/util/ByteUtilTest.java b/src/test/java/phoenix/util/ByteUtilTest.java similarity index 100% rename from test/unit/java/src/phoenix/util/ByteUtilTest.java rename to src/test/java/phoenix/util/ByteUtilTest.java diff --git a/test/unit/java/src/phoenix/util/LikeExpressionTest.java b/src/test/java/phoenix/util/LikeExpressionTest.java similarity index 100% rename from test/unit/java/src/phoenix/util/LikeExpressionTest.java rename to src/test/java/phoenix/util/LikeExpressionTest.java diff --git a/test/unit/java/src/phoenix/util/TestUtil.java b/src/test/java/phoenix/util/TestUtil.java similarity index 100% rename from test/unit/java/src/phoenix/util/TestUtil.java rename to src/test/java/phoenix/util/TestUtil.java diff --git a/test/unit/java/src/hbase-default.xml b/src/test/resources/hbase-default.xml similarity index 100% rename from test/unit/java/src/hbase-default.xml rename to src/test/resources/hbase-default.xml diff --git a/test/.classpath b/test/.classpath deleted file mode 100644 index 596c75a1..00000000 --- a/test/.classpath +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - - - - diff --git a/test/.project b/test/.project deleted file mode 100644 index e586f235..00000000 --- a/test/.project +++ /dev/null @@ -1,18 +0,0 @@ - - - phoenix-test - - - phoenix - - - - org.eclipse.jdt.core.javabuilder - - - - - - org.eclipse.jdt.core.javanature - - diff --git a/test/.settings/stub.txt b/test/.settings/stub.txt deleted file mode 100644 index e69de29b..00000000 diff --git a/test/unit/java/lib-src/junit-4.8.2-src.jar b/test/unit/java/lib-src/junit-4.8.2-src.jar deleted file mode 100644 index 7b95d733..00000000 Binary files a/test/unit/java/lib-src/junit-4.8.2-src.jar and /dev/null differ diff --git a/test/unit/java/lib/junit-4.8.2.jar b/test/unit/java/lib/junit-4.8.2.jar deleted file mode 100644 index 5b4bb849..00000000 Binary files a/test/unit/java/lib/junit-4.8.2.jar and /dev/null differ