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); + } }
