You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@pig.apache.org by ch...@apache.org on 2012/11/08 18:06:50 UTC
svn commit: r1407167 [9/10] - in /pig/trunk: ./ test/org/apache/pig/test/
test/org/apache/pig/test/pigunit/
Modified: pig/trunk/test/org/apache/pig/test/TestTypeCheckingValidatorNewLP.java
URL: http://svn.apache.org/viewvc/pig/trunk/test/org/apache/pig/test/TestTypeCheckingValidatorNewLP.java?rev=1407167&r1=1407166&r2=1407167&view=diff
==============================================================================
--- pig/trunk/test/org/apache/pig/test/TestTypeCheckingValidatorNewLP.java (original)
+++ pig/trunk/test/org/apache/pig/test/TestTypeCheckingValidatorNewLP.java Thu Nov 8 17:06:46 2012
@@ -18,9 +18,10 @@
package org.apache.pig.test;
-import static org.apache.pig.newplan.logical.relational.LOTestHelper.newLOLoad;
-
import static org.apache.pig.ExecType.LOCAL;
+import static org.apache.pig.newplan.logical.relational.LOTestHelper.newLOLoad;
+import static org.apache.pig.test.Util.checkExceptionMessage;
+import static org.apache.pig.test.Util.checkMessageInException;
import static org.apache.pig.test.utils.TypeCheckingTestUtil.genDummyLOLoadNewLP;
import static org.apache.pig.test.utils.TypeCheckingTestUtil.genFlatSchema;
import static org.apache.pig.test.utils.TypeCheckingTestUtil.genFlatSchemaInTuple;
@@ -44,8 +45,6 @@ import java.util.Properties;
import junit.framework.Assert;
-import org.joda.time.DateTime;
-
import org.apache.hadoop.conf.Configuration;
import org.apache.pig.EvalFunc;
import org.apache.pig.ExecType;
@@ -83,10 +82,10 @@ import org.apache.pig.newplan.logical.ex
import org.apache.pig.newplan.logical.expression.DereferenceExpression;
import org.apache.pig.newplan.logical.expression.DivideExpression;
import org.apache.pig.newplan.logical.expression.EqualExpression;
-import org.apache.pig.newplan.logical.expression.GreaterThanExpression;
import org.apache.pig.newplan.logical.expression.GreaterThanEqualExpression;
-import org.apache.pig.newplan.logical.expression.LessThanExpression;
+import org.apache.pig.newplan.logical.expression.GreaterThanExpression;
import org.apache.pig.newplan.logical.expression.LessThanEqualExpression;
+import org.apache.pig.newplan.logical.expression.LessThanExpression;
import org.apache.pig.newplan.logical.expression.LogicalExpression;
import org.apache.pig.newplan.logical.expression.LogicalExpressionPlan;
import org.apache.pig.newplan.logical.expression.LogicalExpressionVisitor;
@@ -123,17 +122,18 @@ import org.apache.pig.newplan.logical.vi
import org.apache.pig.newplan.logical.visitor.UnionOnSchemaSetter;
import org.apache.pig.parser.ParserException;
import org.apache.pig.parser.ParserTestingUtils;
+import org.joda.time.DateTime;
import org.junit.Before;
+import org.junit.BeforeClass;
import org.junit.Test;
-import static org.apache.pig.test.Util.*;
public class TestTypeCheckingValidatorNewLP {
PigContext pc = new PigContext(ExecType.LOCAL, new Properties());
- private static final String CAST_LOAD_NOT_FOUND =
+ private static final String CAST_LOAD_NOT_FOUND =
"Cannot resolve load function to use for casting from bytearray";
-
-
+
+
/* (non-Javadoc)
* @see junit.framework.TestCase#setUp()
*/
@@ -148,16 +148,16 @@ public class TestTypeCheckingValidatorNe
simpleEchoStreamingCommand = "perl -ne 'print \\\"$_\\\"'";
else
simpleEchoStreamingCommand = "perl -ne 'print \"$_\"'";
+ }
+
+ @BeforeClass
+ public static void setUpBeforeClass() throws Exception {
File fileA = new File("a");
File fileB = new File("b");
- try {
- fileA.delete();
- fileB.delete();
- if(!fileA.createNewFile() || !fileB.createNewFile())
- fail("Unable to create input files");
- } catch (IOException e) {
- fail("Unable to create input files:" + e.getMessage());
- }
+ fileA.delete();
+ fileB.delete();
+ if(!fileA.createNewFile() || !fileB.createNewFile())
+ fail("Unable to create input files");
fileA.deleteOnExit();
fileB.deleteOnExit();
}
@@ -168,31 +168,30 @@ public class TestTypeCheckingValidatorNe
ConstantExpression constant1 = new ConstantExpression(expPlan, 10);
- ConstantExpression constant2 = new ConstantExpression(expPlan, 20D) ;
- ConstantExpression constant3 = new ConstantExpression(expPlan, 123f) ;
+ ConstantExpression constant2 = new ConstantExpression(expPlan, 20D);
+ ConstantExpression constant3 = new ConstantExpression(expPlan, 123f);
- AddExpression add1 = new AddExpression(expPlan, constant1, constant2) ;
- CastExpression cast1 = new CastExpression(expPlan,constant3, createFS(DataType.DOUBLE)) ;
- MultiplyExpression mul1 = new MultiplyExpression(expPlan, add1, cast1) ;
+ AddExpression add1 = new AddExpression(expPlan, constant1, constant2);
+ CastExpression cast1 = new CastExpression(expPlan,constant3, createFS(DataType.DOUBLE));
+ MultiplyExpression mul1 = new MultiplyExpression(expPlan, add1, cast1);
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(expPlan, collector, null);
expTypeChecker.visit();
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
if (collector.hasError()) {
- throw new Exception("Error during type checking") ;
- }
+ throw new Exception("Error during type checking");
+ }
// Induction check
- assertEquals(DataType.DOUBLE, add1.getType()) ;
- assertEquals(DataType.DOUBLE, mul1.getType()) ;
+ assertEquals(DataType.DOUBLE, add1.getType());
+ assertEquals(DataType.DOUBLE, mul1.getType());
// Cast insertion check
- assertEquals(DataType.DOUBLE, add1.getLhs().getType()) ;
- assertEquals(DataType.DOUBLE, mul1.getRhs().getType()) ;
-
+ assertEquals(DataType.DOUBLE, add1.getLhs().getType());
+ assertEquals(DataType.DOUBLE, mul1.getRhs().getType());
}
private LogicalFieldSchema createFS(byte datatype) {
@@ -201,229 +200,227 @@ public class TestTypeCheckingValidatorNe
@Test
public void testExpressionTypeCheckingFail1() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan, 10) ;
- ConstantExpression constant2 = new ConstantExpression(plan, 20D) ;
- ConstantExpression constant3 = new ConstantExpression(plan, "123") ;
-
- AddExpression add1 = new AddExpression(plan, constant1, constant2) ;
- CastExpression cast1 = new CastExpression(plan, constant3, createFS(DataType.BYTEARRAY)) ;
- MultiplyExpression mul1 = new MultiplyExpression(plan, add1, cast1) ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, 10);
+ ConstantExpression constant2 = new ConstantExpression(plan, 20D);
+ ConstantExpression constant3 = new ConstantExpression(plan, "123");
+
+ AddExpression add1 = new AddExpression(plan, constant1, constant2);
+ CastExpression cast1 = new CastExpression(plan, constant3, createFS(DataType.BYTEARRAY));
+ MultiplyExpression mul1 = new MultiplyExpression(plan, add1, cast1);
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, null);
try {
expTypeChecker.visit();
- fail("Exception expected") ;
+ fail("Exception expected");
}
catch (TypeCheckerException pve) {
// good
}
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
if (!collector.hasError()) {
- throw new Exception("Error during type checking") ;
- }
+ throw new Exception("Error during type checking");
+ }
}
@Test
public void testExpressionTypeChecking2() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan, 10) ;
- ConstantExpression constant2 = new ConstantExpression(plan, new DataByteArray()) ;
- ConstantExpression constant3 = new ConstantExpression(plan, 123L) ;
- ConstantExpression constant4 = new ConstantExpression(plan, true) ;
-
- SubtractExpression sub1 = new SubtractExpression(plan, constant1, constant2) ;
- GreaterThanExpression gt1 = new GreaterThanExpression(plan, sub1, constant3) ;
- AndExpression and1 = new AndExpression(plan, gt1, constant4) ;
- NotExpression not1 = new NotExpression(plan, and1) ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, 10);
+ ConstantExpression constant2 = new ConstantExpression(plan, new DataByteArray());
+ ConstantExpression constant3 = new ConstantExpression(plan, 123L);
+ ConstantExpression constant4 = new ConstantExpression(plan, true);
+
+ SubtractExpression sub1 = new SubtractExpression(plan, constant1, constant2);
+ GreaterThanExpression gt1 = new GreaterThanExpression(plan, sub1, constant3);
+ AndExpression and1 = new AndExpression(plan, gt1, constant4);
+ NotExpression not1 = new NotExpression(plan, and1);
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, null);
expTypeChecker.visit();
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
if (collector.hasError()) {
- throw new Exception("Error not expected during type checking") ;
- }
+ throw new Exception("Error not expected during type checking");
+ }
- // Induction check
- assertEquals(DataType.INTEGER, sub1.getType()) ;
- assertEquals(DataType.BOOLEAN, gt1.getType()) ;
- assertEquals(DataType.BOOLEAN, and1.getType()) ;
- assertEquals(DataType.BOOLEAN, not1.getType()) ;
-
- // Cast insertion check
- assertEquals(DataType.INTEGER, sub1.getRhs().getType()) ;
- assertEquals(DataType.LONG, gt1.getLhs().getType()) ;
+ // Induction check
+ assertEquals(DataType.INTEGER, sub1.getType());
+ assertEquals(DataType.BOOLEAN, gt1.getType());
+ assertEquals(DataType.BOOLEAN, and1.getType());
+ assertEquals(DataType.BOOLEAN, not1.getType());
+
+ // Cast insertion check
+ assertEquals(DataType.INTEGER, sub1.getRhs().getType());
+ assertEquals(DataType.LONG, gt1.getLhs().getType());
}
@Test
public void testExpressionTypeChecking3() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan, 10) ;
- ConstantExpression constant2 = new ConstantExpression(plan, 20L) ;
- ConstantExpression constant3 = new ConstantExpression(plan, 123) ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, 10);
+ ConstantExpression constant2 = new ConstantExpression(plan, 20L);
+ ConstantExpression constant3 = new ConstantExpression(plan, 123);
- ModExpression mod1 = new ModExpression(plan, constant1, constant2) ;
- EqualExpression equal1 = new EqualExpression(plan, mod1, constant3) ;
+ ModExpression mod1 = new ModExpression(plan, constant1, constant2);
+ EqualExpression equal1 = new EqualExpression(plan, mod1, constant3);
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, null);
expTypeChecker.visit();
plan.explain(System.out, "text", true);
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
if (collector.hasError()) {
- throw new Exception("Error during type checking") ;
- }
+ throw new Exception("Error during type checking");
+ }
// Induction check
- assertEquals(DataType.LONG, mod1.getType()) ;
- assertEquals(DataType.BOOLEAN, equal1.getType()) ;
+ assertEquals(DataType.LONG, mod1.getType());
+ assertEquals(DataType.BOOLEAN, equal1.getType());
// Cast insertion check
- assertEquals(DataType.LONG, mod1.getLhs().getType()) ;
- assertEquals(DataType.LONG, equal1.getRhs().getType()) ;
+ assertEquals(DataType.LONG, mod1.getLhs().getType());
+ assertEquals(DataType.LONG, equal1.getRhs().getType());
}
@Test
public void testExpressionTypeChecking4() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan, 10) ;
- ConstantExpression constant2 = new ConstantExpression(plan, 20D) ;
- ConstantExpression constant3 = new ConstantExpression(plan, 123f) ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, 10);
+ ConstantExpression constant2 = new ConstantExpression(plan, 20D);
+ ConstantExpression constant3 = new ConstantExpression(plan, 123f);
- DivideExpression div1 = new DivideExpression(plan, constant1, constant2) ;
+ DivideExpression div1 = new DivideExpression(plan, constant1, constant2);
CastExpression cast1 = new CastExpression(plan, constant3, createFS(DataType.DOUBLE));
- NotEqualExpression notequal1 = new NotEqualExpression(plan, div1, cast1) ;
+ NotEqualExpression notequal1 = new NotEqualExpression(plan, div1, cast1);
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, null);
- expTypeChecker.visit();
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
+ expTypeChecker.visit();
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
if (collector.hasError()) {
- throw new Exception("Error during type checking") ;
- }
+ throw new Exception("Error during type checking");
+ }
// Induction check
- assertEquals(DataType.DOUBLE, div1.getType()) ;
- assertEquals(DataType.BOOLEAN, notequal1.getType()) ;
+ assertEquals(DataType.DOUBLE, div1.getType());
+ assertEquals(DataType.BOOLEAN, notequal1.getType());
// Cast insertion check
- assertEquals(DataType.DOUBLE, div1.getLhs().getType()) ;
- assertEquals(DataType.DOUBLE, notequal1.getRhs().getType()) ;
+ assertEquals(DataType.DOUBLE, div1.getLhs().getType());
+ assertEquals(DataType.DOUBLE, notequal1.getRhs().getType());
}
@Test
public void testExpressionTypeCheckingFail4() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan, 10) ;
- ConstantExpression constant2 = new ConstantExpression(plan, 20D) ;
- ConstantExpression constant3 = new ConstantExpression(plan, "123") ;
-
- DivideExpression div1 = new DivideExpression(plan, constant1, constant2) ;
- CastExpression cast1 = new CastExpression(plan, constant3, createFS(DataType.BYTEARRAY)) ;
- NotEqualExpression notequal1 = new NotEqualExpression(plan, div1, cast1) ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, 10);
+ ConstantExpression constant2 = new ConstantExpression(plan, 20D);
+ ConstantExpression constant3 = new ConstantExpression(plan, "123");
+
+ DivideExpression div1 = new DivideExpression(plan, constant1, constant2);
+ CastExpression cast1 = new CastExpression(plan, constant3, createFS(DataType.BYTEARRAY));
+ NotEqualExpression notequal1 = new NotEqualExpression(plan, div1, cast1);
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, null);
- try{
- expTypeChecker.visit();
- fail("Exception expected") ;
- }
- catch (TypeCheckerException pve) {
+ try {
+ expTypeChecker.visit();
+ fail("Exception expected");
+ } catch (TypeCheckerException pve) {
// good
}
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
if (!collector.hasError()) {
- throw new Exception("Error during type checking") ;
- }
+ fail("Error during type checking");
+ }
}
@Test
public void testExpressionTypeChecking5() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan, 10F) ;
- ConstantExpression constant2 = new ConstantExpression(plan, 20L) ;
- ConstantExpression constant3 = new ConstantExpression(plan, 123F) ;
- ConstantExpression constant4 = new ConstantExpression(plan, 123D) ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, 10F);
+ ConstantExpression constant2 = new ConstantExpression(plan, 20L);
+ ConstantExpression constant3 = new ConstantExpression(plan, 123F);
+ ConstantExpression constant4 = new ConstantExpression(plan, 123D);
- LessThanEqualExpression lesser1 = new LessThanEqualExpression(plan, constant1, constant2) ;
- BinCondExpression bincond1 = new BinCondExpression(plan, lesser1, constant3, constant4) ;
+ LessThanEqualExpression lesser1 = new LessThanEqualExpression(plan, constant1, constant2);
+ BinCondExpression bincond1 = new BinCondExpression(plan, lesser1, constant3, constant4);
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, null);
- expTypeChecker.visit();
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
+ expTypeChecker.visit();
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
if (collector.hasError()) {
- throw new Exception("Error during type checking") ;
- }
+ throw new Exception("Error during type checking");
+ }
// Induction check
- assertEquals(DataType.BOOLEAN, lesser1.getType()) ;
- assertEquals(DataType.DOUBLE, bincond1.getType()) ;
+ assertEquals(DataType.BOOLEAN, lesser1.getType());
+ assertEquals(DataType.DOUBLE, bincond1.getType());
// Cast insertion check
- assertEquals(DataType.FLOAT, lesser1.getLhs().getType()) ;
- assertEquals(DataType.FLOAT, lesser1.getRhs().getType()) ;
- assertEquals(DataType.DOUBLE, bincond1.getLhs().getType()) ;
- assertEquals(DataType.DOUBLE, bincond1.getRhs().getType()) ;
+ assertEquals(DataType.FLOAT, lesser1.getLhs().getType());
+ assertEquals(DataType.FLOAT, lesser1.getRhs().getType());
+ assertEquals(DataType.DOUBLE, bincond1.getLhs().getType());
+ assertEquals(DataType.DOUBLE, bincond1.getRhs().getType());
}
@Test
public void testExpressionTypeChecking6() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan, "10") ;
- ConstantExpression constant2 = new ConstantExpression(plan, 20L) ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, "10");
+ ConstantExpression constant2 = new ConstantExpression(plan, 20L);
- AddExpression add1 = new AddExpression(plan, constant1, constant2) ;
+ AddExpression add1 = new AddExpression(plan, constant1, constant2);
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
LogicalRelationalOperator dummyRelOp = createDummyRelOpWithAlias();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, dummyRelOp);
try {
- expTypeChecker.visit();
- fail("Exception expected") ;
- }
- catch (TypeCheckerException pve) {
+ expTypeChecker.visit();
+ fail("Exception expected");
+ } catch (TypeCheckerException pve) {
String msg = "In alias dummy, incompatible types in " +
"Add Operator left hand side:chararray right hand side:long";
-
+
checkMessageInException(pve, msg);
}
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
if (!collector.hasError()) {
- throw new AssertionError("Error expected") ;
- }
+ throw new AssertionError("Error expected");
+ }
}
/**
- * @return a dummy logical relational operator
+ * @return a dummy logical relational operator
*/
private LogicalRelationalOperator createDummyRelOpWithAlias() {
class DummyRelOp extends LogicalRelationalOperator{
@@ -456,40 +453,40 @@ public class TestTypeCheckingValidatorNe
@Test
public void testExpressionTypeChecking7() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan, 10) ;
- ConstantExpression constant2 = new ConstantExpression(plan, 20D) ;
- ConstantExpression constant3 = new ConstantExpression(plan, 123L) ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, 10);
+ ConstantExpression constant2 = new ConstantExpression(plan, 20D);
+ ConstantExpression constant3 = new ConstantExpression(plan, 123L);
- GreaterThanExpression gt1 = new GreaterThanExpression(plan, constant1, constant2) ;
- EqualExpression equal1 = new EqualExpression(plan, gt1, constant3) ;
+ GreaterThanExpression gt1 = new GreaterThanExpression(plan, constant1, constant2);
+ EqualExpression equal1 = new EqualExpression(plan, gt1, constant3);
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
LogicalRelationalOperator dummyRelOp = createDummyRelOpWithAlias();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, dummyRelOp);
try {
- expTypeChecker.visit();
- fail("Exception expected") ;
+ expTypeChecker.visit();
+ fail("Exception expected");
}
catch (TypeCheckerException pve) {
// good
- }
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
+ }
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
if (!collector.hasError()) {
- throw new AssertionError("Error expected") ;
- }
+ throw new AssertionError("Error expected");
+ }
}
@Test
public void testExpressionTypeChecking8() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
TupleFactory tupleFactory = TupleFactory.getInstance();
- ArrayList<Object> innerObjList = new ArrayList<Object>();
- ArrayList<Object> objList = new ArrayList<Object>();
+ ArrayList<Object> innerObjList = new ArrayList<Object>();
+ ArrayList<Object> objList = new ArrayList<Object>();
innerObjList.add(10);
innerObjList.add(3);
@@ -531,28 +528,28 @@ public class TestTypeCheckingValidatorNe
Schema castSchema = new Schema(castFss);
- ConstantExpression constant1 = new ConstantExpression(plan, innerTuple) ;
- ConstantExpression constant2 = new ConstantExpression(plan, tuple) ;
+ ConstantExpression constant1 = new ConstantExpression(plan, innerTuple);
+ ConstantExpression constant2 = new ConstantExpression(plan, tuple);
CastExpression cast1 = new CastExpression(plan, constant1,
- org.apache.pig.newplan.logical.Util.translateFieldSchema(new FieldSchema(null, castSchema, DataType.TUPLE))) ;
+ org.apache.pig.newplan.logical.Util.translateFieldSchema(new FieldSchema(null, castSchema, DataType.TUPLE)));
- EqualExpression equal1 = new EqualExpression(plan, cast1, constant2) ;
+ EqualExpression equal1 = new EqualExpression(plan, cast1, constant2);
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
LogicalRelationalOperator dummyRelOp = createDummyRelOpWithAlias();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, dummyRelOp);
- expTypeChecker.visit();
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
+ expTypeChecker.visit();
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
if (collector.hasError()) {
- throw new Exception("Error during type checking") ;
- }
+ throw new Exception("Error during type checking");
+ }
- assertEquals(DataType.BOOLEAN, equal1.getType()) ;
- assertEquals(DataType.TUPLE, equal1.getRhs().getType()) ;
- assertEquals(DataType.TUPLE, equal1.getLhs().getType()) ;
+ assertEquals(DataType.BOOLEAN, equal1.getType());
+ assertEquals(DataType.TUPLE, equal1.getRhs().getType());
+ assertEquals(DataType.TUPLE, equal1.getLhs().getType());
}
/*
@@ -560,12 +557,12 @@ public class TestTypeCheckingValidatorNe
*/
@Test
public void testExpressionTypeChecking9() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
TupleFactory tupleFactory = TupleFactory.getInstance();
- ArrayList<Object> innerObjList = new ArrayList<Object>();
- ArrayList<Object> objList = new ArrayList<Object>();
+ ArrayList<Object> innerObjList = new ArrayList<Object>();
+ ArrayList<Object> objList = new ArrayList<Object>();
innerObjList.add("10");
innerObjList.add("3");
@@ -609,30 +606,25 @@ public class TestTypeCheckingValidatorNe
Schema castSchema = new Schema(castFss);
- ConstantExpression constant1 = new ConstantExpression(plan, innerTuple) ;
- ConstantExpression constant2 = new ConstantExpression(plan, tuple) ;
+ ConstantExpression constant1 = new ConstantExpression(plan, innerTuple);
+ ConstantExpression constant2 = new ConstantExpression(plan, tuple);
CastExpression cast1 = new CastExpression(plan, constant1,
- org.apache.pig.newplan.logical.Util.translateFieldSchema(new FieldSchema(null, castSchema, DataType.TUPLE))) ;
+ org.apache.pig.newplan.logical.Util.translateFieldSchema(new FieldSchema(null, castSchema, DataType.TUPLE)));
- EqualExpression equal1 = new EqualExpression(plan, cast1, constant2) ;
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ EqualExpression equal1 = new EqualExpression(plan, cast1, constant2);
+ CompilationMessageCollector collector = new CompilationMessageCollector();
LogicalRelationalOperator dummyRelOp = createDummyRelOpWithAlias();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, dummyRelOp);
- try {
- expTypeChecker.visit();
- }
- catch (TypeCheckerException pve) {
- fail("Exception not expected") ;
- }
+ expTypeChecker.visit();
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
if (collector.hasError()) {
- throw new Exception("Error expected") ;
- }
+ throw new Exception("Error expected");
+ }
}
-
+
@Test
public void testExpressionTypeChecking10() throws Throwable {
// test whether the equal and not equal operators can accept two boolean operands
@@ -653,7 +645,7 @@ public class TestTypeCheckingValidatorNe
plan.explain(System.out, "text", true);
printMessageCollector(collector);
- // printTypeGraph(plan) ;
+ // printTypeGraph(plan);
if (collector.hasError()) {
throw new Exception("Error during type checking");
@@ -669,7 +661,7 @@ public class TestTypeCheckingValidatorNe
assertEquals(DataType.BOOLEAN, equal1.getRhs().getType());
assertEquals(DataType.BOOLEAN, nq1.getRhs().getType());
}
-
+
@Test
public void testExpressionTypeCheckingFail10() throws Throwable {
// test whether the equal and not equal operators will reject the comparison between
@@ -681,7 +673,7 @@ public class TestTypeCheckingValidatorNe
GreaterThanExpression gt1 = new GreaterThanExpression(plan, constant1,
constant2);
- CastExpression cast1 = new CastExpression(plan, constant3, createFS(DataType.BYTEARRAY)) ;
+ CastExpression cast1 = new CastExpression(plan, constant3, createFS(DataType.BYTEARRAY));
EqualExpression equal1 = new EqualExpression(plan, gt1, cast1);
NotEqualExpression nq1 = new NotEqualExpression(plan, gt1, cast1);
@@ -696,7 +688,7 @@ public class TestTypeCheckingValidatorNe
// good
}
printMessageCollector(collector);
- // printTypeGraph(plan) ;
+ // printTypeGraph(plan);
if (!collector.hasError()) {
throw new Exception("Error during type checking");
@@ -728,7 +720,7 @@ public class TestTypeCheckingValidatorNe
plan.explain(System.out, "text", true);
printMessageCollector(collector);
- // printTypeGraph(plan) ;
+ // printTypeGraph(plan);
if (collector.hasError()) {
throw new Exception("Error during type checking");
@@ -746,7 +738,7 @@ public class TestTypeCheckingValidatorNe
assertEquals(DataType.DATETIME, gt1.getRhs().getType());
assertEquals(DataType.DATETIME, gte1.getRhs().getType());
}
-
+
@Test
public void testExpressionTypeCheckingFail11() throws Throwable {
// test whether conditional operators will reject the operation of one
@@ -754,7 +746,7 @@ public class TestTypeCheckingValidatorNe
LogicalExpressionPlan plan = new LogicalExpressionPlan();
ConstantExpression constant0 = new ConstantExpression(plan, new DateTime(0L));
ConstantExpression constant1 = new ConstantExpression(plan, new DataByteArray("1970-01-01T00:00:00.000Z"));
- CastExpression cast1 = new CastExpression(plan, constant1, createFS(DataType.BYTEARRAY)) ;
+ CastExpression cast1 = new CastExpression(plan, constant1, createFS(DataType.BYTEARRAY));
EqualExpression eq1 = new EqualExpression(plan, constant0, cast1);
CompilationMessageCollector collector = new CompilationMessageCollector();
@@ -768,7 +760,7 @@ public class TestTypeCheckingValidatorNe
// good
}
printMessageCollector(collector);
- // printTypeGraph(plan) ;
+ // printTypeGraph(plan);
if (!collector.hasError()) {
throw new Exception("Error during type checking");
@@ -777,471 +769,441 @@ public class TestTypeCheckingValidatorNe
@Test
public void testArithmeticOpCastInsert1() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan, 10) ;
- ConstantExpression constant2 = new ConstantExpression(plan, 20D) ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, 10);
+ ConstantExpression constant2 = new ConstantExpression(plan, 20D);
- MultiplyExpression mul1 = new MultiplyExpression(plan,constant1, constant2) ;
+ MultiplyExpression mul1 = new MultiplyExpression(plan,constant1, constant2);
// Before type checking its set correctly - PIG-421
-// System.out.println(DataType.findTypeName(mul1.getType())) ;
-// assertEquals(DataType.DOUBLE, mul1.getType()) ;
+ // System.out.println(DataType.findTypeName(mul1.getType()));
+ // assertEquals(DataType.DOUBLE, mul1.getType());
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, null);
- expTypeChecker.visit();
- printMessageCollector(collector) ;
+ expTypeChecker.visit();
+ printMessageCollector(collector);
- //printTypeGraph(plan) ;
+ //printTypeGraph(plan);
// After type checking
- System.out.println(DataType.findTypeName(mul1.getType())) ;
- assertEquals(DataType.DOUBLE, mul1.getType()) ;
+ System.out.println(DataType.findTypeName(mul1.getType()));
+ assertEquals(DataType.DOUBLE, mul1.getType());
}
@Test
public void testArithmeticOpCastInsert2() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan, 10) ;
- ConstantExpression constant2 = new ConstantExpression(plan, 20L) ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, 10);
+ ConstantExpression constant2 = new ConstantExpression(plan, 20L);
- NegativeExpression neg1 = new NegativeExpression(plan, constant1) ;
- SubtractExpression subtract1 = new SubtractExpression(plan, neg1, constant2) ;
+ NegativeExpression neg1 = new NegativeExpression(plan, constant1);
+ SubtractExpression subtract1 = new SubtractExpression(plan, neg1, constant2);
// Before type checking its set correctly = PIG-421
-// assertEquals(DataType.LONG, subtract1.getType()) ;
+ // assertEquals(DataType.LONG, subtract1.getType());
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, null);
- expTypeChecker.visit();
- printMessageCollector(collector) ;
+ expTypeChecker.visit();
+ printMessageCollector(collector);
- //printTypeGraph(plan) ;
+ //printTypeGraph(plan);
// After type checking
- System.out.println(DataType.findTypeName(subtract1.getType())) ;
- assertEquals(DataType.LONG, subtract1.getType()) ;
+ System.out.println(DataType.findTypeName(subtract1.getType()));
+ assertEquals(DataType.LONG, subtract1.getType());
assertTrue(subtract1.getLhs() instanceof CastExpression);
- assertEquals(((CastExpression)subtract1.getLhs()).getType(), DataType.LONG);
- assertTrue(((CastExpression)subtract1.getLhs()).getExpression() == neg1);
+ assertEquals(DataType.LONG, ((CastExpression)subtract1.getLhs()).getType());
+ assertEquals(neg1, ((CastExpression)subtract1.getLhs()).getExpression());
}
@Test
public void testModCastInsert1() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan, 10) ;
- ConstantExpression constant2 = new ConstantExpression(plan, 20L) ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, 10);
+ ConstantExpression constant2 = new ConstantExpression(plan, 20L);
- ModExpression mod1 = new ModExpression(plan, constant1, constant2) ;
+ ModExpression mod1 = new ModExpression(plan, constant1, constant2);
// Before type checking its set correctly = PIG-421
-// assertEquals(DataType.LONG, mod1.getType()) ;
+ // assertEquals(DataType.LONG, mod1.getType());
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, null);
- expTypeChecker.visit();
- printMessageCollector(collector) ;
+ expTypeChecker.visit();
+ printMessageCollector(collector);
- //printTypeGraph(plan) ;
+ //printTypeGraph(plan);
// After type checking
- System.out.println(DataType.findTypeName(mod1.getType())) ;
- assertEquals(DataType.LONG, mod1.getType()) ;
+ System.out.println(DataType.findTypeName(mod1.getType()));
+ assertEquals(DataType.LONG, mod1.getType());
assertTrue(mod1.getLhs() instanceof CastExpression);
- assertEquals(((CastExpression)mod1.getLhs()).getType(), DataType.LONG);
- assertTrue(((CastExpression)mod1.getLhs()).getExpression() == constant1);
+ assertEquals(DataType.LONG, ((CastExpression)mod1.getLhs()).getType());
+ assertEquals(constant1, ((CastExpression)mod1.getLhs()).getExpression());
}
-
-
+
+
// Positive case
@Test
public void testRegexTypeChecking1() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan, "10") ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, "10");
ConstantExpression constant2 = new ConstantExpression(plan, "Regex");
-
- RegexExpression regex = new RegexExpression(plan, constant1, constant2) ;
-
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+
+ RegexExpression regex = new RegexExpression(plan, constant1, constant2);
+
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, null);
- expTypeChecker.visit();
- printMessageCollector(collector) ;
-
- //printTypeGraph(plan) ;
-
+ expTypeChecker.visit();
+ printMessageCollector(collector);
+
+ //printTypeGraph(plan);
+
// After type checking
- System.out.println(DataType.findTypeName(regex.getType())) ;
- assertEquals(DataType.BOOLEAN, regex.getType()) ;
+ System.out.println(DataType.findTypeName(regex.getType()));
+ assertEquals(DataType.BOOLEAN, regex.getType());
}
-
+
// Positive case with cast insertion
@Test
public void testRegexTypeChecking2() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan,
- new DataByteArray()
- ) ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, new DataByteArray());
ConstantExpression constant2 = new ConstantExpression(plan, "Regex");
-
+
RegexExpression regex = new RegexExpression(plan, constant1, constant2);
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, null);
- expTypeChecker.visit();
- printMessageCollector(collector) ;
-
- //printTypeGraph(plan) ;
-
+ expTypeChecker.visit();
+ printMessageCollector(collector);
+
+ //printTypeGraph(plan);
+
// After type checking
-
+
if (collector.hasError()) {
- throw new Exception("Error not expected during type checking") ;
- }
-
+ throw new Exception("Error not expected during type checking");
+ }
+
// check type
- System.out.println(DataType.findTypeName(regex.getType())) ;
- assertEquals(DataType.BOOLEAN, regex.getType()) ;
-
- // check wiring
- CastExpression cast = (CastExpression) regex.getLhs() ;
- assertEquals(cast.getType(), DataType.CHARARRAY);
- assertEquals(cast.getExpression(), constant1) ;
+ System.out.println(DataType.findTypeName(regex.getType()));
+ assertEquals(DataType.BOOLEAN, regex.getType());
+
+ // check wiring
+ CastExpression cast = (CastExpression) regex.getLhs();
+ assertEquals(cast.getType(), DataType.CHARARRAY);
+ assertEquals(cast.getExpression(), constant1);
}
-
- // Negative case
- @Test
+
+ // Negative case
+ @Test(expected = TypeCheckerException.class)
public void testRegexTypeChecking3() throws Throwable {
- LogicalExpressionPlan plan = new LogicalExpressionPlan() ;
- ConstantExpression constant1 = new ConstantExpression(plan, 10) ;
+ LogicalExpressionPlan plan = new LogicalExpressionPlan();
+ ConstantExpression constant1 = new ConstantExpression(plan, 10);
ConstantExpression constant2 = new ConstantExpression(plan, "Regex");
-
+
RegexExpression regex = new RegexExpression(plan, constant1, constant2);
-
- try {
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
- TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, null);
- expTypeChecker.visit();
- printMessageCollector(collector) ;
- fail("Exception expected") ;
- }
- catch (TypeCheckerException pve) {
- // good
- }
-
+
+ CompilationMessageCollector collector = new CompilationMessageCollector();
+ TypeCheckingExpVisitor expTypeChecker = new TypeCheckingExpVisitor(plan, collector, null);
+ expTypeChecker.visit();
+ printMessageCollector(collector);
}
-
-
+
+
// This tests when both inputs need casting
@Test
public void testUnionCastingInsert1() throws Throwable {
-
+
printCurrentMethodName();
- LogicalPlan plan = new LogicalPlan() ;
-
- String pigStorage = PigStorage.class.getName() ;
-
+ LogicalPlan plan = new LogicalPlan();
+
+ String pigStorage = PigStorage.class.getName();
+
LOLoad load1 = newLOLoad(
new FileSpec("pi", new FuncSpec(pigStorage)),
null, plan, new Configuration(ConfigurationUtil.toConfiguration(pc.getFs().getConfiguration()))
);
-
+
LOLoad load2 = newLOLoad(
new FileSpec("pi", new FuncSpec(pigStorage)),
null, plan, new Configuration(ConfigurationUtil.toConfiguration(pc.getFs().getConfiguration()))
);
-//
-// new LOLoad(plan,
-//
-// new FileSpec("pi", new FuncSpec(pigStorage)),
-// null) ;
-// LOLoad load2 = new LOLoad(plan,
-//
-// new FileSpec("pi", new FuncSpec(pigStorage)),
-// null) ;
-//
+
// schema for input#1
- Schema inputSchema1 = null ;
+ Schema inputSchema1 = null;
{
- List<FieldSchema> fsList1 = new ArrayList<FieldSchema>() ;
- fsList1.add(new FieldSchema("field1a", DataType.INTEGER)) ;
- fsList1.add(new FieldSchema("field2a", DataType.LONG)) ;
- fsList1.add(new FieldSchema(null, DataType.BYTEARRAY)) ;
- fsList1.add(new FieldSchema(null, DataType.CHARARRAY)) ;
- inputSchema1 = new Schema(fsList1) ;
+ List<FieldSchema> fsList1 = new ArrayList<FieldSchema>();
+ fsList1.add(new FieldSchema("field1a", DataType.INTEGER));
+ fsList1.add(new FieldSchema("field2a", DataType.LONG));
+ fsList1.add(new FieldSchema(null, DataType.BYTEARRAY));
+ fsList1.add(new FieldSchema(null, DataType.CHARARRAY));
+ inputSchema1 = new Schema(fsList1);
}
-
+
// schema for input#2
- Schema inputSchema2 = null ;
+ Schema inputSchema2 = null;
{
- List<FieldSchema> fsList2 = new ArrayList<FieldSchema>() ;
- fsList2.add(new FieldSchema("field1b", DataType.DOUBLE)) ;
- fsList2.add(new FieldSchema(null, DataType.INTEGER)) ;
- fsList2.add(new FieldSchema("field3b", DataType.FLOAT)) ;
- fsList2.add(new FieldSchema("field4b", DataType.CHARARRAY)) ;
- inputSchema2 = new Schema(fsList2) ;
+ List<FieldSchema> fsList2 = new ArrayList<FieldSchema>();
+ fsList2.add(new FieldSchema("field1b", DataType.DOUBLE));
+ fsList2.add(new FieldSchema(null, DataType.INTEGER));
+ fsList2.add(new FieldSchema("field3b", DataType.FLOAT));
+ fsList2.add(new FieldSchema("field4b", DataType.CHARARRAY));
+ inputSchema2 = new Schema(fsList2);
}
-
+
// set schemas
load1.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema(inputSchema1));
load2.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema(inputSchema2));
-
+
// create union operator
- ArrayList<LogicalRelationalOperator> inputList = new ArrayList<LogicalRelationalOperator>() ;
- inputList.add(load1) ;
- inputList.add(load2) ;
- LOUnion union = new LOUnion(plan, false) ;
-
+ ArrayList<LogicalRelationalOperator> inputList = new ArrayList<LogicalRelationalOperator>();
+ inputList.add(load1);
+ inputList.add(load2);
+ LOUnion union = new LOUnion(plan, false);
+
// wiring
- plan.add(load1) ;
- plan.add(load2) ;
- plan.add(union) ;
-
+ plan.add(load1);
+ plan.add(load2);
+ plan.add(union);
+
plan.connect(load1, union);
plan.connect(load2, union);
-
+
// validate
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingRelVisitor typeChecker = new TypeCheckingRelVisitor(plan, collector);
- typeChecker.visit();
- printMessageCollector(collector) ;
-
+ typeChecker.visit();
+ printMessageCollector(collector);
+
// check end result schema
- Schema outputSchema = org.apache.pig.newplan.logical.Util.translateSchema(union.getSchema()) ;
-
- Schema expectedSchema = null ;
+ Schema outputSchema = org.apache.pig.newplan.logical.Util.translateSchema(union.getSchema());
+
+ Schema expectedSchema = null;
{
- List<FieldSchema> fsListExpected = new ArrayList<FieldSchema>() ;
- fsListExpected.add(new FieldSchema("field1a", DataType.DOUBLE)) ;
- fsListExpected.add(new FieldSchema("field2a", DataType.LONG)) ;
- fsListExpected.add(new FieldSchema("field3b", DataType.FLOAT)) ;
- fsListExpected.add(new FieldSchema("field4b", DataType.CHARARRAY)) ;
- expectedSchema = new Schema(fsListExpected) ;
- }
-
- assertTrue(Schema.equals(outputSchema, expectedSchema, true, false)) ;
-
- //printTypeGraph(plan) ;
-
+ List<FieldSchema> fsListExpected = new ArrayList<FieldSchema>();
+ fsListExpected.add(new FieldSchema("field1a", DataType.DOUBLE));
+ fsListExpected.add(new FieldSchema("field2a", DataType.LONG));
+ fsListExpected.add(new FieldSchema("field3b", DataType.FLOAT));
+ fsListExpected.add(new FieldSchema("field4b", DataType.CHARARRAY));
+ expectedSchema = new Schema(fsListExpected);
+ }
+
+ assertTrue(Schema.equals(outputSchema, expectedSchema, true, false));
+
+ //printTypeGraph(plan);
+
// check the inserted casting of input1
{
// Check wiring
List<Operator> sucList1 = plan.getSuccessors(load1);
- assertEquals(sucList1.size(), 1);
- LOForEach foreach = (LOForEach) sucList1.get(0) ;
- assertTrue(foreach instanceof LOForEach) ;
-
+ assertEquals(1, sucList1.size());
+ LOForEach foreach = (LOForEach) sucList1.get(0);
+ assertTrue(foreach instanceof LOForEach);
+
List<Operator> sucList2 = plan.getSuccessors(foreach);
- assertEquals(sucList2.size(), 1);
- assertTrue(sucList2.get(0) instanceof LOUnion) ;
-
+ assertEquals(1, sucList2.size());
+ assertTrue(sucList2.get(0) instanceof LOUnion);
+
// Check inserted casting
- checkForEachCasting(foreach, 0, true, DataType.DOUBLE) ;
- checkForEachCasting(foreach, 1, false, DataType.UNKNOWN) ;
- checkForEachCasting(foreach, 2, true, DataType.FLOAT) ;
- checkForEachCasting(foreach, 3, false, DataType.UNKNOWN) ;
-
+ checkForEachCasting(foreach, 0, true, DataType.DOUBLE);
+ checkForEachCasting(foreach, 1, false, DataType.UNKNOWN);
+ checkForEachCasting(foreach, 2, true, DataType.FLOAT);
+ checkForEachCasting(foreach, 3, false, DataType.UNKNOWN);
+
}
-
+
// check the inserted casting of input2
{
// Check wiring
- List<Operator> sucList1 = plan.getSuccessors(load2) ;
- assertEquals(sucList1.size(), 1);
- LOForEach foreach = (LOForEach) sucList1.get(0) ;
- assertTrue(foreach instanceof LOForEach) ;
-
- List<Operator> sucList2 = plan.getSuccessors(foreach) ;
- assertEquals(sucList2.size(), 1);
- assertTrue(sucList2.get(0) instanceof LOUnion) ;
-
+ List<Operator> sucList1 = plan.getSuccessors(load2);
+ assertEquals(1, sucList1.size());
+ LOForEach foreach = (LOForEach) sucList1.get(0);
+ assertTrue(foreach instanceof LOForEach);
+
+ List<Operator> sucList2 = plan.getSuccessors(foreach);
+ assertEquals(1, sucList2.size());
+ assertTrue(sucList2.get(0) instanceof LOUnion);
+
// Check inserted casting
- checkForEachCasting(foreach, 0, false, DataType.UNKNOWN) ;
- checkForEachCasting(foreach, 1, true, DataType.LONG) ;
- checkForEachCasting(foreach, 2, false, DataType.UNKNOWN) ;
- checkForEachCasting(foreach, 3, false, DataType.UNKNOWN) ;
-
+ checkForEachCasting(foreach, 0, false, DataType.UNKNOWN);
+ checkForEachCasting(foreach, 1, true, DataType.LONG);
+ checkForEachCasting(foreach, 2, false, DataType.UNKNOWN);
+ checkForEachCasting(foreach, 3, false, DataType.UNKNOWN);
}
-
}
-
-
+
// This tests when both only on input needs casting
@Test
public void testUnionCastingInsert2() throws Throwable {
-
+
printCurrentMethodName();
- LogicalPlan plan = new LogicalPlan() ;
-
- String pigStorage = PigStorage.class.getName() ;
-
-
+ LogicalPlan plan = new LogicalPlan();
+
+ String pigStorage = PigStorage.class.getName();
+
+
LOLoad load1 = newLOLoad(
new FileSpec("pi", new FuncSpec(pigStorage)),
null, plan, new Configuration(ConfigurationUtil.toConfiguration(pc.getFs().getConfiguration()))
);
-
+
LOLoad load2 = newLOLoad(
new FileSpec("pi", new FuncSpec(pigStorage)),
null, plan, new Configuration(ConfigurationUtil.toConfiguration(pc.getFs().getConfiguration()))
);
-
+
// schema for input#1
- Schema inputSchema1 = null ;
+ Schema inputSchema1 = null;
{
- List<FieldSchema> fsList1 = new ArrayList<FieldSchema>() ;
- fsList1.add(new FieldSchema("field1a", DataType.INTEGER)) ;
- fsList1.add(new FieldSchema("field2a", DataType.BYTEARRAY)) ;
- inputSchema1 = new Schema(fsList1) ;
+ List<FieldSchema> fsList1 = new ArrayList<FieldSchema>();
+ fsList1.add(new FieldSchema("field1a", DataType.INTEGER));
+ fsList1.add(new FieldSchema("field2a", DataType.BYTEARRAY));
+ inputSchema1 = new Schema(fsList1);
}
-
+
// schema for input#2
- Schema inputSchema2 = null ;
+ Schema inputSchema2 = null;
{
- List<FieldSchema> fsList2 = new ArrayList<FieldSchema>() ;
- fsList2.add(new FieldSchema("field1b", DataType.DOUBLE)) ;
- fsList2.add(new FieldSchema("field2b", DataType.DOUBLE)) ;
- inputSchema2 = new Schema(fsList2) ;
+ List<FieldSchema> fsList2 = new ArrayList<FieldSchema>();
+ fsList2.add(new FieldSchema("field1b", DataType.DOUBLE));
+ fsList2.add(new FieldSchema("field2b", DataType.DOUBLE));
+ inputSchema2 = new Schema(fsList2);
}
-
+
// set schemas
load1.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema(inputSchema1));
load2.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema(inputSchema2));
-
-
-
+
// create union operator
- ArrayList<LogicalRelationalOperator> inputList = new ArrayList<LogicalRelationalOperator>() ;
- inputList.add(load1) ;
- inputList.add(load2) ;
- LOUnion union = new LOUnion(plan, false) ;
+ ArrayList<LogicalRelationalOperator> inputList = new ArrayList<LogicalRelationalOperator>();
+ inputList.add(load1);
+ inputList.add(load2);
+ LOUnion union = new LOUnion(plan, false);
// wiring
- plan.add(load1) ;
- plan.add(load2) ;
- plan.add(union) ;
-
+ plan.add(load1);
+ plan.add(load2);
+ plan.add(union);
+
plan.connect(load1, union);
plan.connect(load2, union);
-
-
+
// validate
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingRelVisitor typeChecker = new TypeCheckingRelVisitor(plan, collector);
- typeChecker.visit();
- printMessageCollector(collector) ;
-
+ typeChecker.visit();
+ printMessageCollector(collector);
+
// check end result schema
- Schema outputSchema = org.apache.pig.newplan.logical.Util.translateSchema(union.getSchema()) ;
-
- Schema expectedSchema = null ;
+ Schema outputSchema = org.apache.pig.newplan.logical.Util.translateSchema(union.getSchema());
+
+ Schema expectedSchema = null;
{
- List<FieldSchema> fsListExpected = new ArrayList<FieldSchema>() ;
- fsListExpected.add(new FieldSchema("field1a", DataType.DOUBLE)) ;
- fsListExpected.add(new FieldSchema("field2a", DataType.DOUBLE)) ;
- expectedSchema = new Schema(fsListExpected) ;
- }
-
- assertTrue(Schema.equals(outputSchema, expectedSchema, true, false)) ;
-
- //printTypeGraph(plan) ;
-
+ List<FieldSchema> fsListExpected = new ArrayList<FieldSchema>();
+ fsListExpected.add(new FieldSchema("field1a", DataType.DOUBLE));
+ fsListExpected.add(new FieldSchema("field2a", DataType.DOUBLE));
+ expectedSchema = new Schema(fsListExpected);
+ }
+
+ assertTrue(Schema.equals(outputSchema, expectedSchema, true, false));
+
+ //printTypeGraph(plan);
+
// check the inserted casting of input1
{
// Check wiring
List<Operator> sucList1 = plan.getSuccessors(load1);
- assertEquals(sucList1.size(), 1);
- LOForEach foreach = (LOForEach) sucList1.get(0) ;
- assertTrue(foreach instanceof LOForEach) ;
+ assertEquals(1, sucList1.size());
+ LOForEach foreach = (LOForEach) sucList1.get(0);
+ assertTrue(foreach instanceof LOForEach);
List<Operator> sucList2 = plan.getSuccessors(foreach);
- assertEquals(sucList2.size(), 1);
- assertTrue(sucList2.get(0) instanceof LOUnion) ;
+ assertEquals(1, sucList2.size());
+ assertTrue(sucList2.get(0) instanceof LOUnion);
// Check inserted casting
- checkForEachCasting(foreach, 0, true, DataType.DOUBLE) ;
- checkForEachCasting(foreach, 1, true, DataType.DOUBLE) ;
+ checkForEachCasting(foreach, 0, true, DataType.DOUBLE);
+ checkForEachCasting(foreach, 1, true, DataType.DOUBLE);
}
-
+
// check the inserted casting of input2
{
// Check wiring
List<Operator> sucList1 = plan.getSuccessors(load2);
- assertEquals(sucList1.size(), 1);
- assertTrue(sucList1.get(0) instanceof LOUnion) ;
+ assertEquals(1, sucList1.size());
+ assertTrue(sucList1.get(0) instanceof LOUnion);
}
-
}
-
-
@Test
public void testDistinct1() throws Throwable {
-
printCurrentMethodName();
- LogicalPlan plan = new LogicalPlan() ;
-
- String pigStorage = PigStorage.class.getName() ;
-
+ LogicalPlan plan = new LogicalPlan();
+
+ String pigStorage = PigStorage.class.getName();
+
LOLoad load1 = newLOLoad(
new FileSpec("pi", new FuncSpec(pigStorage)),
null, plan, new Configuration(ConfigurationUtil.toConfiguration(pc.getFs().getConfiguration()))
);
-
+
// schema for input#1
- Schema inputSchema1 = null ;
+ Schema inputSchema1 = null;
{
- List<FieldSchema> innerList = new ArrayList<FieldSchema>() ;
- innerList.add(new FieldSchema("innerfield1", DataType.BAG)) ;
- innerList.add(new FieldSchema("innerfield2", DataType.FLOAT)) ;
- Schema innerSchema = new Schema(innerList) ;
-
- List<FieldSchema> fsList1 = new ArrayList<FieldSchema>() ;
- fsList1.add(new FieldSchema("field1", DataType.INTEGER)) ;
- fsList1.add(new FieldSchema("field2", DataType.BYTEARRAY)) ;
- fsList1.add(new FieldSchema("field3", innerSchema)) ;
- fsList1.add(new FieldSchema("field4", DataType.BAG)) ;
-
- inputSchema1 = new Schema(fsList1) ;
+ List<FieldSchema> innerList = new ArrayList<FieldSchema>();
+ innerList.add(new FieldSchema("innerfield1", DataType.BAG));
+ innerList.add(new FieldSchema("innerfield2", DataType.FLOAT));
+ Schema innerSchema = new Schema(innerList);
+
+ List<FieldSchema> fsList1 = new ArrayList<FieldSchema>();
+ fsList1.add(new FieldSchema("field1", DataType.INTEGER));
+ fsList1.add(new FieldSchema("field2", DataType.BYTEARRAY));
+ fsList1.add(new FieldSchema("field3", innerSchema));
+ fsList1.add(new FieldSchema("field4", DataType.BAG));
+
+ inputSchema1 = new Schema(fsList1);
}
-
+
// set schemas
- load1.setSchema(org.apache.pig.newplan.logical.Util.translateSchema(inputSchema1)) ;
-
+ load1.setSchema(org.apache.pig.newplan.logical.Util.translateSchema(inputSchema1));
+
// create union operator
- LODistinct distinct1 = new LODistinct(plan) ;
-
+ LODistinct distinct1 = new LODistinct(plan);
+
// wiring
- plan.add(load1) ;
- plan.add(distinct1) ;
-
+ plan.add(load1);
+ plan.add(distinct1);
+
plan.connect(load1, distinct1);
-
+
// validate
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingRelVisitor typeChecker = new TypeCheckingRelVisitor(plan, collector);
- typeChecker.visit();
- printMessageCollector(collector) ;
-
+ typeChecker.visit();
+ printMessageCollector(collector);
+
// check end result schema
- LogicalSchema outputSchema = distinct1.getSchema() ;
+ LogicalSchema outputSchema = distinct1.getSchema();
assertTrue(load1.getSchema().isEqual(outputSchema));
-
-
}
// Positive test
@Test
public void testFilterWithInnerPlan1() throws Throwable {
- testFilterWithInnerPlan(DataType.INTEGER, DataType.LONG) ;
+ testFilterWithInnerPlan(DataType.INTEGER, DataType.LONG);
}
// Positive test
@Test
public void testFilterWithInnerPlan2() throws Throwable {
- testFilterWithInnerPlan(DataType.INTEGER, DataType.BYTEARRAY) ;
+ testFilterWithInnerPlan(DataType.INTEGER, DataType.BYTEARRAY);
}
// Filter test helper
@@ -1249,60 +1211,55 @@ public class TestTypeCheckingValidatorNe
// Create outer plan
printCurrentMethodName();
- LogicalPlan plan = new LogicalPlan() ;
+ LogicalPlan plan = new LogicalPlan();
- String pigStorage = PigStorage.class.getName() ;
+ String pigStorage = PigStorage.class.getName();
LOLoad load1 = newLOLoad(
new FileSpec("pi", new FuncSpec(pigStorage)),
null, plan, new Configuration(ConfigurationUtil.toConfiguration(pc.getFs().getConfiguration()))
);
// schema for input#1
- Schema inputSchema1 = null ;
+ Schema inputSchema1 = null;
{
- List<FieldSchema> fsList1 = new ArrayList<FieldSchema>() ;
- fsList1.add(new FieldSchema("field1", field1Type)) ;
- fsList1.add(new FieldSchema("field2", field2Type)) ;
+ List<FieldSchema> fsList1 = new ArrayList<FieldSchema>();
+ fsList1.add(new FieldSchema("field1", field1Type));
+ fsList1.add(new FieldSchema("field2", field2Type));
- inputSchema1 = new Schema(fsList1) ;
+ inputSchema1 = new Schema(fsList1);
}
// set schemas
- load1.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema(inputSchema1)) ;
+ load1.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema(inputSchema1));
// Create inner plan
- LogicalExpressionPlan innerPlan = new LogicalExpressionPlan() ;
+ LogicalExpressionPlan innerPlan = new LogicalExpressionPlan();
// filter
- LOFilter filter1 = new LOFilter(plan) ;
+ LOFilter filter1 = new LOFilter(plan);
filter1.setFilterPlan(innerPlan);
-
+
ProjectExpression project1 = new ProjectExpression(innerPlan, 0, 0, filter1);
-
-// new ProjectExpression(innerPlan, load1, 0) ;
- // project1.setSentinel(true);
- ProjectExpression project2 = new ProjectExpression(innerPlan, 0, 1, filter1);
- //new ProjectExpression(innerPlan, load1, 1) ;
- //project2.setSentinel(true);
+ ProjectExpression project2 = new ProjectExpression(innerPlan, 0, 1, filter1);
GreaterThanExpression gt1 = new GreaterThanExpression(innerPlan, project1, project2);
-
+
plan.add(load1);
plan.add(filter1);
- plan.connect(load1, filter1) ;
+ plan.connect(load1, filter1);
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingRelVisitor typeChecker = new TypeCheckingRelVisitor(plan, collector);
- typeChecker.visit();
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
+ typeChecker.visit();
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
if (collector.hasError()) {
- throw new AssertionError("Expect no error") ;
+ throw new AssertionError("Expect no error");
}
- LogicalSchema endResultSchema = filter1.getSchema() ;
- assertEquals(endResultSchema.getField(0).type, field1Type) ;
- assertEquals(endResultSchema.getField(1).type, field2Type) ;
+ LogicalSchema endResultSchema = filter1.getSchema();
+ assertEquals(endResultSchema.getField(0).type, field1Type);
+ assertEquals(endResultSchema.getField(1).type, field2Type);
}
@@ -1312,146 +1269,145 @@ public class TestTypeCheckingValidatorNe
// Create outer plan
printCurrentMethodName();
- LogicalPlan plan = new LogicalPlan() ;
+ LogicalPlan plan = new LogicalPlan();
- String pigStorage = PigStorage.class.getName() ;
+ String pigStorage = PigStorage.class.getName();
LOLoad load1 = newLOLoad(
new FileSpec("pi", new FuncSpec(pigStorage)),
null, plan, new Configuration(ConfigurationUtil.toConfiguration(pc.getFs().getConfiguration()))
);
-
+
// schema for input#1
- Schema inputSchema1 = null ;
+ Schema inputSchema1 = null;
{
- List<FieldSchema> fsList1 = new ArrayList<FieldSchema>() ;
- fsList1.add(new FieldSchema("field1", DataType.INTEGER)) ;
- fsList1.add(new FieldSchema("field2", DataType.LONG)) ;
+ List<FieldSchema> fsList1 = new ArrayList<FieldSchema>();
+ fsList1.add(new FieldSchema("field1", DataType.INTEGER));
+ fsList1.add(new FieldSchema("field2", DataType.LONG));
- inputSchema1 = new Schema(fsList1) ;
+ inputSchema1 = new Schema(fsList1);
}
// set schemas
- load1.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema((inputSchema1))) ;
+ load1.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema((inputSchema1)));
// Create inner plan
- LogicalExpressionPlan innerPlan = new LogicalExpressionPlan() ;
-
+ LogicalExpressionPlan innerPlan = new LogicalExpressionPlan();
+
// filter
- LOFilter filter1 = new LOFilter(plan) ;
+ LOFilter filter1 = new LOFilter(plan);
filter1.setFilterPlan(innerPlan);
-
- ProjectExpression project1 = new ProjectExpression(innerPlan, 0, 0, filter1) ;
- ProjectExpression project2 = new ProjectExpression(innerPlan, 0, 1, filter1) ;
- AddExpression add1 = new AddExpression(innerPlan, project1, project2) ;
+ ProjectExpression project1 = new ProjectExpression(innerPlan, 0, 0, filter1);
+ ProjectExpression project2 = new ProjectExpression(innerPlan, 0, 1, filter1);
+
+ AddExpression add1 = new AddExpression(innerPlan, project1, project2);
plan.add(load1);
plan.add(filter1);
- plan.connect(load1, filter1) ;
+ plan.connect(load1, filter1);
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingRelVisitor typeChecker = new TypeCheckingRelVisitor(plan, collector);
try {
- typeChecker.visit();
- }
- catch (Exception t) {
+ typeChecker.visit();
+ } catch (Exception t) {
// good
}
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
if (!collector.hasError()) {
- throw new AssertionError("Expect error") ;
+ throw new AssertionError("Expect error");
}
}
-
-
+
+
// Simple project sort columns
@Test
public void testSortWithInnerPlan1() throws Throwable {
-
+
// Create outer plan
printCurrentMethodName();
- LogicalPlan plan = new LogicalPlan() ;
-
- String pigStorage = PigStorage.class.getName() ;
-
+ LogicalPlan plan = new LogicalPlan();
+
+ String pigStorage = PigStorage.class.getName();
+
LOLoad load1 = newLOLoad(
new FileSpec("pi", new FuncSpec(pigStorage)),
null, plan, new Configuration(ConfigurationUtil.toConfiguration(pc.getFs().getConfiguration()))
);
-
+
// schema for input#1
- Schema inputSchema1 = null ;
+ Schema inputSchema1 = null;
{
- List<FieldSchema> fsList1 = new ArrayList<FieldSchema>() ;
- fsList1.add(new FieldSchema("field1", DataType.LONG)) ;
- fsList1.add(new FieldSchema("field2", DataType.INTEGER)) ;
-
- inputSchema1 = new Schema(fsList1) ;
+ List<FieldSchema> fsList1 = new ArrayList<FieldSchema>();
+ fsList1.add(new FieldSchema("field1", DataType.LONG));
+ fsList1.add(new FieldSchema("field2", DataType.INTEGER));
+
+ inputSchema1 = new Schema(fsList1);
}
-
+
// set schemas
- load1.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema((inputSchema1))) ; ;
-
+ load1.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema((inputSchema1)));;
+
// Create project inner plan #1
- LogicalExpressionPlan innerPlan1 = new LogicalExpressionPlan() ;
+ LogicalExpressionPlan innerPlan1 = new LogicalExpressionPlan();
// Sort
LOSort sort1 = new LOSort(plan);
- ProjectExpression project1 = new ProjectExpression(innerPlan1, 0, 1, sort1) ;
-
- innerPlan1.add(project1) ;
-
+ ProjectExpression project1 = new ProjectExpression(innerPlan1, 0, 1, sort1);
+
+ innerPlan1.add(project1);
+
// Create project inner plan #2
- LogicalExpressionPlan innerPlan2 = new LogicalExpressionPlan() ;
- ProjectExpression project2 = new ProjectExpression(innerPlan2, 0, 0, sort1) ;
-
- innerPlan2.add(project2) ;
-
+ LogicalExpressionPlan innerPlan2 = new LogicalExpressionPlan();
+ ProjectExpression project2 = new ProjectExpression(innerPlan2, 0, 0, sort1);
+
+ innerPlan2.add(project2);
+
// List of innerplans
- List<LogicalExpressionPlan> innerPlans = new ArrayList<LogicalExpressionPlan>() ;
- innerPlans.add(innerPlan1) ;
- innerPlans.add(innerPlan2) ;
-
+ List<LogicalExpressionPlan> innerPlans = new ArrayList<LogicalExpressionPlan>();
+ innerPlans.add(innerPlan1);
+ innerPlans.add(innerPlan2);
+
// List of ASC flags
- List<Boolean> ascList = new ArrayList<Boolean>() ;
+ List<Boolean> ascList = new ArrayList<Boolean>();
ascList.add(true);
ascList.add(true);
-
+
sort1.setAscendingCols(ascList);
sort1.setSortColPlans(innerPlans);
-
+
plan.add(load1);
plan.add(sort1);
- plan.connect(load1, sort1) ;
-
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ plan.connect(load1, sort1);
+
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingRelVisitor typeChecker = new TypeCheckingRelVisitor(plan, collector);
- typeChecker.visit();
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
-
+ typeChecker.visit();
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
+
if (collector.hasError()) {
- throw new AssertionError("Expect no error") ;
+ throw new AssertionError("Expect no error");
}
-
- LogicalSchema endResultSchema = sort1.getSchema() ;
-
+
+ LogicalSchema endResultSchema = sort1.getSchema();
+
// outer
- assertEquals(endResultSchema.getField(0).type, DataType.LONG) ;
- assertEquals(endResultSchema.getField(1).type, DataType.INTEGER) ;
-
+ assertEquals(DataType.LONG, endResultSchema.getField(0).type);
+ assertEquals(DataType.INTEGER, endResultSchema.getField(1).type);
+
// inner
- assertEquals(getSingleOutput(innerPlan1).getType(), DataType.INTEGER);
- assertEquals(getSingleOutput(innerPlan2).getType(), DataType.LONG);
-
- }
-
-
-
+ assertEquals(DataType.INTEGER, getSingleOutput(innerPlan1).getType());
+ assertEquals(DataType.LONG, getSingleOutput(innerPlan2).getType());
+
+ }
+
+
+
private LogicalExpression getSingleOutput(LogicalExpressionPlan innerPlan1) {
List<Operator> outputs = innerPlan1.getSources();
assertEquals("number of outputs in exp plan", outputs.size(),1);
@@ -1461,180 +1417,176 @@ public class TestTypeCheckingValidatorNe
// Positive expression sort columns
@Test
public void testSortWithInnerPlan2() throws Throwable {
-
+
// Create outer plan
printCurrentMethodName();
- LogicalPlan plan = new LogicalPlan() ;
-
- String pigStorage = PigStorage.class.getName() ;
-
+ LogicalPlan plan = new LogicalPlan();
+
+ String pigStorage = PigStorage.class.getName();
+
LOLoad load1 = newLOLoad(
new FileSpec("pi", new FuncSpec(pigStorage)),
null, plan, new Configuration(ConfigurationUtil.toConfiguration(pc.getFs().getConfiguration()))
);
// schema for input#1
- Schema inputSchema1 = null ;
+ Schema inputSchema1 = null;
{
- List<FieldSchema> fsList1 = new ArrayList<FieldSchema>() ;
- fsList1.add(new FieldSchema("field1", DataType.BYTEARRAY)) ;
- fsList1.add(new FieldSchema("field2", DataType.INTEGER)) ;
-
- inputSchema1 = new Schema(fsList1) ;
+ List<FieldSchema> fsList1 = new ArrayList<FieldSchema>();
+ fsList1.add(new FieldSchema("field1", DataType.BYTEARRAY));
+ fsList1.add(new FieldSchema("field2", DataType.INTEGER));
+
+ inputSchema1 = new Schema(fsList1);
}
-
+
// set schemas
- load1.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema((inputSchema1))) ; ;
-
- LOSort sort1 = new LOSort(plan) ;
+ load1.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema((inputSchema1)));;
+
+ LOSort sort1 = new LOSort(plan);
+
-
// Create expression inner plan #1
- LogicalExpressionPlan innerPlan1 = new LogicalExpressionPlan() ;
- ProjectExpression project11 = new ProjectExpression(innerPlan1, 0, 0, sort1) ;
- ProjectExpression project12 = new ProjectExpression(innerPlan1, 0, 1, sort1) ;
-
- MultiplyExpression mul1 = new MultiplyExpression(innerPlan1, project11, project12) ;
-
+ LogicalExpressionPlan innerPlan1 = new LogicalExpressionPlan();
+ ProjectExpression project11 = new ProjectExpression(innerPlan1, 0, 0, sort1);
+ ProjectExpression project12 = new ProjectExpression(innerPlan1, 0, 1, sort1);
+
+ MultiplyExpression mul1 = new MultiplyExpression(innerPlan1, project11, project12);
+
// Create expression inner plan #2
- LogicalExpressionPlan innerPlan2 = new LogicalExpressionPlan() ;
- ProjectExpression project21 = new ProjectExpression(innerPlan2, 0, 0, sort1) ;
+ LogicalExpressionPlan innerPlan2 = new LogicalExpressionPlan();
+ ProjectExpression project21 = new ProjectExpression(innerPlan2, 0, 0, sort1);
+
+ ConstantExpression const21 = new ConstantExpression(innerPlan2, 26L);
+ ModExpression mod21 = new ModExpression(innerPlan2, project21, const21);
- ConstantExpression const21 = new ConstantExpression(innerPlan2, 26L) ;
- ModExpression mod21 = new ModExpression(innerPlan2, project21, const21) ;
-
// List of innerplans
- List<LogicalExpressionPlan> innerPlans = new ArrayList<LogicalExpressionPlan>() ;
- innerPlans.add(innerPlan1) ;
- innerPlans.add(innerPlan2) ;
-
+ List<LogicalExpressionPlan> innerPlans = new ArrayList<LogicalExpressionPlan>();
+ innerPlans.add(innerPlan1);
+ innerPlans.add(innerPlan2);
+
// List of ASC flags
- List<Boolean> ascList = new ArrayList<Boolean>() ;
+ List<Boolean> ascList = new ArrayList<Boolean>();
ascList.add(true);
ascList.add(true);
-
+
// Sort
sort1.setAscendingCols(ascList);
sort1.setSortColPlans(innerPlans);
-
+
plan.add(load1);
plan.add(sort1);
- plan.connect(load1, sort1) ;
-
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ plan.connect(load1, sort1);
+
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingRelVisitor typeChecker = new TypeCheckingRelVisitor(plan, collector);
- typeChecker.visit();
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
-
+ typeChecker.visit();
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
+
if (collector.hasError()) {
- throw new AssertionError("Expect no error") ;
+ throw new AssertionError("Expect no error");
}
-
- LogicalSchema endResultSchema = sort1.getSchema() ;
-
+
+ LogicalSchema endResultSchema = sort1.getSchema();
+
// outer
- assertEquals(endResultSchema.getField(0).type, DataType.BYTEARRAY) ;
- assertEquals(endResultSchema.getField(1).type, DataType.INTEGER) ;
-
+ assertEquals(DataType.BYTEARRAY, endResultSchema.getField(0).type);
+ assertEquals(DataType.INTEGER, endResultSchema.getField(1).type);
+
// inner
- assertEquals(getSingleOutput(innerPlan1).getType(), DataType.INTEGER);
- assertEquals(getSingleOutput(innerPlan2).getType(), DataType.LONG);
-
+ assertEquals(DataType.INTEGER, getSingleOutput(innerPlan1).getType());
+ assertEquals(DataType.LONG, getSingleOutput(innerPlan2).getType());
+
}
-
+
// Negative test on expression sort columns
@Test
public void testSortWithInnerPlan3() throws Throwable {
-
+
// Create outer plan
printCurrentMethodName();
- LogicalPlan plan = new LogicalPlan() ;
-
- String pigStorage = PigStorage.class.getName() ;
-
+ LogicalPlan plan = new LogicalPlan();
+
+ String pigStorage = PigStorage.class.getName();
+
LOLoad load1 = newLOLoad(
new FileSpec("pi", new FuncSpec(pigStorage)),
null, plan, new Configuration(ConfigurationUtil.toConfiguration(pc.getFs().getConfiguration()))
);
-
+
// schema for input#1
- Schema inputSchema1 = null ;
+ Schema inputSchema1 = null;
{
- List<FieldSchema> fsList1 = new ArrayList<FieldSchema>() ;
- fsList1.add(new FieldSchema("field1", DataType.BYTEARRAY)) ;
- fsList1.add(new FieldSchema("field2", DataType.INTEGER)) ;
-
- inputSchema1 = new Schema(fsList1) ;
+ List<FieldSchema> fsList1 = new ArrayList<FieldSchema>();
+ fsList1.add(new FieldSchema("field1", DataType.BYTEARRAY));
+ fsList1.add(new FieldSchema("field2", DataType.INTEGER));
+
+ inputSchema1 = new Schema(fsList1);
}
-
+
// set schemas
- load1.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema((inputSchema1))) ; ;
-
-
+ load1.setScriptSchema(org.apache.pig.newplan.logical.Util.translateSchema((inputSchema1)));;
+
+
// Sort
- LOSort sort1 = new LOSort(plan) ;
-
+ LOSort sort1 = new LOSort(plan);
+
// Create expression inner plan #1
- LogicalExpressionPlan innerPlan1 = new LogicalExpressionPlan() ;
- ProjectExpression project11 = new ProjectExpression(innerPlan1, 0, 0, sort1) ;
- ProjectExpression project12 = new ProjectExpression(innerPlan1, 0, 1, sort1) ;
- MultiplyExpression mul1 = new MultiplyExpression(innerPlan1, project11, project12) ;
+ LogicalExpressionPlan innerPlan1 = new LogicalExpressionPlan();
+ ProjectExpression project11 = new ProjectExpression(innerPlan1, 0, 0, sort1);
+ ProjectExpression project12 = new ProjectExpression(innerPlan1, 0, 1, sort1);
+ MultiplyExpression mul1 = new MultiplyExpression(innerPlan1, project11, project12);
+
-
// Create expression inner plan #2
- LogicalExpressionPlan innerPlan2 = new LogicalExpressionPlan() ;
- ProjectExpression project21 = new ProjectExpression(innerPlan2, 0, 0, sort1) ;
- ConstantExpression const21 = new ConstantExpression(innerPlan2, "26") ;
- ModExpression mod21 = new ModExpression(innerPlan2, project21, const21) ;
-
+ LogicalExpressionPlan innerPlan2 = new LogicalExpressionPlan();
+ ProjectExpression project21 = new ProjectExpression(innerPlan2, 0, 0, sort1);
+ ConstantExpression const21 = new ConstantExpression(innerPlan2, "26");
+ ModExpression mod21 = new ModExpression(innerPlan2, project21, const21);
+
// List of innerplans
- List<LogicalExpressionPlan> innerPlans = new ArrayList<LogicalExpressionPlan>() ;
- innerPlans.add(innerPlan1) ;
- innerPlans.add(innerPlan2) ;
-
+ List<LogicalExpressionPlan> innerPlans = new ArrayList<LogicalExpressionPlan>();
+ innerPlans.add(innerPlan1);
+ innerPlans.add(innerPlan2);
+
// List of ASC flags
- List<Boolean> ascList = new ArrayList<Boolean>() ;
+ List<Boolean> ascList = new ArrayList<Boolean>();
ascList.add(true);
ascList.add(true);
// Sort
sort1.setAscendingCols(ascList);
sort1.setSortColPlans(innerPlans);
-
+
plan.add(load1);
plan.add(sort1);
- plan.connect(load1, sort1) ;
-
- CompilationMessageCollector collector = new CompilationMessageCollector() ;
+ plan.connect(load1, sort1);
+
+ CompilationMessageCollector collector = new CompilationMessageCollector();
TypeCheckingRelVisitor typeChecker = new TypeCheckingRelVisitor(plan, collector);
try {
- typeChecker.visit();
- fail("Error expected") ;
- }
- catch (Exception t) {
+ typeChecker.visit();
+ fail("Error expected");
+ } catch (Exception t) {
// good
}
- printMessageCollector(collector) ;
- //printTypeGraph(plan) ;
-
+ printMessageCollector(collector);
+ //printTypeGraph(plan);
+
if (!collector.hasError()) {
- throw new AssertionError("Error expected") ;
+ throw new AssertionError("Error expected");
}
-
}
-
// Positive expression cond columns
@Test
[... 3585 lines stripped ...]