Rename ExistingRDD to ExternalRDD.

Author: ueshin

sql/core/src/main/scala/org/apache/spark/sql/SparkSession.scala

@@ -238,7 +238,7 @@ class SparkSession private(
   def createDataFrame[A <: Product : TypeTag](rdd: RDD[A]): DataFrame = {
     SparkSession.setActiveSession(this)
     val encoder = Encoders.product[A]
-    Dataset.ofRows(self, ExistingRDD(rdd)(self)(encoder))
+    Dataset.ofRows(self, ExternalRDD(rdd)(self)(encoder))
   }
 
   /**
@@ -423,7 +423,7 @@ class SparkSession private(
    */
   @Experimental
   def createDataset[T : Encoder](data: RDD[T]): Dataset[T] = {
-    Dataset[T](self, ExistingRDD(data)(self))
+    Dataset[T](self, ExternalRDD(data)(self))
   }
 
   /**

sql/core/src/main/scala/org/apache/spark/sql/execution/ExistingRDD.scala

@@ -74,28 +74,28 @@ object RDDConversions {
   }
 }
 
-private[sql] object ExistingRDD {
+private[sql] object ExternalRDD {
 
   def apply[T: Encoder](rdd: RDD[T])(session: SparkSession): LogicalPlan = {
-    val exisitingRdd = ExistingRDD(CatalystSerde.generateObjAttr[T], rdd)(session)
-    CatalystSerde.serialize[T](exisitingRdd)
+    val externalRdd = ExternalRDD(CatalystSerde.generateObjAttr[T], rdd)(session)
+    CatalystSerde.serialize[T](externalRdd)
   }
 }
 
 /** Logical plan node for scanning data from an RDD. */
-private[sql] case class ExistingRDD[T](
+private[sql] case class ExternalRDD[T](
     outputObjAttr: Attribute,
     rdd: RDD[T])(session: SparkSession)
   extends LeafNode with ObjectProducer with MultiInstanceRelation {
 
   override protected final def otherCopyArgs: Seq[AnyRef] = session :: Nil
 
-  override def newInstance(): ExistingRDD.this.type =
-    ExistingRDD(outputObjAttr.newInstance(), rdd)(session).asInstanceOf[this.type]
+  override def newInstance(): ExternalRDD.this.type =
+    ExternalRDD(outputObjAttr.newInstance(), rdd)(session).asInstanceOf[this.type]
 
   override def sameResult(plan: LogicalPlan): Boolean = {
     plan.canonicalized match {
-      case ExistingRDD(_, otherRDD) => rdd.id == otherRDD.id
+      case ExternalRDD(_, otherRDD) => rdd.id == otherRDD.id
       case _ => false
     }
   }
@@ -110,7 +110,7 @@ private[sql] case class ExistingRDD[T](
 }
 
 /** Physical plan node for scanning data from an RDD. */
-private[sql] case class ExistingRDDScanExec[T](
+private[sql] case class ExternalRDDScanExec[T](
     outputObjAttr: Attribute,
     rdd: RDD[T]) extends LeafExecNode with ObjectProducerExec {
 

sql/core/src/main/scala/org/apache/spark/sql/execution/SparkStrategies.scala

@@ -409,7 +409,7 @@ private[sql] abstract class SparkStrategies extends QueryPlanner[SparkPlan] {
       case logical.RepartitionByExpression(expressions, child, nPartitions) =>
         exchange.ShuffleExchange(HashPartitioning(
           expressions, nPartitions.getOrElse(numPartitions)), planLater(child)) :: Nil
-      case ExistingRDD(outputObjAttr, rdd) => ExistingRDDScanExec(outputObjAttr, rdd) :: Nil
+      case ExternalRDD(outputObjAttr, rdd) => ExternalRDDScanExec(outputObjAttr, rdd) :: Nil
       case LogicalRDD(output, rdd) => RDDScanExec(output, rdd, "ExistingRDD") :: Nil
       case BroadcastHint(child) => planLater(child) :: Nil
       case _ => Nil