Clearer definition of implicit type cast.

Author: rxin

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/HiveTypeCoercion.scala

@@ -723,26 +723,28 @@ object HiveTypeCoercion {
      * If the implicit cast is not allowed, return the expression itself.
      */
     def implicitCast(e: Expression, expectedType: AbstractDataType): Expression = {
-      (e, expectedType) match {
+      val inType = e.dataType
+      (inType, expectedType) match {
         // Cast null type (usually from null literals) into target types
-        case (in @ NullType(), target: DataType) => Cast(in, target.defaultConcreteType)
+        case (NullType, target: DataType) => Cast(e, target.defaultConcreteType)
 
         // Implicit cast among numeric types
-        case (in @ NumericType(), target: NumericType) if in.dataType != target =>
-          Cast(in, target)
+        case (_: NumericType, target: NumericType) if e.dataType != target => Cast(e, target)
 
         // Implicit cast between date time types
-        case (in @ DateType(), TimestampType) => Cast(in, TimestampType)
-        case (in @ TimestampType(), DateType) => Cast(in, DateType)
+        case (DateType, TimestampType) => Cast(e, TimestampType)
+        case (TimestampType, DateType) => Cast(e, DateType)
 
-        // Implicit from string to atomic types, and vice versa
-        case (in @ StringType(), target: AtomicType) if target != StringType =>
-          Cast(in, target.defaultConcreteType)
-        case (in, StringType) if in.dataType != StringType =>
-          Cast(in, StringType)
+        // Implicit cast from/to string
+        case (StringType, NumericType) => Cast(e, DoubleType)
+        case (StringType, target: NumericType) => Cast(e, target)
+        case (StringType, DateType) => Cast(e, DateType)
+        case (StringType, TimestampType) => Cast(e, TimestampType)
+        case (StringType, BinaryType) => Cast(e, BinaryType)
+        case (any, StringType) if any != StringType => Cast(e, StringType)
 
         // Else, just return the same input expression
-        case (in, _) => in
+        case _ => e
       }
     }
   }

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/ExpectsInputTypes.scala

@@ -37,7 +37,7 @@ trait ExpectsInputTypes { self: Expression =>
   def inputTypes: Seq[AbstractDataType]
 
   override def checkInputDataTypes(): TypeCheckResult = {
-    // We will do the type checking in `HiveTypeCoercion`, so always returning success here.
+    // TODO: implement proper type checking.
     TypeCheckResult.TypeCheckSuccess
   }
 }

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/predicates.scala

@@ -122,7 +122,7 @@ case class InSet(value: Expression, hset: Set[Any])
 case class And(left: Expression, right: Expression)
   extends BinaryExpression with Predicate with ExpectsInputTypes {
 
-  override def toString: String = s"$left && $right"
+  override def toString: String = s"($left && $right)"
 
   override def inputTypes: Seq[DataType] = Seq(BooleanType, BooleanType)
 
@@ -171,7 +171,7 @@ case class And(left: Expression, right: Expression)
 case class Or(left: Expression, right: Expression)
   extends BinaryExpression with Predicate with ExpectsInputTypes {
 
-  override def toString: String = s"$left || $right"
+  override def toString: String = s"($left || $right)"
 
   override def inputTypes: Seq[DataType] = Seq(BooleanType, BooleanType)
 

sql/catalyst/src/main/scala/org/apache/spark/sql/types/AbstractDataType.scala

@@ -28,7 +28,7 @@ import org.apache.spark.util.Utils
  * A non-concrete data type, reserved for internal uses.
  */
 private[sql] abstract class AbstractDataType {
-  def defaultConcreteType: DataType
+  private[sql] def defaultConcreteType: DataType
 }
 
 
@@ -50,8 +50,6 @@ protected[sql] abstract class AtomicType extends DataType {
 /**
  * :: DeveloperApi ::
  * Numeric data types.
- *
- * @group dataType
  */
 abstract class NumericType extends AtomicType {
   // Unfortunately we can't get this implicitly as that breaks Spark Serialization. In order for
@@ -73,7 +71,7 @@ private[sql] object NumericType extends AbstractDataType {
    */
   def unapply(e: Expression): Boolean = e.dataType.isInstanceOf[NumericType]
 
-  override def defaultConcreteType: DataType = IntegerType
+  private[sql] override def defaultConcreteType: DataType = IntegerType
 }
 
 
@@ -87,7 +85,7 @@ private[sql] object IntegralType extends AbstractDataType {
    */
   def unapply(e: Expression): Boolean = e.dataType.isInstanceOf[IntegralType]
 
-  override def defaultConcreteType: DataType = IntegerType
+  private[sql] override def defaultConcreteType: DataType = IntegerType
 }
 
 
@@ -106,7 +104,7 @@ private[sql] object FractionalType extends AbstractDataType {
    */
   def unapply(e: Expression): Boolean = e.dataType.isInstanceOf[FractionalType]
 
-  override def defaultConcreteType: DataType = DoubleType
+  private[sql] override def defaultConcreteType: DataType = DoubleType
 }
 
 

sql/catalyst/src/main/scala/org/apache/spark/sql/types/ArrayType.scala

@@ -22,9 +22,11 @@ import org.json4s.JsonDSL._
 import org.apache.spark.annotation.DeveloperApi
 
 
-object ArrayType {
+object ArrayType extends AbstractDataType {
   /** Construct a [[ArrayType]] object with the given element type. The `containsNull` is true. */
   def apply(elementType: DataType): ArrayType = ArrayType(elementType, containsNull = true)
+
+  override def defaultConcreteType: DataType = ArrayType(NullType, containsNull = true)
 }
 
 
@@ -41,8 +43,6 @@ object ArrayType {
  *
  * @param elementType The data type of values.
  * @param containsNull Indicates if values have `null` values
- *
- * @group dataType
  */
 @DeveloperApi
 case class ArrayType(elementType: DataType, containsNull: Boolean) extends DataType {

sql/catalyst/src/main/scala/org/apache/spark/sql/types/BinaryType.scala

@@ -29,8 +29,6 @@ import org.apache.spark.sql.catalyst.util.TypeUtils
  * :: DeveloperApi ::
  * The data type representing `Array[Byte]` values.
  * Please use the singleton [[DataTypes.BinaryType]].
- *
- * @group dataType
  */
 @DeveloperApi
 class BinaryType private() extends AtomicType {

sql/catalyst/src/main/scala/org/apache/spark/sql/types/BooleanType.scala

@@ -27,8 +27,6 @@ import org.apache.spark.sql.catalyst.ScalaReflectionLock
 /**
  * :: DeveloperApi ::
  * The data type representing `Boolean` values. Please use the singleton [[DataTypes.BooleanType]].
- *
- *@group dataType
  */
 @DeveloperApi
 class BooleanType private() extends AtomicType {

sql/catalyst/src/main/scala/org/apache/spark/sql/types/ByteType.scala

@@ -27,8 +27,6 @@ import org.apache.spark.sql.catalyst.ScalaReflectionLock
 /**
  * :: DeveloperApi ::
  * The data type representing `Byte` values. Please use the singleton [[DataTypes.ByteType]].
- *
- * @group dataType
  */
 @DeveloperApi
 class ByteType private() extends IntegralType {

sql/catalyst/src/main/scala/org/apache/spark/sql/types/DataType.scala

@@ -31,8 +31,6 @@ import org.apache.spark.sql.catalyst.expressions.Expression
 /**
  * :: DeveloperApi ::
  * The base type of all Spark SQL data types.
- *
- * @group dataType
  */
 @DeveloperApi
 abstract class DataType extends AbstractDataType {

sql/catalyst/src/main/scala/org/apache/spark/sql/types/DateType.scala

@@ -26,10 +26,11 @@ import org.apache.spark.sql.catalyst.ScalaReflectionLock
 
 /**
  * :: DeveloperApi ::
- * The data type representing `java.sql.Date` values.
+ * A date type, supporting "0001-01-01" through "9999-12-31".
+ *
  * Please use the singleton [[DataTypes.DateType]].
  *
- * @group dataType
+ * Internally, this is represented as the number of days from epoch (1970-01-01 00:00:00 UTC).
  */
 @DeveloperApi
 class DateType private() extends AtomicType {