You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@eagle.apache.org by ja...@apache.org on 2018/02/07 07:05:48 UTC
[4/7] eagle git commit: [EAGLE-1080] Fix checkstyle errors in the
eagle-query-base module
http://git-wip-us.apache.org/repos/asf/eagle/blob/c970bb42/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/TestHBaseLogReader2.java
----------------------------------------------------------------------
diff --git a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/TestHBaseLogReader2.java b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/TestHBaseLogReader2.java
index 6406b13..5de8d87 100755
--- a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/TestHBaseLogReader2.java
+++ b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/TestHBaseLogReader2.java
@@ -14,7 +14,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.eagle.query;;
+package org.apache.eagle.query;
import org.apache.eagle.common.ByteUtil;
import org.apache.eagle.common.DateTimeUtil;
@@ -34,121 +34,121 @@ import org.slf4j.LoggerFactory;
import java.util.*;
public class TestHBaseLogReader2 {
- private final static Logger LOG = LoggerFactory.getLogger(TestHBaseLogReader2.class);
+ private static final Logger LOG = LoggerFactory.getLogger(TestHBaseLogReader2.class);
private static EmbeddedHBase hbase = EmbeddedHBase.getInstance();
-
- @SuppressWarnings("serial")
- @Test
- public void testStartTimeInclusiveEndTimeExclusive() throws Exception {
- EntityDefinition entityDefinition = EntityDefinitionManager.getEntityDefinitionByEntityClass(TestTimeSeriesAPIEntity.class);
- hbase.createTable(entityDefinition.getTable(), entityDefinition.getColumnFamily());
-
- EntityDefinitionManager.registerEntity(TestTimeSeriesAPIEntity.class);
-
- final String cluster = "cluster1";
- final String datacenter = "dc1";
- String serviceName = "TestTimeSeriesAPIEntity";
- GenericEntityWriter writer = new GenericEntityWriter(serviceName);
- List<TestTimeSeriesAPIEntity> entities = new ArrayList<TestTimeSeriesAPIEntity>();
- TestTimeSeriesAPIEntity entity = new TestTimeSeriesAPIEntity();
- long timestamp1 = DateTimeUtil.humanDateToSeconds("2014-04-08 03:00:00")*1000;
- LOG.info("First entity timestamp:" + timestamp1);
- entity.setTimestamp(timestamp1);
- entity.setTags(new HashMap<String, String>(){{
- put("cluster", cluster);
- put("datacenter", datacenter);
- }});
- entity.setField7("field7");
- entities.add(entity);
-
- entity = new TestTimeSeriesAPIEntity();
- long timestamp2 = DateTimeUtil.humanDateToSeconds("2014-05-08 04:00:00")*1000;
- LOG.info("Second entity timestamp:" + timestamp2);
- entity.setTimestamp(timestamp2);
- entity.setTags(new HashMap<String, String>(){{
- put("cluster", cluster);
- put("datacenter", datacenter);
- }});
- entity.setField7("field7_2");
- entities.add(entity);
- writer.write(entities);
-
- // for timezone difference between UTC & localtime, enlarge the search range
- long queryStartTimestamp = timestamp1 - DateTimeUtil.ONEDAY;
- long queryEndTimestamp = timestamp1 + DateTimeUtil.ONEDAY;
- LOG.info("Query start timestamp:" + queryStartTimestamp);
- LOG.info("Query end timestamp:" + queryEndTimestamp);
-
- String format = "%s[@cluster=\"%s\" AND @datacenter=\"%s\"]{%s}";
- String query = String.format(format, serviceName, cluster, datacenter, "@field7");
- ListQueryCompiler comp = new ListQueryCompiler(query);
- SearchCondition condition = new SearchCondition();
- condition.setFilter(comp.filter());
- condition.setQueryExpression(comp.getQueryExpression());
- condition.setOutputFields(comp.outputFields());
-
- final List<String[]> partitionValues = comp.getQueryPartitionValues();
- if (partitionValues != null) {
- condition.setPartitionValues(Arrays.asList(partitionValues.get(0)));
- }
-
- condition.setStartRowkey(null);
- condition.setPageSize(Integer.MAX_VALUE);
- condition.setStartTime(0);
- condition.setEndTime(queryEndTimestamp);
-
- GenericEntityBatchReader reader = new GenericEntityBatchReader(serviceName, condition);
- List<TestTimeSeriesAPIEntity> list = reader.read();
-
- Assert.assertEquals(1, list.size());
- Assert.assertEquals(timestamp1, list.get(0).getTimestamp());
- Assert.assertEquals("field7", list.get(0).getField7());
-
- // for timezone difference between UTC & localtime, enlarge the search range
- queryStartTimestamp = timestamp1 - DateTimeUtil.ONEDAY;
- queryEndTimestamp = timestamp2 + DateTimeUtil.ONEDAY; // eagle timestamp is rounded to seconds
- condition.setStartTime(queryStartTimestamp);
- condition.setEndTime(queryEndTimestamp);
- reader = new GenericEntityBatchReader(serviceName, condition);
- list = reader.read();
- Assert.assertEquals(2, list.size());
-
- queryStartTimestamp = timestamp1;
- queryEndTimestamp = timestamp1; // eagle timestamp is rounded to seconds
- condition.setStartTime(queryStartTimestamp);
- condition.setEndTime(queryEndTimestamp);
- reader = new GenericEntityBatchReader(serviceName, condition);
- list = reader.read();
- Assert.assertEquals(0, list.size());
- hbase.deleteTable(entityDefinition.getTable());
-
- }
-
- @Test
- public void testByteComparison(){
- byte[] byte1 = new byte[]{-23, 12, 63};
- byte[] byte2 = ByteUtil.concat(byte1, new byte[]{0});
- Assert.assertTrue(Bytes.compareTo(byte1, byte2) < 0);
- byte[] byte3 = ByteUtil.concat(byte1, new byte[]{127});
- Assert.assertTrue(Bytes.compareTo(byte2, byte3) < 0);
- byte[] byte4 = ByteUtil.concat(byte1, new byte[]{-128});
- Assert.assertTrue(Bytes.compareTo(byte4, byte3) > 0);
- }
-
- @Test
- public void testMaxByteInBytesComparision(){
- int max = -1000000;
-// int maxb = -1000000;
- System.out.println("Byte MaxValue: " + Byte.MAX_VALUE);
- System.out.println("Byte MaxValue: " + Byte.MIN_VALUE);
- for(int i=-128; i<128; i++){
- byte b = (byte)i;
- int tmp = b & 0xff;
- max = Math.max(max, tmp);
- }
- System.out.println(max);
-
- byte b = -1;
- System.out.println(b & 0xff);
- }
+
+ @SuppressWarnings("serial")
+ @Test
+ public void testStartTimeInclusiveEndTimeExclusive() throws Exception {
+ EntityDefinition entityDefinition = EntityDefinitionManager.getEntityDefinitionByEntityClass(TestTimeSeriesAPIEntity.class);
+ hbase.createTable(entityDefinition.getTable(), entityDefinition.getColumnFamily());
+
+ EntityDefinitionManager.registerEntity(TestTimeSeriesAPIEntity.class);
+
+ final String cluster = "cluster1";
+ final String datacenter = "dc1";
+ String serviceName = "TestTimeSeriesAPIEntity";
+ GenericEntityWriter writer = new GenericEntityWriter(serviceName);
+ List<TestTimeSeriesAPIEntity> entities = new ArrayList<TestTimeSeriesAPIEntity>();
+ TestTimeSeriesAPIEntity entity = new TestTimeSeriesAPIEntity();
+ long timestamp1 = DateTimeUtil.humanDateToSeconds("2014-04-08 03:00:00")*1000;
+ LOG.info("First entity timestamp:" + timestamp1);
+ entity.setTimestamp(timestamp1);
+ entity.setTags(new HashMap<String, String>() {{
+ put("cluster", cluster);
+ put("datacenter", datacenter);
+ }});
+ entity.setField7("field7");
+ entities.add(entity);
+
+ entity = new TestTimeSeriesAPIEntity();
+ long timestamp2 = DateTimeUtil.humanDateToSeconds("2014-05-08 04:00:00")*1000;
+ LOG.info("Second entity timestamp:" + timestamp2);
+ entity.setTimestamp(timestamp2);
+ entity.setTags(new HashMap<String, String>() {{
+ put("cluster", cluster);
+ put("datacenter", datacenter);
+ }});
+ entity.setField7("field7_2");
+ entities.add(entity);
+ writer.write(entities);
+
+ // for timezone difference between UTC & localtime, enlarge the search range
+ long queryStartTimestamp = timestamp1 - DateTimeUtil.ONEDAY;
+ long queryEndTimestamp = timestamp1 + DateTimeUtil.ONEDAY;
+ LOG.info("Query start timestamp:" + queryStartTimestamp);
+ LOG.info("Query end timestamp:" + queryEndTimestamp);
+
+ String format = "%s[@cluster =\"%s\" AND @datacenter=\"%s\"]{%s}";
+ String query = String.format(format, serviceName, cluster, datacenter, "@field7");
+ ListQueryCompiler comp = new ListQueryCompiler(query);
+ SearchCondition condition = new SearchCondition();
+ condition.setFilter(comp.filter());
+ condition.setQueryExpression(comp.getQueryExpression());
+ condition.setOutputFields(comp.outputFields());
+
+ final List<String[]> partitionValues = comp.getQueryPartitionValues();
+ if (partitionValues != null) {
+ condition.setPartitionValues(Arrays.asList(partitionValues.get(0)));
+ }
+
+ condition.setStartRowkey(null);
+ condition.setPageSize(Integer.MAX_VALUE);
+ condition.setStartTime(0);
+ condition.setEndTime(queryEndTimestamp);
+
+ GenericEntityBatchReader reader = new GenericEntityBatchReader(serviceName, condition);
+ List<TestTimeSeriesAPIEntity> list = reader.read();
+
+ Assert.assertEquals(1, list.size());
+ Assert.assertEquals(timestamp1, list.get(0).getTimestamp());
+ Assert.assertEquals("field7", list.get(0).getField7());
+
+ // for timezone difference between UTC & localtime, enlarge the search range
+ queryStartTimestamp = timestamp1 - DateTimeUtil.ONEDAY;
+ queryEndTimestamp = timestamp2 + DateTimeUtil.ONEDAY; // eagle timestamp is rounded to seconds
+ condition.setStartTime(queryStartTimestamp);
+ condition.setEndTime(queryEndTimestamp);
+ reader = new GenericEntityBatchReader(serviceName, condition);
+ list = reader.read();
+ Assert.assertEquals(2, list.size());
+
+ queryStartTimestamp = timestamp1;
+ queryEndTimestamp = timestamp1; // eagle timestamp is rounded to seconds
+ condition.setStartTime(queryStartTimestamp);
+ condition.setEndTime(queryEndTimestamp);
+ reader = new GenericEntityBatchReader(serviceName, condition);
+ list = reader.read();
+ Assert.assertEquals(0, list.size());
+ hbase.deleteTable(entityDefinition.getTable());
+
+ }
+
+ @Test
+ public void testByteComparison() {
+ byte[] byte1 = new byte[]{-23, 12, 63};
+ byte[] byte2 = ByteUtil.concat(byte1, new byte[]{0});
+ Assert.assertTrue(Bytes.compareTo(byte1, byte2) < 0);
+ byte[] byte3 = ByteUtil.concat(byte1, new byte[]{127});
+ Assert.assertTrue(Bytes.compareTo(byte2, byte3) < 0);
+ byte[] byte4 = ByteUtil.concat(byte1, new byte[]{-128});
+ Assert.assertTrue(Bytes.compareTo(byte4, byte3) > 0);
+ }
+
+ @Test
+ public void testMaxByteInBytesComparision() {
+ int max = -1000000;
+ // int maxb = -1000000;
+ System.out.println("Byte MaxValue: " + Byte.MAX_VALUE);
+ System.out.println("Byte MaxValue: " + Byte.MIN_VALUE);
+ for (int i = -128; i < 128; i++) {
+ byte b = (byte)i;
+ int tmp = b & 0xff;
+ max = Math.max(max, tmp);
+ }
+ System.out.println(max);
+
+ byte b = -1;
+ System.out.println(b & 0xff);
+ }
}
http://git-wip-us.apache.org/repos/asf/eagle/blob/c970bb42/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/TestListQueryCompiler.java
----------------------------------------------------------------------
diff --git a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/TestListQueryCompiler.java b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/TestListQueryCompiler.java
index 341c976..7aa72a9 100755
--- a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/TestListQueryCompiler.java
+++ b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/TestListQueryCompiler.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
/**
- *
+ *
*/
package org.apache.eagle.query;
@@ -38,206 +38,206 @@ import java.util.List;
*/
public class TestListQueryCompiler {
- private static final Logger LOG = LoggerFactory.getLogger(TestListQueryCompiler.class);
-
- @Before
- public void prepare() throws Exception{
- String[] partitions = new String[2];
- partitions[0] = "cluster";
- partitions[1] = "datacenter";
- EntityDefinitionManager.registerEntity(TestLogAPIEntity.class);
- EntityDefinition entityDef = EntityDefinitionManager.getEntityByServiceName("TestLogAPIEntity");
- entityDef.setPartitions(partitions);
- entityDef.setTimeSeries(true);
- }
-
- /**************************************************************************************************/
- /*********************************** Test Expression In List Query*********************************/
- /**************************************************************************************************/
-
- @Test
- public void testListQueryWithoutExpression() throws Exception{
- String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND @field5 > 0.05]{@cluster, @field1}";
- ListQueryCompiler compiler = new ListQueryCompiler(query, false);
- ORExpression filter = compiler.getQueryExpression();
- Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND @field5>0.05)");
- List<String> aggFields = compiler.aggregateFields();
- Assert.assertTrue(aggFields == null);
- List<String> outputFields = compiler.outputFields();
- Assert.assertEquals(outputFields.size(), 2);
- Assert.assertTrue(outputFields.contains("cluster"));
- Assert.assertTrue(outputFields.contains("field1"));
- }
-
- @Test
- public void testListQueryWithExpressionEndWithNumberInFilter() throws Exception{
- String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND EXP{@field5 + @field6} > 0.05]{@cluster, @field1}";
- ListQueryCompiler compiler = new ListQueryCompiler(query, false);
- ORExpression filter = compiler.getQueryExpression();
- Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND field5 + field6>0.05)");
- List<String> aggFields = compiler.aggregateFields();
- Assert.assertTrue(aggFields == null);
- List<String> outputFields = compiler.outputFields();
- Assert.assertEquals(outputFields.size(), 2);
- Assert.assertTrue(outputFields.contains("cluster"));
- Assert.assertTrue(outputFields.contains("field1"));
- }
-
- @Test
- public void testListQueryWithExpressionEndWithRPARENInFilter() throws Exception{
- String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND (EXP{@field5 + @field6} > 0.05)]{@cluster, @field1}";
- ListQueryCompiler compiler = new ListQueryCompiler(query, false);
- ORExpression filter = compiler.getQueryExpression();
- LOG.info(filter.toString());
- Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND field5 + field6>0.05)");
- List<String> aggFields = compiler.aggregateFields();
- Assert.assertTrue(aggFields == null);
- List<String> outputFields = compiler.outputFields();
- Assert.assertEquals(outputFields.size(), 2);
- Assert.assertTrue(outputFields.contains("cluster"));
- Assert.assertTrue(outputFields.contains("field1"));
-
- query = "TestLogAPIEntity[(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND (EXP{@field5 + @field6} > 0.05))]{@cluster, @field1}";
- compiler = new ListQueryCompiler(query, false);
- filter = compiler.getQueryExpression();
- Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND field5 + field6>0.05)");
- aggFields = compiler.aggregateFields();
- Assert.assertTrue(aggFields == null);
- outputFields = compiler.outputFields();
- Assert.assertEquals(outputFields.size(), 2);
- Assert.assertTrue(outputFields.contains("cluster"));
- Assert.assertTrue(outputFields.contains("field1"));
- }
-
- @Test
- public void testListQueryWithExpressionEndWithRBRACEInFilter() throws Exception{
- String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND EXP{@a + @b} > EXP{0.05 + @c + @d}]{@cluster, EXP{@a + @b}}";
- ListQueryCompiler compiler = new ListQueryCompiler(query, false);
- ORExpression filter = compiler.getQueryExpression();
- Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND a + b>0.05 + c + d)");
- List<String> aggFields = compiler.aggregateFields();
- Assert.assertTrue(aggFields == null);
- List<String> outputFields = compiler.outputFields();
-// Assert.assertEquals(outputFields.size(), 2);
- Assert.assertTrue(outputFields.contains("cluster"));
- Assert.assertTrue(outputFields.contains("EXP{a + b}"));
- }
-
- /**************************************************************************************************/
- /*********************************** Test Expression In Group By Query*********************************/
- /**************************************************************************************************/
-
- @Test
- public void testGroupByQueryAggWithoutExpressionInAggFunc() throws Exception{
- String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND EXP{@a + @b} > EXP{@c + @d} AND EXP{@a + @c} < EXP{@b + @d + 0.05}]<@cluster, @datacenter>{sum(@a), avg(@b)}";
- ListQueryCompiler compiler = new ListQueryCompiler(query, false);
- ORExpression filter = compiler.getQueryExpression();
- LOG.info(filter.toString());
- Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND a + b>c + d AND a + c<b + d + 0.05)");
-
- List<String> groupByFields = compiler.groupbyFields();
- Assert.assertEquals(groupByFields.size(), 2);
- Assert.assertTrue(groupByFields.contains("cluster"));
- Assert.assertTrue(groupByFields.contains("datacenter"));
-
- List<AggregateFunctionType> functions = compiler.aggregateFunctionTypes();
- Assert.assertEquals(functions.size(), 2);
- Assert.assertTrue(functions.contains(AggregateFunctionType.sum));
- Assert.assertTrue(functions.contains(AggregateFunctionType.avg));
-
- List<String> aggFields = compiler.aggregateFields();
- Assert.assertEquals(aggFields.size(), 2);
- Assert.assertTrue(aggFields.contains("a"));
- Assert.assertTrue(aggFields.contains("b"));
- }
-
- @Test
- public void testGroupByQueryAggWithExpressionInAggFunc() throws Exception{
- String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND EXP{@a + @b} > EXP{@c + @d} AND EXP{@a + @c} < EXP{@b + @d + 0.07}]<@cluster, @datacenter>{sum(EXP{@a+@b+20.0}), avg(EXP{(@a+@c + 2.5)/@d}), count}";
- ListQueryCompiler compiler = new ListQueryCompiler(query, false);
- ORExpression filter = compiler.getQueryExpression();
- LOG.info(filter.toString());
- Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND a + b>c + d AND a + c<b + d + 0.07)");
-
- List<String> groupByFields = compiler.groupbyFields();
- Assert.assertEquals(groupByFields.size(), 2);
- Assert.assertTrue(groupByFields.contains("cluster"));
- Assert.assertTrue(groupByFields.contains("datacenter"));
-
- List<AggregateFunctionType> functions = compiler.aggregateFunctionTypes();
- Assert.assertEquals(functions.size(), 3);
- Assert.assertTrue(functions.contains(AggregateFunctionType.sum));
- Assert.assertTrue(functions.contains(AggregateFunctionType.avg));
- Assert.assertTrue(functions.contains(AggregateFunctionType.count));
-
- List<String> aggFields = compiler.aggregateFields();
- Assert.assertEquals(aggFields.size(), 3);
- Assert.assertTrue(aggFields.contains("EXP{a+b+20.0}"));
- Assert.assertTrue(aggFields.contains("EXP{(a+c + 2.5)/d}"));
- Assert.assertTrue(aggFields.contains("count"));
- }
-
- /**************************************************************************************************/
- /*********************************** Test Expression In Sort Query*********************************/
- /**************************************************************************************************/
-
- @Test
- public void testSortQueryWithoutExpressionInSort() throws Exception{
- String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND EXP{@a + @b} > EXP{@c + @d} AND EXP{@a + @c} < EXP{@b + @d}]<@cluster, @datacenter>"
- + "{sum(@a), count}.{sum(@a) asc}";
- ListQueryCompiler compiler = new ListQueryCompiler(query, false);
- ORExpression filter = compiler.getQueryExpression();
- LOG.info(filter.toString());
- Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND a + b>c + d AND a + c<b + d)");
-
- List<String> groupByFields = compiler.groupbyFields();
- Assert.assertEquals(groupByFields.size(), 2);
- Assert.assertTrue(groupByFields.contains("cluster"));
- Assert.assertTrue(groupByFields.contains("datacenter"));
-
- List<AggregateFunctionType> functions = compiler.aggregateFunctionTypes();
- Assert.assertEquals(functions.size(), 2);
- Assert.assertTrue(functions.contains(AggregateFunctionType.sum));
- Assert.assertTrue(functions.contains(AggregateFunctionType.count));
-
- List<String> aggFields = compiler.aggregateFields();
- Assert.assertEquals(aggFields.size(), 2);
- Assert.assertTrue(aggFields.contains("a"));
- Assert.assertTrue(aggFields.contains("count"));
-
- List<String> sortFields = compiler.sortFields();
- Assert.assertEquals(sortFields.size(), 1);
- Assert.assertTrue(sortFields.contains("a"));
- }
-
- @Test
- public void testSortQuerySortWithExpressionInSort() throws Exception{
- String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND EXP{@a + @b} > EXP{@c + @d} AND EXP{@a + @c} < EXP{@b + @d + 0.05}]<@cluster, @datacenter>"
- + "{sum(EXP{@a+@b+0.07}), max(EXP{(@a+@c)/@d}), min(EXP{@a+@b})}.{sum(EXP{@a+@b+0.07}) asc}";
- ListQueryCompiler compiler = new ListQueryCompiler(query, false);
- ORExpression filter = compiler.getQueryExpression();
- LOG.info(filter.toString());
- Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND a + b>c + d AND a + c<b + d + 0.05)");
-
- List<String> groupByFields = compiler.groupbyFields();
- Assert.assertEquals(groupByFields.size(), 2);
- Assert.assertTrue(groupByFields.contains("cluster"));
- Assert.assertTrue(groupByFields.contains("datacenter"));
-
- List<String> aggFields = compiler.aggregateFields();
- Assert.assertEquals(aggFields.size(), 3);
- Assert.assertTrue(aggFields.contains("EXP{a+b+0.07}"));
- Assert.assertTrue(aggFields.contains("EXP{(a+c)/d}"));
- Assert.assertTrue(aggFields.contains("EXP{a+b}"));
-
- List<AggregateFunctionType> functions = compiler.aggregateFunctionTypes();
- Assert.assertEquals(functions.size(), 3);
- Assert.assertTrue(functions.contains(AggregateFunctionType.sum));
- Assert.assertTrue(functions.contains(AggregateFunctionType.max));
- Assert.assertTrue(functions.contains(AggregateFunctionType.min));
-
- List<String> sortFields = compiler.sortFields();
- Assert.assertEquals(sortFields.size(), 1);
- Assert.assertTrue(sortFields.contains("EXP{a+b+0.07}"));
- }
+ private static final Logger LOG = LoggerFactory.getLogger(TestListQueryCompiler.class);
+
+ @Before
+ public void prepare() throws Exception{
+ String[] partitions = new String[2];
+ partitions[0] = "cluster";
+ partitions[1] = "datacenter";
+ EntityDefinitionManager.registerEntity(TestLogAPIEntity.class);
+ EntityDefinition entityDef = EntityDefinitionManager.getEntityByServiceName("TestLogAPIEntity");
+ entityDef.setPartitions(partitions);
+ entityDef.setTimeSeries(true);
+ }
+
+ /**************************************************************************************************/
+ /*********************************** Test Expression In List Query*********************************/
+ /**************************************************************************************************/
+
+ @Test
+ public void testListQueryWithoutExpression() throws Exception{
+ String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND @field5 > 0.05]{@cluster, @field1}";
+ ListQueryCompiler compiler = new ListQueryCompiler(query, false);
+ ORExpression filter = compiler.getQueryExpression();
+ Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND @field5>0.05)");
+ List<String> aggFields = compiler.aggregateFields();
+ Assert.assertTrue(aggFields == null);
+ List<String> outputFields = compiler.outputFields();
+ Assert.assertEquals(outputFields.size(), 2);
+ Assert.assertTrue(outputFields.contains("cluster"));
+ Assert.assertTrue(outputFields.contains("field1"));
+ }
+
+ @Test
+ public void testListQueryWithExpressionEndWithNumberInFilter() throws Exception{
+ String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND EXP{@field5 + @field6} > 0.05]{@cluster, @field1}";
+ ListQueryCompiler compiler = new ListQueryCompiler(query, false);
+ ORExpression filter = compiler.getQueryExpression();
+ Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND field5 + field6>0.05)");
+ List<String> aggFields = compiler.aggregateFields();
+ Assert.assertTrue(aggFields == null);
+ List<String> outputFields = compiler.outputFields();
+ Assert.assertEquals(outputFields.size(), 2);
+ Assert.assertTrue(outputFields.contains("cluster"));
+ Assert.assertTrue(outputFields.contains("field1"));
+ }
+
+ @Test
+ public void testListQueryWithExpressionEndWithRPARENInFilter() throws Exception{
+ String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND (EXP{@field5 + @field6} > 0.05)]{@cluster, @field1}";
+ ListQueryCompiler compiler = new ListQueryCompiler(query, false);
+ ORExpression filter = compiler.getQueryExpression();
+ LOG.info(filter.toString());
+ Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND field5 + field6>0.05)");
+ List<String> aggFields = compiler.aggregateFields();
+ Assert.assertTrue(aggFields == null);
+ List<String> outputFields = compiler.outputFields();
+ Assert.assertEquals(outputFields.size(), 2);
+ Assert.assertTrue(outputFields.contains("cluster"));
+ Assert.assertTrue(outputFields.contains("field1"));
+
+ query = "TestLogAPIEntity[(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND (EXP{@field5 + @field6} > 0.05))]{@cluster, @field1}";
+ compiler = new ListQueryCompiler(query, false);
+ filter = compiler.getQueryExpression();
+ Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND field5 + field6>0.05)");
+ aggFields = compiler.aggregateFields();
+ Assert.assertTrue(aggFields == null);
+ outputFields = compiler.outputFields();
+ Assert.assertEquals(outputFields.size(), 2);
+ Assert.assertTrue(outputFields.contains("cluster"));
+ Assert.assertTrue(outputFields.contains("field1"));
+ }
+
+ @Test
+ public void testListQueryWithExpressionEndWithRBRACEInFilter() throws Exception{
+ String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND EXP{@a + @b} > EXP{0.05 + @c + @d}]{@cluster, EXP{@a + @b}}";
+ ListQueryCompiler compiler = new ListQueryCompiler(query, false);
+ ORExpression filter = compiler.getQueryExpression();
+ Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND a + b>0.05 + c + d)");
+ List<String> aggFields = compiler.aggregateFields();
+ Assert.assertTrue(aggFields == null);
+ List<String> outputFields = compiler.outputFields();
+ // Assert.assertEquals(outputFields.size(), 2);
+ Assert.assertTrue(outputFields.contains("cluster"));
+ Assert.assertTrue(outputFields.contains("EXP{a + b}"));
+ }
+
+ /**************************************************************************************************/
+ /*********************************** Test Expression In Group By Query*********************************/
+ /**************************************************************************************************/
+
+ @Test
+ public void testGroupByQueryAggWithoutExpressionInAggFunc() throws Exception{
+ String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND EXP{@a + @b} > EXP{@c + @d} AND EXP{@a + @c} < EXP{@b + @d + 0.05}]<@cluster, @datacenter>{sum(@a), avg(@b)}";
+ ListQueryCompiler compiler = new ListQueryCompiler(query, false);
+ ORExpression filter = compiler.getQueryExpression();
+ LOG.info(filter.toString());
+ Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND a + b>c + d AND a + c<b + d + 0.05)");
+
+ List<String> groupByFields = compiler.groupbyFields();
+ Assert.assertEquals(groupByFields.size(), 2);
+ Assert.assertTrue(groupByFields.contains("cluster"));
+ Assert.assertTrue(groupByFields.contains("datacenter"));
+
+ List<AggregateFunctionType> functions = compiler.aggregateFunctionTypes();
+ Assert.assertEquals(functions.size(), 2);
+ Assert.assertTrue(functions.contains(AggregateFunctionType.sum));
+ Assert.assertTrue(functions.contains(AggregateFunctionType.avg));
+
+ List<String> aggFields = compiler.aggregateFields();
+ Assert.assertEquals(aggFields.size(), 2);
+ Assert.assertTrue(aggFields.contains("a"));
+ Assert.assertTrue(aggFields.contains("b"));
+ }
+
+ @Test
+ public void testGroupByQueryAggWithExpressionInAggFunc() throws Exception{
+ String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND EXP{@a + @b} > EXP{@c + @d} AND EXP{@a + @c} < EXP{@b + @d + 0.07}]<@cluster, @datacenter>{sum(EXP{@a+@b+20.0}), avg(EXP{(@a+@c + 2.5)/@d}), count}";
+ ListQueryCompiler compiler = new ListQueryCompiler(query, false);
+ ORExpression filter = compiler.getQueryExpression();
+ LOG.info(filter.toString());
+ Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND a + b>c + d AND a + c<b + d + 0.07)");
+
+ List<String> groupByFields = compiler.groupbyFields();
+ Assert.assertEquals(groupByFields.size(), 2);
+ Assert.assertTrue(groupByFields.contains("cluster"));
+ Assert.assertTrue(groupByFields.contains("datacenter"));
+
+ List<AggregateFunctionType> functions = compiler.aggregateFunctionTypes();
+ Assert.assertEquals(functions.size(), 3);
+ Assert.assertTrue(functions.contains(AggregateFunctionType.sum));
+ Assert.assertTrue(functions.contains(AggregateFunctionType.avg));
+ Assert.assertTrue(functions.contains(AggregateFunctionType.count));
+
+ List<String> aggFields = compiler.aggregateFields();
+ Assert.assertEquals(aggFields.size(), 3);
+ Assert.assertTrue(aggFields.contains("EXP{a+b+20.0}"));
+ Assert.assertTrue(aggFields.contains("EXP{(a+c + 2.5)/d}"));
+ Assert.assertTrue(aggFields.contains("count"));
+ }
+
+ /**************************************************************************************************/
+ /*********************************** Test Expression In Sort Query*********************************/
+ /**************************************************************************************************/
+
+ @Test
+ public void testSortQueryWithoutExpressionInSort() throws Exception{
+ String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND EXP{@a + @b} > EXP{@c + @d} AND EXP{@a + @c} < EXP{@b + @d}]<@cluster, @datacenter>"
+ + "{sum(@a), count}.{sum(@a) asc}";
+ ListQueryCompiler compiler = new ListQueryCompiler(query, false);
+ ORExpression filter = compiler.getQueryExpression();
+ LOG.info(filter.toString());
+ Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND a + b>c + d AND a + c<b + d)");
+
+ List<String> groupByFields = compiler.groupbyFields();
+ Assert.assertEquals(groupByFields.size(), 2);
+ Assert.assertTrue(groupByFields.contains("cluster"));
+ Assert.assertTrue(groupByFields.contains("datacenter"));
+
+ List<AggregateFunctionType> functions = compiler.aggregateFunctionTypes();
+ Assert.assertEquals(functions.size(), 2);
+ Assert.assertTrue(functions.contains(AggregateFunctionType.sum));
+ Assert.assertTrue(functions.contains(AggregateFunctionType.count));
+
+ List<String> aggFields = compiler.aggregateFields();
+ Assert.assertEquals(aggFields.size(), 2);
+ Assert.assertTrue(aggFields.contains("a"));
+ Assert.assertTrue(aggFields.contains("count"));
+
+ List<String> sortFields = compiler.sortFields();
+ Assert.assertEquals(sortFields.size(), 1);
+ Assert.assertTrue(sortFields.contains("a"));
+ }
+
+ @Test
+ public void testSortQuerySortWithExpressionInSort() throws Exception{
+ String query = "TestLogAPIEntity[@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND EXP{@a + @b} > EXP{@c + @d} AND EXP{@a + @c} < EXP{@b + @d + 0.05}]<@cluster, @datacenter>"
+ + "{sum(EXP{@a+@b+0.07}), max(EXP{(@a+@c)/@d}), min(EXP{@a+@b})}.{sum(EXP{@a+@b+0.07}) asc}";
+ ListQueryCompiler compiler = new ListQueryCompiler(query, false);
+ ORExpression filter = compiler.getQueryExpression();
+ LOG.info(filter.toString());
+ Assert.assertEquals(filter.toString(), "(@cluster=\"cluster\" AND @datacenter=\"datacenter\" AND a + b>c + d AND a + c<b + d + 0.05)");
+
+ List<String> groupByFields = compiler.groupbyFields();
+ Assert.assertEquals(groupByFields.size(), 2);
+ Assert.assertTrue(groupByFields.contains("cluster"));
+ Assert.assertTrue(groupByFields.contains("datacenter"));
+
+ List<String> aggFields = compiler.aggregateFields();
+ Assert.assertEquals(aggFields.size(), 3);
+ Assert.assertTrue(aggFields.contains("EXP{a+b+0.07}"));
+ Assert.assertTrue(aggFields.contains("EXP{(a+c)/d}"));
+ Assert.assertTrue(aggFields.contains("EXP{a+b}"));
+
+ List<AggregateFunctionType> functions = compiler.aggregateFunctionTypes();
+ Assert.assertEquals(functions.size(), 3);
+ Assert.assertTrue(functions.contains(AggregateFunctionType.sum));
+ Assert.assertTrue(functions.contains(AggregateFunctionType.max));
+ Assert.assertTrue(functions.contains(AggregateFunctionType.min));
+
+ List<String> sortFields = compiler.sortFields();
+ Assert.assertEquals(sortFields.size(), 1);
+ Assert.assertTrue(sortFields.contains("EXP{a+b+0.07}"));
+ }
}
http://git-wip-us.apache.org/repos/asf/eagle/blob/c970bb42/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/raw/TestGroupbyKey.java
----------------------------------------------------------------------
diff --git a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/raw/TestGroupbyKey.java b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/raw/TestGroupbyKey.java
index 2683220..9371656 100755
--- a/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/raw/TestGroupbyKey.java
+++ b/eagle-core/eagle-query/eagle-query-base/src/test/java/org/apache/eagle/query/aggregate/raw/TestGroupbyKey.java
@@ -20,54 +20,55 @@ import org.junit.Assert;
import org.junit.Test;
public class TestGroupbyKey {
- @Test
- public void testGroupbyKey(){
- GroupbyKey key1 = new GroupbyKey();
- Assert.assertEquals(0, key1.getValue().size());
-
- key1.addValue(new byte[]{1, 3, 5});
- Assert.assertEquals(1, key1.getValue().size());
-
- key1.clear();
- Assert.assertEquals(0, key1.getValue().size());
-
- key1.addValue(new byte[]{1, 3, 5});
- GroupbyKey key2 = new GroupbyKey();
- key2.addValue(new byte[]{1, 3, 5});
- Assert.assertEquals(key1, key2);
-
- GroupbyKey key3 = new GroupbyKey(key1);
- Assert.assertEquals(key1, key3);
- Assert.assertEquals(key2, key3);
- }
-
- @Test
- public void testGroupbyKeyComparator(){
- GroupbyKeyComparator comparator = new GroupbyKeyComparator();
- GroupbyKey key1 = new GroupbyKey();
- key1.addValue("hello".getBytes());
- GroupbyKey key2 = new GroupbyKey();
- key2.addValue("world".getBytes());
- int r = comparator.compare(key1, key2);
- Assert.assertTrue(r < 0);
-
- key2.clear();
- key2.addValue("friend".getBytes());
- r = comparator.compare(key1, key2);
- Assert.assertTrue(r > 0);
-
- key2.clear();
- key2.addValue("hello".getBytes());
- r = comparator.compare(key1, key2);
- Assert.assertTrue(r == 0);
-
- key1.clear();
- key2.clear();
- key1.addValue("hello".getBytes());
- key1.addValue("tom".getBytes());
- key2.addValue("hello".getBytes());
- key2.addValue("jackie".getBytes());
- r = comparator.compare(key1, key2);
- Assert.assertTrue(r > 0);
- }
+
+ @Test
+ public void testGroupbyKey() {
+ GroupbyKey key1 = new GroupbyKey();
+ Assert.assertEquals(0, key1.getValue().size());
+
+ key1.addValue(new byte[]{1, 3, 5});
+ Assert.assertEquals(1, key1.getValue().size());
+
+ key1.clear();
+ Assert.assertEquals(0, key1.getValue().size());
+
+ key1.addValue(new byte[]{1, 3, 5});
+ GroupbyKey key2 = new GroupbyKey();
+ key2.addValue(new byte[]{1, 3, 5});
+ Assert.assertEquals(key1, key2);
+
+ GroupbyKey key3 = new GroupbyKey(key1);
+ Assert.assertEquals(key1, key3);
+ Assert.assertEquals(key2, key3);
+ }
+
+ @Test
+ public void testGroupbyKeyComparator() {
+ GroupbyKeyComparator comparator = new GroupbyKeyComparator();
+ GroupbyKey key1 = new GroupbyKey();
+ key1.addValue("hello".getBytes());
+ GroupbyKey key2 = new GroupbyKey();
+ key2.addValue("world".getBytes());
+ int r = comparator.compare(key1, key2);
+ Assert.assertTrue(r < 0);
+
+ key2.clear();
+ key2.addValue("friend".getBytes());
+ r = comparator.compare(key1, key2);
+ Assert.assertTrue(r > 0);
+
+ key2.clear();
+ key2.addValue("hello".getBytes());
+ r = comparator.compare(key1, key2);
+ Assert.assertTrue(r == 0);
+
+ key1.clear();
+ key2.clear();
+ key1.addValue("hello".getBytes());
+ key1.addValue("tom".getBytes());
+ key2.addValue("hello".getBytes());
+ key2.addValue("jackie".getBytes());
+ r = comparator.compare(key1, key2);
+ Assert.assertTrue(r > 0);
+ }
}